Add webhooks for OURA

auth/service/service/service.go

@@ -5,7 +5,11 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/tidepool-org/platform/customerio"
 	"github.com/tidepool-org/platform/mailer"
+	"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"
 
@@ -37,6 +41,10 @@ import (
 	dexcomProvider "github.com/tidepool-org/platform/dexcom/provider"
 	"github.com/tidepool-org/platform/errors"
 	"github.com/tidepool-org/platform/events"
+	jotformAPI "github.com/tidepool-org/platform/oura/jotform/api"
+	shopifyAPI "github.com/tidepool-org/platform/oura/shopify/api"
+	shopifyClient "github.com/tidepool-org/platform/oura/shopify/client"
+
 	"github.com/tidepool-org/platform/log"
 	oauthProvider "github.com/tidepool-org/platform/oauth/provider"
 	"github.com/tidepool-org/platform/platform"
@@ -64,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 {
@@ -134,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
 	}
@@ -152,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
 	}
@@ -253,6 +273,87 @@ func (s *Service) terminateDomain() {
 	}
 }
 
+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 user client")
+	}
+	return nil
+}
+
+func (s *Service) initializeShopifyClient() error {
+	shopifyConfig := shopify.ClientConfig{}
+	if err := envconfig.Process("", &shopifyConfig); err != nil {
+		return errors.Wrap(err, "unable to load shopify config")
+	}
+
+	var err error
+	s.shopifyClient, err = shopifyClient.New(context.Background(), shopifyConfig)
+	if err != nil {
+		return errors.Wrap(err, "unable to create shopify client")
+	}
+
+	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")
+	}
+
+	var err error
+	s.customerIOClient, err = customerio.NewClient(customerIOConfig, s.Logger())
+	if err != nil {
+		return errors.Wrap(err, "unable to create customerio client")
+	}
+
+	return nil
+}
+
+func (s *Service) createJotformRouter() (*jotformAPI.Router, error) {
+	jotformConfig := jotform.Config{}
+	if err := envconfig.Process("", &jotformConfig); err != nil {
+		return nil, errors.Wrap(err, "unable to load jotform 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")
+	}
+
+	jotformRouter, err := jotformAPI.NewRouter(webhookProcessor)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create jotform router")
+	}
+
+	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 nil, errors.Wrap(err, "unable to create fulfillment event processor")
+	}
+
+	ordersCreateEventProcessor, err := shopify.NewOrdersCreateEventProcessor(s.Logger(), s.customerIOClient)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create orders create event processor")
+	}
+
+	shopifyRouter, err := shopifyAPI.NewRouter(fulfillmentEventProcessor, ordersCreateEventProcessor)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create shopify router")
+	}
+
+	return shopifyRouter, nil
+}
+
 func (s *Service) initializeRouter() error {
 	s.Logger().Debug("Creating api router")
 
@@ -275,9 +376,23 @@ func (s *Service) initializeRouter() error {
 		return errors.Wrap(err, "unable to create consent router")
 	}
 
+	s.Logger().Debug("Creating jotform router")
+
+	jotformRouter, err := s.createJotformRouter()
+	if err != nil {
+		return errors.Wrap(err, "unable to create jotform router")
+	}
+
+	s.Logger().Debug("Creating shopify router")
+
+	shopifyRouter, err := s.createShopifyRouter()
+	if err != nil {
+		return errors.Wrap(err, "unable to create shopify router")
+	}
+
 	s.Logger().Debug("Initializing routers")
 
-	if err = s.API().InitializeRouters(apiRouter, v1Router, consentV1Router); err != nil {
+	if err = s.API().InitializeRouters(apiRouter, v1Router, consentV1Router, jotformRouter, shopifyRouter); err != nil {
 		return errors.Wrap(err, "unable to initialize routers")
 	}
 
@@ -362,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"`
+}