Add webhooks for OURA

auth/service/service/service.go

@@ -5,10 +5,11 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/tidepool-org/platform/customerio"
 	"github.com/tidepool-org/platform/mailer"
-	"github.com/tidepool-org/platform/oura/customerio"
 	"github.com/tidepool-org/platform/oura/jotform"
 	"github.com/tidepool-org/platform/oura/shopify"
+	"github.com/tidepool-org/platform/user"
 
 	userClient "github.com/tidepool-org/platform/user/client"
 
@@ -71,21 +72,24 @@ func (c *confirmationClientConfig) Load() error {
 type Service struct {
 	*serviceService.Service
 	domain                         string
+	appValidator                   *appvalidate.Validator
+	authClient                     *Client
 	authStore                      *authStoreMongo.Store
-	workStructuredStore            *workStoreStructuredMongo.Store
+	confirmationClient             confirmationClient.ClientWithResponsesInterface
+	customerIOClient               *customerio.Client
 	dataClient                     dataClient.Client
 	dataSourceClient               *dataSourceClient.Client
-	confirmationClient             confirmationClient.ClientWithResponsesInterface
-	taskClient                     task.Client
-	workClient                     *workService.Client
-	providerFactory                *providerFactory.Factory
-	authClient                     *Client
-	userEventsHandler              events.Runner
 	deviceCheck                    apple.DeviceCheck
-	appValidator                   *appvalidate.Validator
 	partnerSecrets                 *appvalidate.PartnerSecrets
+	providerFactory                *providerFactory.Factory
+	shopifyClient                  shopify.Client
+	taskClient                     task.Client
 	twiistServiceAccountAuthorizer auth.ServiceAccountAuthorizer
+	userEventsHandler              events.Runner
+	userClient                     user.Client
 	consentService                 consent.Service
+	workClient                     *workService.Client
+	workStructuredStore            *workStoreStructuredMongo.Store
 }
 
 func New() *Service {
@@ -141,6 +145,9 @@ func (s *Service) Initialize(provider application.Provider) error {
 	if err := s.initializeAuthClient(); err != nil {
 		return err
 	}
+	if err := s.initializeUserClient(); err != nil {
+		return err
+	}
 	if err := s.initializeConsentService(); err != nil {
 		return err
 	}
@@ -159,6 +166,12 @@ func (s *Service) Initialize(provider application.Provider) error {
 	if err := s.initializeTwiistServiceAccountAuthorizer(); err != nil {
 		return err
 	}
+	if err := s.initializeCustomerIOClient(); err != nil {
+		return err
+	}
+	if err := s.initializeShopifyClient(); err != nil {
+		return err
+	}
 	if err := s.initializeRouter(); err != nil {
 		return err
 	}
@@ -260,85 +273,119 @@ func (s *Service) terminateDomain() {
 	}
 }
 
-func (s *Service) initializeRouter() error {
-	s.Logger().Debug("Creating api router")
-
-	apiRouter, err := authServiceApi.NewRouter(s)
+func (s *Service) initializeUserClient() error {
+	s.Logger().Debug("Initializing user client")
+	var err error
+	s.userClient, err = userClient.NewDefaultClient(userClient.Params{
+		ConfigReporter: s.ConfigReporter(),
+		Logger:         s.Logger(),
+		UserAgent:      s.UserAgent(),
+	})
 	if err != nil {
-		return errors.Wrap(err, "unable to create api router")
+		return errors.Wrap(err, "unable to create user client")
 	}
+	return nil
+}
 
-	s.Logger().Debug("Creating v1 router")
+func (s *Service) initializeShopifyClient() error {
+	shopifyConfig := shopify.ClientConfig{}
+	if err := envconfig.Process("", &shopifyConfig); err != nil {
+		return errors.Wrap(err, "unable to load shopify config")
+	}
 
-	v1Router, err := authServiceApiV1.NewRouter(s)
+	var err error
+	s.shopifyClient, err = shopifyClient.New(context.Background(), shopifyConfig)
 	if err != nil {
-		return errors.Wrap(err, "unable to create v1 router")
+		return errors.Wrap(err, "unable to create shopify client")
 	}
 
-	s.Logger().Debug("Creating consent router")
+	return nil
+}
+func (s *Service) initializeCustomerIOClient() error {
+	customerIOConfig := customerio.Config{}
+	if err := envconfig.Process("", &customerIOConfig); err != nil {
+		return errors.Wrap(err, "unable to load customerio config")
+	}
 
-	consentV1Router, err := consentApiV1.NewRouter(s.consentService)
+	var err error
+	s.customerIOClient, err = customerio.NewClient(customerIOConfig, s.Logger())
 	if err != nil {
-		return errors.Wrap(err, "unable to create consent router")
+		return errors.Wrap(err, "unable to create customerio client")
 	}
 
-	s.Logger().Debug("Creating jotform router")
+	return nil
+}
 
+func (s *Service) createJotformRouter() (*jotformAPI.Router, error) {
 	jotformConfig := jotform.Config{}
 	if err := envconfig.Process("", &jotformConfig); err != nil {
-		return errors.Wrap(err, "unable to load jotform config")
+		return nil, errors.Wrap(err, "unable to load jotform config")
 	}
 
-	customerIOConfig := customerio.Config{}
-	if err := envconfig.Process("", &customerIOConfig); err != nil {
-		return errors.Wrap(err, "unable to load customerio config")
+	webhookProcessor, err := jotform.NewWebhookProcessor(jotformConfig, s.Logger(), s.consentService, s.customerIOClient, s.userClient, s.shopifyClient)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create jotform webhook processor")
 	}
-	customerIOClient, err := customerio.NewClient(customerIOConfig, s.Logger())
+
+	jotformRouter, err := jotformAPI.NewRouter(webhookProcessor)
 	if err != nil {
-		return errors.Wrap(err, "unable to create customerio client")
+		return nil, errors.Wrap(err, "unable to create jotform router")
 	}
 
-	s.Logger().Debug("Initializing user client")
-	usrClient, err := userClient.NewDefaultClient(userClient.Params{
-		ConfigReporter: s.ConfigReporter(),
-		Logger:         s.Logger(),
-		UserAgent:      s.UserAgent(),
-	})
+	return jotformRouter, nil
+}
+
+func (s *Service) createShopifyRouter() (*shopifyAPI.Router, error) {
+	fulfillmentEventProcessor, err := shopify.NewFulfillmentEventProcessor(s.Logger(), s.customerIOClient, s.shopifyClient, s.AuthServiceClient())
 	if err != nil {
-		return errors.Wrap(err, "unable to create user client")
+		return nil, errors.Wrap(err, "unable to create fulfillment event processor")
 	}
 
-	shopifyConfig := shopify.ClientConfig{}
-	if err := envconfig.Process("", &shopifyConfig); err != nil {
-		return errors.Wrap(err, "unable to load shopify config")
+	ordersCreateEventProcessor, err := shopify.NewOrdersCreateEventProcessor(s.Logger(), s.customerIOClient)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create orders create event processor")
 	}
 
-	shopifyClnt, err := shopifyClient.New(context.Background(), shopifyConfig)
+	shopifyRouter, err := shopifyAPI.NewRouter(fulfillmentEventProcessor, ordersCreateEventProcessor)
 	if err != nil {
-		return errors.Wrap(err, "unable to create shopify client")
+		return nil, errors.Wrap(err, "unable to create shopify router")
 	}
 
-	webhookProcessor, err := jotform.NewWebhookProcessor(jotformConfig, s.Logger(), s.consentService, customerIOClient, usrClient, shopifyClnt)
+	return shopifyRouter, nil
+}
+
+func (s *Service) initializeRouter() error {
+	s.Logger().Debug("Creating api router")
+
+	apiRouter, err := authServiceApi.NewRouter(s)
 	if err != nil {
-		return errors.Wrap(err, "unable to create jotform webhook processor")
+		return errors.Wrap(err, "unable to create api router")
 	}
 
-	jotformRouter, err := jotformAPI.NewRouter(webhookProcessor)
+	s.Logger().Debug("Creating v1 router")
+
+	v1Router, err := authServiceApiV1.NewRouter(s)
 	if err != nil {
-		return errors.Wrap(err, "unable to create jotform router")
+		return errors.Wrap(err, "unable to create v1 router")
 	}
 
-	fulfillmentEventProcessor, err := shopify.NewFulfillmentEventProcessor(s.Logger(), customerIOClient, shopifyClnt, s.AuthServiceClient())
+	s.Logger().Debug("Creating consent router")
+
+	consentV1Router, err := consentApiV1.NewRouter(s.consentService)
 	if err != nil {
-		return errors.Wrap(err, "unable to create fulfillment event processor")
+		return errors.Wrap(err, "unable to create consent router")
 	}
 
-	ordersCreateEventProcessor, err := shopify.NewOrdersCreateEventProcessor(s.Logger(), customerIOClient)
+	s.Logger().Debug("Creating jotform router")
+
+	jotformRouter, err := s.createJotformRouter()
 	if err != nil {
-		return errors.Wrap(err, "unable to create orders create event processor")
+		return errors.Wrap(err, "unable to create jotform router")
 	}
 
-	shopifyRouter, err := shopifyAPI.NewRouter(fulfillmentEventProcessor, ordersCreateEventProcessor)
+	s.Logger().Debug("Creating shopify router")
+
+	shopifyRouter, err := s.createShopifyRouter()
 	if err != nil {
 		return errors.Wrap(err, "unable to create shopify router")
 	}
@@ -430,24 +477,14 @@ func (s *Service) initializeConsentService() error {
 		return errors.Wrap(err, "unable to create bddp sharer")
 	}
 
-	s.Logger().Debug("Initializing user client")
-	usrClient, err := userClient.NewDefaultClient(userClient.Params{
-		ConfigReporter: s.ConfigReporter(),
-		Logger:         s.Logger(),
-		UserAgent:      s.UserAgent(),
-	})
-	if err != nil {
-		return errors.Wrap(err, "unable to create user client")
-	}
-
 	s.Logger().Debug("Initializing mailer")
 	mailr, err := mailer.Client()
 	if err != nil {
 		return errors.Wrap(err, "unable to create mailer")
 	}
 
 	s.Logger().Debug("Initializing consent mailer")
-	consentMailer, err := consentService.NewConsentMailer(mailr, usrClient, s.Logger())
+	consentMailer, err := consentService.NewConsentMailer(mailr, s.userClient, s.Logger())
 	if err != nil {
 		return errors.Wrap(err, "unable to create consent mailer")
 	}

customerio/client.go

@@ -0,0 +1,96 @@
+package customerio
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/tidepool-org/platform/client"
+	"github.com/tidepool-org/platform/errors"
+	"github.com/tidepool-org/platform/log"
+	"github.com/tidepool-org/platform/request"
+)
+
+type Client struct {
+	appClient   *client.Client
+	trackClient *client.Client
+	config      Config
+	logger      log.Logger
+	httpClient  *http.Client
+}
+
+type Config struct {
+	AppAPIBaseURL   string `envconfig:"TIDEPOOL_CUSTOMERIO_APP_API_BASE_URL" default:"https://api.customer.io"`
+	AppAPIKey       string `envconfig:"TIDEPOOL_CUSTOMERIO_APP_API_KEY"`
+	SiteID          string `envconfig:"TIDEPOOL_CUSTOMERIO_SITE_ID"`
+	TrackAPIBaseURL string `envconfig:"TIDEPOOL_CUSTOMERIO_TRACK_API_BASE_URL" default:"https://track.customer.io"`
+	TrackAPIKey     string `envconfig:"TIDEPOOL_CUSTOMERIO_TRACK_API_KEY"`
+}
+
+func NewClient(config Config, logger log.Logger) (*Client, error) {
+	errorParser := newErrorResponseParser()
+
+	appClient, err := client.NewWithErrorParser(&client.Config{
+		Address: config.AppAPIBaseURL,
+	}, errorParser)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create app API client")
+	}
+
+	trackClient, err := client.NewWithErrorParser(&client.Config{
+		Address: config.TrackAPIBaseURL,
+	}, errorParser)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create track API client")
+	}
+
+	return &Client{
+		appClient:   appClient,
+		trackClient: trackClient,
+		config:      config,
+		logger:      logger,
+		httpClient:  http.DefaultClient,
+	}, nil
+}
+
+// appAPIAuthMutator returns a request mutator for App API authentication (Bearer token)
+func (c *Client) appAPIAuthMutator() *request.HeaderMutator {
+	return request.NewHeaderMutator("Authorization", fmt.Sprintf("Bearer %s", c.config.AppAPIKey))
+}
+
+// trackAPIAuthMutator returns a request mutator for Track API authentication (Basic auth)
+func (c *Client) trackAPIAuthMutator() *request.HeaderMutator {
+	auth := c.config.SiteID + ":" + c.config.TrackAPIKey
+	basicAuth := "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
+	return request.NewHeaderMutator("Authorization", basicAuth)
+}
+
+// errorResponseParser implements client.ErrorResponseParser for Customer.io API errors
+type errorResponseParser struct{}
+
+func newErrorResponseParser() *errorResponseParser {
+	return &errorResponseParser{}
+}
+
+func (p *errorResponseParser) ParseErrorResponse(ctx context.Context, res *http.Response, req *http.Request) error {
+	var errResp errorResponse
+	if err := json.NewDecoder(res.Body).Decode(&errResp); err != nil {
+		return nil
+	}
+
+	if len(errResp.Errors) > 0 {
+		return errors.Newf("API error (status %d): %s", res.StatusCode, errResp.Errors[0].Message)
+	}
+
+	return nil
+}
+
+type errorResponse struct {
+	Errors []struct {
+		Reason  string `json:"reason,omitempty"`
+		Field   string `json:"field,omitempty"`
+		Message string `json:"message,omitempty"`
+	} `json:"errors,omitempty"`
+}