Send and receive SMS messages using your Android phone programmatically via a simple HTTP API
Create the API's for handing phone API keys
Acho Arnold88599249400c
diff --git a/api/pkg/di/container.go b/api/pkg/di/container.goindex 0ec2d426..51a0b303 100644--- a/api/pkg/di/container.go+++ b/api/pkg/di/container.go@@ -145,6 +145,9 @@ func NewContainer(projectID string, version string) (container *Container) {container.RegisterDiscordRoutes()container.RegisterDiscordListeners()+ container.RegisterPhoneAPIKeyRoutes()+ container.RegisterPhoneAPIKeyListeners()+container.RegisterMarketingListeners()// this has to be last since it registers the /* route@@ -191,18 +194,18 @@ func (container *Container) BearerAPIKeyMiddleware() fiber.Handler {return middlewares.BearerAPIKeyAuth(container.Logger(), container.Tracer(), container.UserRepository())}+// PhoneAPIKeyMiddleware creates a new instance of middlewares.BearerAPIKeyAuth+func (container *Container) PhoneAPIKeyMiddleware() fiber.Handler {+ container.logger.Debug("creating middlewares.PhoneAPIKeyMiddleware")+ return middlewares.PhoneAPIKeyAuth(container.Logger(), container.Tracer(), container.PhoneAPIKeyRepository())+}+// AuthenticatedMiddleware creates a new instance of middlewares.Authenticatedfunc (container *Container) AuthenticatedMiddleware() fiber.Handler {container.logger.Debug("creating middlewares.Authenticated")return middlewares.Authenticated(container.Tracer())}-// AuthRouter creates router for authenticated requests-func (container *Container) AuthRouter() fiber.Router {- container.logger.Debug("creating authRouter")- return container.App().Group("v1").Use(container.AuthenticatedMiddleware())-}-// Logger creates a new instance of telemetry.Loggerfunc (container *Container) Logger(skipFrameCount ...int) telemetry.Logger {container.logger.Debug("creating telemetry.Logger")@@ -686,6 +689,17 @@ func (container *Container) MessageRepository() (repository repositories.Message)}+// PhoneAPIKeyRepository creates a new instance of repositories.PhoneAPIKeyRepository+func (container *Container) PhoneAPIKeyRepository() (repository repositories.PhoneAPIKeyRepository) {+ container.logger.Debug("creating GORM repositories.PhoneAPIKeyRepository")+ return repositories.NewGormPhoneAPIKeyRepository(+ container.Logger(),+ container.Tracer(),+ container.DB(),+ container.UserRistrettoCache(),+ )+}+// Integration3CXRepository creates a new instance of repositories.Integration3CxRepositoryfunc (container *Container) Integration3CXRepository() (repository repositories.Integration3CxRepository) {container.logger.Debug("creating GORM repositories.Integration3CxRepository")@@ -1072,6 +1086,18 @@ func (container *Container) Integration3CXHandler() (handler *handlers.Integrati)}+// PhoneAPIKeyHandler creates a new instance of handlers.PhoneAPIKeyHandler+func (container *Container) PhoneAPIKeyHandler() (handler *handlers.PhoneAPIKeyHandler) {+ container.logger.Debug(fmt.Sprintf("creating %T", handler))++ return handlers.NewPhoneAPIKeyHandler(+ container.Logger(),+ container.Tracer(),+ container.PhoneAPIKeyHandlerValidator(),+ container.PhoneAPIKeyService(),+ )+}+// DiscordHandler creates a new instance of handlers.DiscordHandlerfunc (container *Container) DiscordHandler() (handler *handlers.DiscordHandler) {container.logger.Debug(fmt.Sprintf("creating %T", handler))@@ -1097,6 +1123,15 @@ func (container *Container) LemonsqueezyHandlerValidator() (validator *validator)}+// PhoneAPIKeyHandlerValidator creates a new instance of validators.PhoneAPIKeyHandlerValidator+func (container *Container) PhoneAPIKeyHandlerValidator() (validator *validators.PhoneAPIKeyHandlerValidator) {+ container.logger.Debug(fmt.Sprintf("creating %T", validator))+ return validators.NewPhoneAPIKeyHandlerValidator(+ container.Logger(),+ container.Tracer(),+ )+}+// LemonsqueezyClient creates a new instance of lemonsqueezy.Clientfunc (container *Container) LemonsqueezyClient() (client *lemonsqueezy.Client) {container.logger.Debug(fmt.Sprintf("creating %T", client))@@ -1129,6 +1164,12 @@ func (container *Container) RegisterIntegration3CXRoutes() {container.Integration3CXHandler().RegisterRoutes(container.App(), container.BearerAPIKeyMiddleware(), container.AuthenticatedMiddleware())}+// RegisterPhoneAPIKeyRoutes registers routes for the /phone-api-key prefix+func (container *Container) RegisterPhoneAPIKeyRoutes() {+ container.logger.Debug(fmt.Sprintf("registering [%T] routes", &handlers.Integration3CXHandler{}))+ container.PhoneAPIKeyHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())+}+// RegisterDiscordRoutes registers routes for the /discord prefixfunc (container *Container) RegisterDiscordRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.DiscordHandler{}))@@ -1261,6 +1302,20 @@ func (container *Container) RegisterIntegration3CXListeners() {}}+// RegisterPhoneAPIKeyListeners registers event listeners for listeners.PhoneAPIKeyListener+func (container *Container) RegisterPhoneAPIKeyListeners() {+ container.logger.Debug(fmt.Sprintf("registering listeners for %T", listeners.PhoneAPIKeyListener{}))+ _, routes := listeners.NewPhoneAPIKeyListener(+ container.Logger(),+ container.Tracer(),+ container.PhoneAPIKeyService(),+ )++ for event, handler := range routes {+ container.EventDispatcher().Subscribe(event, handler)+ }+}+// RegisterWebhookListeners registers event listeners for listeners.WebhookListenerfunc (container *Container) RegisterWebhookListeners() {container.logger.Debug(fmt.Sprintf("registering listeners for %T", listeners.WebhookListener{}))@@ -1287,6 +1342,17 @@ func (container *Container) MessageService() (service *services.MessageService))}+// PhoneAPIKeyService creates a new instance of services.PhoneAPIKeyService+func (container *Container) PhoneAPIKeyService() (service *services.PhoneAPIKeyService) {+ container.logger.Debug(fmt.Sprintf("creating %T", service))+ return services.NewPhoneAPIKeyService(+ container.Logger(),+ container.Tracer(),+ container.PhoneRepository(),+ container.PhoneAPIKeyRepository(),+ )+}+// NotificationService creates a new instance of services.PhoneNotificationServicefunc (container *Container) NotificationService() (service *services.PhoneNotificationService) {container.logger.Debug(fmt.Sprintf("creating %T", service))@@ -1303,31 +1369,33 @@ func (container *Container) NotificationService() (service *services.PhoneNotifi// RegisterMessageRoutes registers routes for the /messages prefixfunc (container *Container) RegisterMessageRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.MessageHandler{}))- container.MessageHandler().RegisterRoutes(container.AuthRouter())+ container.MessageHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())+ container.MessageHandler().RegisterPhoneAPIKeyRoutes(container.App(), container.PhoneAPIKeyMiddleware(), container.AuthenticatedMiddleware())}// RegisterBulkMessageRoutes registers routes for the /bulk-messages prefixfunc (container *Container) RegisterBulkMessageRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.BulkMessageHandler{}))- container.BulkMessageHandler().RegisterRoutes(container.AuthRouter())+ container.BulkMessageHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())}// RegisterMessageThreadRoutes registers routes for the /message-threads prefixfunc (container *Container) RegisterMessageThreadRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.MessageThreadHandler{}))- container.MessageThreadHandler().RegisterRoutes(container.AuthRouter())+ container.MessageThreadHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())}// RegisterHeartbeatRoutes registers routes for the /heartbeats prefixfunc (container *Container) RegisterHeartbeatRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.HeartbeatHandler{}))- container.HeartbeatHandler().RegisterRoutes(container.AuthRouter())+ container.HeartbeatHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())+ container.HeartbeatHandler().RegisterPhoneAPIKeyRoutes(container.App(), container.PhoneAPIKeyMiddleware(), container.AuthenticatedMiddleware())}// RegisterBillingRoutes registers routes for the /billing prefixfunc (container *Container) RegisterBillingRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.BillingHandler{}))- container.BillingHandler().RegisterRoutes(container.AuthRouter())+ container.BillingHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())}// RegisterWebhookRoutes registers routes for the /webhooks prefix@@ -1339,19 +1407,20 @@ func (container *Container) RegisterWebhookRoutes() {// RegisterPhoneRoutes registers routes for the /phone prefixfunc (container *Container) RegisterPhoneRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.PhoneHandler{}))- container.PhoneHandler().RegisterRoutes(container.AuthRouter())+ container.PhoneHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())+ container.PhoneHandler().RegisterPhoneAPIKeyRoutes(container.App(), container.PhoneAPIKeyMiddleware(), container.AuthenticatedMiddleware())}// RegisterUserRoutes registers routes for the /users prefixfunc (container *Container) RegisterUserRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.UserHandler{}))- container.UserHandler().RegisterRoutes(container.AuthRouter())+ container.UserHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())}// RegisterEventRoutes registers routes for the /events prefixfunc (container *Container) RegisterEventRoutes() {container.logger.Debug(fmt.Sprintf("registering %T routes", &handlers.EventsHandler{}))- container.EventsHandler().RegisterRoutes(container.AuthRouter())+ container.EventsHandler().RegisterRoutes(container.App(), container.AuthenticatedMiddleware())}// RegisterSwaggerRoutes registers routes for swaggerdiff --git a/api/pkg/events/phone_updated_event.go b/api/pkg/events/phone_updated_event.goindex 88fc6c9d..082aaa3a 100644--- a/api/pkg/events/phone_updated_event.go+++ b/api/pkg/events/phone_updated_event.go@@ -12,9 +12,10 @@ const EventTypePhoneUpdated = "phone.updated"// PhoneUpdatedPayload is the payload of the EventTypePhoneUpdated eventtype PhoneUpdatedPayload struct {- PhoneID uuid.UUID `json:"phone_id"`- UserID entities.UserID `json:"user_id"`- Timestamp time.Time `json:"timestamp"`- Owner string `json:"owner"`- SIM entities.SIM `json:"sim"`+ PhoneID uuid.UUID `json:"phone_id"`+ UserID entities.UserID `json:"user_id"`+ PhoneAPIKeyID *uuid.UUID `json:"phone_api_key_id"`+ Timestamp time.Time `json:"timestamp"`+ Owner string `json:"owner"`+ SIM entities.SIM `json:"sim"`}diff --git a/api/pkg/handlers/billing_handler.go b/api/pkg/handlers/billing_handler.goindex cd6d5713..4c0da0c2 100644--- a/api/pkg/handlers/billing_handler.go+++ b/api/pkg/handlers/billing_handler.go@@ -37,9 +37,9 @@ func NewBillingHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *BillingHandler) RegisterRoutes(router fiber.Router) {- router.Get("/billing/usage-history", h.UsageHistory)- router.Get("/billing/usage", h.Usage)+func (h *BillingHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Get("/billing/usage-history", h.computeRoute(middlewares, h.UsageHistory)...)+ router.Get("/billing/usage", h.computeRoute(middlewares, h.Usage)...)}// UsageHistory returns the usage history of a userdiff --git a/api/pkg/handlers/bulk_message_handler.go b/api/pkg/handlers/bulk_message_handler.goindex fa3cce82..d29a907d 100644--- a/api/pkg/handlers/bulk_message_handler.go+++ b/api/pkg/handlers/bulk_message_handler.go@@ -43,8 +43,8 @@ func NewBulkMessageHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *BulkMessageHandler) RegisterRoutes(router fiber.Router) {- router.Post("/bulk-messages", h.Store)+func (h *BulkMessageHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Post("/v1/bulk-messages", h.computeRoute(middlewares, h.Store)...)}// Store sends bulk SMS messages from a CSV file.diff --git a/api/pkg/handlers/events_handler.go b/api/pkg/handlers/events_handler.goindex 204fcc35..16d0325d 100644--- a/api/pkg/handlers/events_handler.go+++ b/api/pkg/handlers/events_handler.go@@ -37,8 +37,8 @@ func NewEventsHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *EventsHandler) RegisterRoutes(router fiber.Router) {- router.Post("/events", h.Dispatch)+func (h *EventsHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Post("/v1/events", h.computeRoute(middlewares, h.Dispatch)...)}// Dispatch a cloud eventdiff --git a/api/pkg/handlers/handler.go b/api/pkg/handlers/handler.goindex 55dfb353..e6d4cc09 100644--- a/api/pkg/handlers/handler.go+++ b/api/pkg/handlers/handler.go@@ -1,7 +1,10 @@package handlersimport (+ "fmt""net/url"+ "slices"+ "strings""github.com/NdoleStudio/httpsms/pkg/entities""github.com/NdoleStudio/httpsms/pkg/middlewares"@@ -35,6 +38,14 @@ func (h *handler) responseUnauthorized(c *fiber.Ctx) error {})}+func (h *handler) responsePhoneAPIKeyUnauthorized(c *fiber.Ctx, owner string, authCtx entities.AuthContext) error {+ return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{+ "status": "error",+ "message": "You are not authorized to carry out the request for this phone number",+ "data": fmt.Sprintf("The phone API key is does not have permission to carry out actions on the phone number [%s]. The API key is only configured for these phone numbers [%s]", owner, strings.Join(authCtx.PhoneNumbers, ",")),+ })+}+func (h *handler) responseForbidden(c *fiber.Ctx) error {return c.Status(fiber.StatusForbidden).JSON(fiber.Map{"status": "error",@@ -127,3 +138,11 @@ func (h *handler) mergeErrors(errors ...url.Values) url.Values {}return result}++func (h *handler) authorizePhoneAPIKey(c *fiber.Ctx, phoneNumber string) bool {+ user := h.userFromContext(c)+ if user.PhoneAPIKeyID == nil {+ return true+ }+ return slices.Contains(user.PhoneNumbers, phoneNumber)+}diff --git a/api/pkg/handlers/heartbeat_handler.go b/api/pkg/handlers/heartbeat_handler.goindex dc87d39d..e7fb7114 100644--- a/api/pkg/handlers/heartbeat_handler.go+++ b/api/pkg/handlers/heartbeat_handler.go@@ -39,10 +39,14 @@ func NewHeartbeatHandler(}}-// RegisterRoutes registers the routes for the MessageHandler-func (h *HeartbeatHandler) RegisterRoutes(router fiber.Router) {- router.Get("/heartbeats", h.Index)- router.Post("/heartbeats", h.Store)+// RegisterRoutes registers the routes for the HeartbeatHandler+func (h *HeartbeatHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Get("/heartbeats", h.computeRoute(middlewares, h.Index)...)+}++// RegisterPhoneAPIKeyRoutes registers the routes for the HeartbeatHandler+func (h *HeartbeatHandler) RegisterPhoneAPIKeyRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Post("/heartbeats", h.computeRoute(middlewares, h.Store)...)}// Index returns the heartbeats of a phone number@@ -124,6 +128,13 @@ func (h *HeartbeatHandler) Store(c *fiber.Ctx) error {return h.responseUnprocessableEntity(c, errors, "validation errors while storing heartbeat")}+ for _, phoneNumber := range request.PhoneNumbers {+ if !h.authorizePhoneAPIKey(c, phoneNumber) {+ ctxLogger.Warn(stacktrace.NewError(fmt.Sprintf("phone API Key ID [%s] is not authorized to store heartbeat for phone number [%s]", h.userFromContext(c).PhoneAPIKeyID, phoneNumber)))+ return h.responsePhoneAPIKeyUnauthorized(c, phoneNumber, h.userFromContext(c))+ }+ }+params := request.ToStoreParams(h.userFromContext(c), c.OriginalURL(), c.Get("X-Client-Version"))wg := sync.WaitGroup{}diff --git a/api/pkg/handlers/message_handler.go b/api/pkg/handlers/message_handler.goindex 55e574c3..758f4744 100644--- a/api/pkg/handlers/message_handler.go+++ b/api/pkg/handlers/message_handler.go@@ -48,16 +48,20 @@ func NewMessageHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *MessageHandler) RegisterRoutes(router fiber.Router) {- router.Post("/messages/send", h.PostSend)- router.Post("/messages/bulk-send", h.BulkSend)- router.Post("/messages/receive", h.PostReceive)- router.Post("/messages/calls/missed", h.PostCallMissed)- router.Get("/messages/outstanding", h.GetOutstanding)- router.Get("/messages", h.Index)- router.Get("/messages/search", h.Search)- router.Post("/messages/:messageID/events", h.PostEvent)- router.Delete("/messages/:messageID", h.Delete)+func (h *MessageHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Post("/v1/messages/send", h.computeRoute(middlewares, h.PostSend)...)+ router.Post("/v1/messages/bulk-send", h.computeRoute(middlewares, h.BulkSend)...)+ router.Get("/v1/messages", h.computeRoute(middlewares, h.Index)...)+ router.Get("/v1/messages/search", h.computeRoute(middlewares, h.Search)...)+ router.Delete("/v1/messages/:messageID", h.computeRoute(middlewares, h.Delete)...)+}++// RegisterPhoneAPIKeyRoutes registers the routes for the MessageHandler+func (h *MessageHandler) RegisterPhoneAPIKeyRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Post("/v1/messages/:messageID/events", h.computeRoute(middlewares, h.PostEvent)...)+ router.Post("/v1/messages/receive", h.computeRoute(middlewares, h.PostReceive)...)+ router.Post("/v1/messages/calls/missed", h.computeRoute(middlewares, h.PostCallMissed)...)+ router.Get("/v1/messages/outstanding", h.computeRoute(middlewares, h.GetOutstanding)...)}// PostSend a new entities.Message@@ -201,11 +205,11 @@ func (h *MessageHandler) GetOutstanding(c *fiber.Ctx) error {return h.responseUnprocessableEntity(c, errors, "validation errors while fetching outstanding messages")}- message, err := h.service.GetOutstanding(ctx, request.ToGetOutstandingParams(c.Path(), h.userIDFomContext(c), timestamp))+ message, err := h.service.GetOutstanding(ctx, request.ToGetOutstandingParams(c.Path(), h.userFromContext(c), timestamp))if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {- msg := fmt.Sprintf("outstanding message with id [%s] already fetched", request.MessageID)+ msg := fmt.Sprintf("Cannot find outstanding message with ID [%s]", request.MessageID)ctxLogger.Warn(stacktrace.Propagate(err, msg))- return h.responseNotFound(c, "outstanding message already processed")+ return h.responseNotFound(c, msg)}if err != nil {@@ -315,6 +319,11 @@ func (h *MessageHandler) PostEvent(c *fiber.Ctx) error {return h.responseInternalServerError(c)}+ if !h.authorizePhoneAPIKey(c, message.Owner) {+ ctxLogger.Warn(stacktrace.NewError(fmt.Sprintf("user with ID [%s] is not authorized to send event for message with ID [%s]", h.userIDFomContext(c), request.MessageID)))+ return h.responsePhoneAPIKeyUnauthorized(c, message.Owner, h.userFromContext(c))+ }+message, err = h.service.StoreEvent(ctx, message, request.ToMessageStoreEventParams(c.OriginalURL()))if err != nil {msg := fmt.Sprintf("cannot store event for message [%s] with paylod [%s]", request.MessageID, c.Body())@@ -362,6 +371,11 @@ func (h *MessageHandler) PostReceive(c *fiber.Ctx) error {return h.responsePaymentRequired(c, *msg)}+ if !h.authorizePhoneAPIKey(c, request.To) {+ ctxLogger.Warn(stacktrace.NewError(fmt.Sprintf("user with ID [%s] is not authorized to receive message to phone number [%s]", h.userIDFomContext(c), request.To)))+ return h.responsePhoneAPIKeyUnauthorized(c, request.To, h.userFromContext(c))+ }+message, err := h.service.ReceiveMessage(ctx, request.ToMessageReceiveParams(h.userIDFomContext(c), c.OriginalURL()))if err != nil {msg := fmt.Sprintf("cannot receive message with paylod [%s]", c.Body())@@ -454,6 +468,11 @@ func (h *MessageHandler) PostCallMissed(c *fiber.Ctx) error {return h.responseUnprocessableEntity(c, errors, "validation errors while storing missed call event")}+ if !h.authorizePhoneAPIKey(c, request.To) {+ ctxLogger.Warn(stacktrace.NewError(fmt.Sprintf("user with ID [%s] is not authorized to register missed phone call for phone number [%s]", h.userIDFomContext(c), request.To)))+ return h.responsePhoneAPIKeyUnauthorized(c, request.To, h.userFromContext(c))+ }+message, err := h.service.RegisterMissedCall(ctx, request.ToCallMissedParams(h.userIDFomContext(c), c.OriginalURL()))if err != nil {msg := fmt.Sprintf("cannot store missed call event for user [%s] with paylod [%s]", h.userIDFomContext(c), c.Body())diff --git a/api/pkg/handlers/message_thread_handler.go b/api/pkg/handlers/message_thread_handler.goindex 38282831..cd919254 100644--- a/api/pkg/handlers/message_thread_handler.go+++ b/api/pkg/handlers/message_thread_handler.go@@ -40,7 +40,7 @@ func NewMessageThreadHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *MessageThreadHandler) RegisterRoutes(router fiber.Router) {+func (h *MessageThreadHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {router.Get("/message-threads", h.Index)router.Put("/message-threads/:messageThreadID", h.Update)router.Delete("/message-threads/:messageThreadID", h.Delete)diff --git a/api/pkg/handlers/phone_api_key_handler.go b/api/pkg/handlers/phone_api_key_handler.goindex 227aa773..40b8aa1c 100644--- a/api/pkg/handlers/phone_api_key_handler.go+++ b/api/pkg/handlers/phone_api_key_handler.go@@ -17,11 +17,10 @@ import (// PhoneAPIKeyHandler handles phone API key http requeststype PhoneAPIKeyHandler struct {handler- logger telemetry.Logger- tracer telemetry.Tracer- validator *validators.PhoneAPIKeyHandlerValidator- service *services.PhoneAPIKeyService- phoneService *services.PhoneService+ logger telemetry.Logger+ tracer telemetry.Tracer+ validator *validators.PhoneAPIKeyHandlerValidator+ service *services.PhoneAPIKeyService}// NewPhoneAPIKeyHandler creates a new PhoneAPIKeyHandler@@ -30,14 +29,12 @@ func NewPhoneAPIKeyHandler(tracer telemetry.Tracer,validator *validators.PhoneAPIKeyHandlerValidator,service *services.PhoneAPIKeyService,- phoneService *services.PhoneService,) *PhoneAPIKeyHandler {return &PhoneAPIKeyHandler{- logger: logger.WithService(fmt.Sprintf("%T", &PhoneAPIKeyHandler{})),- tracer: tracer,- validator: validator,- service: service,- phoneService: phoneService,+ logger: logger.WithService(fmt.Sprintf("%T", &PhoneAPIKeyHandler{})),+ tracer: tracer,+ validator: validator,+ service: service,}}diff --git a/api/pkg/handlers/phone_handler.go b/api/pkg/handlers/phone_handler.goindex b64c9d0f..9e5cbe1c 100644--- a/api/pkg/handlers/phone_handler.go+++ b/api/pkg/handlers/phone_handler.go@@ -38,10 +38,15 @@ func NewPhoneHandler(}// RegisterRoutes registers the routes for the PhoneHandler-func (h *PhoneHandler) RegisterRoutes(router fiber.Router) {- router.Get("/phones", h.Index)- router.Put("/phones", h.Upsert)- router.Delete("/phones/:phoneID", h.Delete)+func (h *PhoneHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Get("/v1/phones", h.computeRoute(middlewares, h.Index)...)+ router.Put("/v1/phones", h.computeRoute(middlewares, h.Upsert)...)+ router.Delete("/v1/phones/:phoneID", h.computeRoute(middlewares, h.Delete)...)+}++// RegisterPhoneAPIKeyRoutes registers the routes for the PhoneHandler+func (h *PhoneHandler) RegisterPhoneAPIKeyRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Put("/v1/phones/fcm-token", h.computeRoute(middlewares, h.UpsertFCMToken)...)}// Index returns the phones of a user@@ -168,3 +173,46 @@ func (h *PhoneHandler) Delete(c *fiber.Ctx) error {return h.responseOK(c, "phone deleted successfully", nil)}++// UpsertFCMToken upserts the FCM token of a phone+// @Summary Upserts the FCM token of a phone+// @Description Updates the FCM token of a phone. If the phone with this number does not exist, a new one will be created. Think of this method like an 'upsert'+// @Security ApiKeyAuth+// @Tags Phones+// @Accept json+// @Produce json+// @Param payload body requests.PhoneFCMToken true "Payload of new FCM token."+// @Success 200 {object} responses.PhoneResponse+// @Failure 400 {object} responses.BadRequest+// @Failure 401 {object} responses.Unauthorized+// @Failure 422 {object} responses.UnprocessableEntity+// @Failure 500 {object} responses.InternalServerError+// @Router /phones/fcm-token [put]+func (h *PhoneHandler) UpsertFCMToken(c *fiber.Ctx) error {+ ctx, span := h.tracer.StartFromFiberCtx(c)+ defer span.End()++ ctxLogger := h.tracer.CtxLogger(h.logger, span)++ var request requests.PhoneFCMToken+ if err := c.BodyParser(&request); err != nil {+ msg := fmt.Sprintf("cannot marshall params [%s] into %T", c.OriginalURL(), request)+ ctxLogger.Warn(stacktrace.Propagate(err, msg))+ return h.responseBadRequest(c, err)+ }++ if errors := h.validator.ValidateFCMToken(ctx, request.Sanitize()); len(errors) != 0 {+ msg := fmt.Sprintf("validation errors [%s], while updating phones [%+#v]", spew.Sdump(errors), request)+ ctxLogger.Warn(stacktrace.NewError(msg))+ return h.responseUnprocessableEntity(c, errors, "validation errors while updating phones")+ }++ phone, err := h.service.UpsertFCMToken(ctx, request.ToPhoneFCMTokenParams(h.userFromContext(c), c.OriginalURL()))+ if err != nil {+ msg := fmt.Sprintf("cannot delete phones with params [%+#v]", request)+ ctxLogger.Error(stacktrace.Propagate(err, msg))+ return h.responseInternalServerError(c)+ }++ return h.responseOK(c, "FCM token updated successfully", phone)+}diff --git a/api/pkg/handlers/user_handler.go b/api/pkg/handlers/user_handler.goindex daa0aaab..af77e718 100644--- a/api/pkg/handlers/user_handler.go+++ b/api/pkg/handlers/user_handler.go@@ -38,14 +38,14 @@ func NewUserHandler(}// RegisterRoutes registers the routes for the MessageHandler-func (h *UserHandler) RegisterRoutes(router fiber.Router) {- router.Get("/users/me", h.Show)- router.Put("/users/me", h.Update)- router.Delete("/users/me", h.Delete)- router.Delete("/users/:userID/api-keys", h.DeleteAPIKey)- router.Put("/users/:userID/notifications", h.UpdateNotifications)- router.Get("/users/subscription-update-url", h.subscriptionUpdateURL)- router.Delete("/users/subscription", h.cancelSubscription)+func (h *UserHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Get("/v1/users/me", h.computeRoute(middlewares, h.Show)...)+ router.Put("/v1/users/me", h.computeRoute(middlewares, h.Update)...)+ router.Delete("/v1/users/me", h.computeRoute(middlewares, h.Delete)...)+ router.Delete("/v1/users/:userID/api-keys", h.computeRoute(middlewares, h.DeleteAPIKey)...)+ router.Put("/v1/users/:userID/notifications", h.computeRoute(middlewares, h.UpdateNotifications)...)+ router.Get("/v1/users/subscription-update-url", h.computeRoute(middlewares, h.subscriptionUpdateURL)...)+ router.Delete("/v1/users/subscription", h.computeRoute(middlewares, h.cancelSubscription)...)}// Show returns an entities.Userdiff --git a/api/pkg/handlers/webhook_handler.go b/api/pkg/handlers/webhook_handler.goindex 72cb407a..54df0f68 100644--- a/api/pkg/handlers/webhook_handler.go+++ b/api/pkg/handlers/webhook_handler.go@@ -41,12 +41,11 @@ func NewWebhookHandler(}// RegisterRoutes registers the routes for the WebhookHandler-func (h *WebhookHandler) RegisterRoutes(app *fiber.App, middlewares ...fiber.Handler) {- router := app.Group("/v1/webhooks")- router.Get("/", h.computeRoute(middlewares, h.Index)...)- router.Post("/", h.computeRoute(middlewares, h.Store)...)- router.Put("/:webhookID", h.computeRoute(middlewares, h.Update)...)- router.Delete("/:webhookID", h.computeRoute(middlewares, h.Delete)...)+func (h *WebhookHandler) RegisterRoutes(router fiber.Router, middlewares ...fiber.Handler) {+ router.Get("/v1/webhooks", h.computeRoute(middlewares, h.Index)...)+ router.Post("/v1/webhooks", h.computeRoute(middlewares, h.Store)...)+ router.Put("/v1/webhooks/:webhookID", h.computeRoute(middlewares, h.Update)...)+ router.Delete("/v1/webhooks/:webhookID", h.computeRoute(middlewares, h.Delete)...)}// Index returns the webhooks of a userdiff --git a/api/pkg/listeners/phone_api_key_listener.go b/api/pkg/listeners/phone_api_key_listener.gonew file mode 100644index 00000000..626063f0--- /dev/null+++ b/api/pkg/listeners/phone_api_key_listener.go@@ -0,0 +1,104 @@+package listeners++import (+ "context"+ "fmt"++ "github.com/NdoleStudio/httpsms/pkg/entities"++ cloudevents "github.com/cloudevents/sdk-go/v2"+ "github.com/davecgh/go-spew/spew"+ "github.com/palantir/stacktrace"++ "github.com/NdoleStudio/httpsms/pkg/events"+ "github.com/NdoleStudio/httpsms/pkg/services"+ "github.com/NdoleStudio/httpsms/pkg/telemetry"+)++// PhoneAPIKeyListener handles cloud events that alter the state of entities.PhoneAPIKey+type PhoneAPIKeyListener struct {+ logger telemetry.Logger+ tracer telemetry.Tracer+ service *services.PhoneAPIKeyService+}++// NewPhoneAPIKeyListener creates a new instance of PhoneAPIKeyListener+func NewPhoneAPIKeyListener(+ logger telemetry.Logger,+ tracer telemetry.Tracer,+ service *services.PhoneAPIKeyService,+) (l *PhoneAPIKeyListener, routes map[string]events.EventListener) {+ l = &PhoneAPIKeyListener{+ logger: logger.WithService(fmt.Sprintf("%T", l)),+ tracer: tracer,+ service: service,+ }++ return l, map[string]events.EventListener{+ events.EventTypePhoneUpdated: l.onPhoneUpdated,+ events.EventTypePhoneDeleted: l.onPhoneDeleted,+ events.UserAccountDeleted: l.onUserAccountDeleted,+ }+}++// onPhoneUpdated handles the events.EventTypePhoneUpdated event+func (listener *PhoneAPIKeyListener) onPhoneUpdated(ctx context.Context, event cloudevents.Event) error {+ ctx, span, ctxLogger := listener.tracer.StartWithLogger(ctx, listener.logger)+ defer span.End()++ var payload events.PhoneUpdatedPayload+ if err := event.DataAs(&payload); err != nil {+ msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ if payload.PhoneAPIKeyID == nil {+ ctxLogger.Info(fmt.Sprintf("phone API Key does not exist for [%s] event with ID [%s] and phone with ID [%s] for user [%S]", event.Type(), event.ID(), payload.PhoneID, payload.UserID))+ return nil+ }++ if err := listener.service.AddPhone(ctx, payload.UserID, *payload.PhoneAPIKeyID, payload.PhoneID); err != nil {+ msg := fmt.Sprintf("cannot store heartbeat monitor with params [%s] for event with ID [%s]", spew.Sdump(payload), event.ID())+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ return nil+}++// onPhoneUpdated handles the events.EventTypePhoneUpdated event+func (listener *PhoneAPIKeyListener) onPhoneDeleted(ctx context.Context, event cloudevents.Event) error {+ ctx, span, _ := listener.tracer.StartWithLogger(ctx, listener.logger)+ defer span.End()++ var payload events.PhoneDeletedPayload+ if err := event.DataAs(&payload); err != nil {+ msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ if err := listener.service.RemovePhoneByID(ctx, payload.UserID, payload.PhoneID, payload.Owner); err != nil {+ msg := fmt.Sprintf("cannot remove phone with ID [%s] from phone api key for [%s] event with ID [%s]", payload.PhoneID, event.Type(), event.ID())+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ return nil+}++// onUserAccountDeleted handles the events.EventTypePhoneUpdated event+func (listener *PhoneAPIKeyListener) onUserAccountDeleted(ctx context.Context, event cloudevents.Event) error {+ ctx, span, _ := listener.tracer.StartWithLogger(ctx, listener.logger)+ defer span.End()++ var payload events.UserAccountDeletedPayload+ if err := event.DataAs(&payload); err != nil {+ msg := fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ if err := listener.service.DeleteAllForUser(ctx, payload.UserID); err != nil {+ msg := fmt.Sprintf("cannot delete all [%T] for user with ID [%s] for [%s] event with ID [%s]", entities.PhoneAPIKey{}, payload.UserID, event.Type(), event.ID())+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ return nil+}diff --git a/api/pkg/middlewares/api_key_auth_middleware.go b/api/pkg/middlewares/api_key_auth_middleware.goindex cc797bff..17ac4335 100644--- a/api/pkg/middlewares/api_key_auth_middleware.go+++ b/api/pkg/middlewares/api_key_auth_middleware.go@@ -2,6 +2,7 @@ package middlewaresimport ("fmt"+ "strings""github.com/NdoleStudio/httpsms/pkg/repositories""github.com/NdoleStudio/httpsms/pkg/telemetry"@@ -20,8 +21,8 @@ func APIKeyAuth(logger telemetry.Logger, tracer telemetry.Tracer, userRepositoryctxLogger := tracer.CtxLogger(logger, span)apiKey := getAPIKeyFromRequest(c)- if len(apiKey) == 0 || apiKey == "undefined" {- span.AddEvent(fmt.Sprintf("the request header has no [%s] header", authHeaderAPIKey))+ if len(apiKey) == 0 || apiKey == "undefined" || strings.HasPrefix(apiKey, "pk_") {+ span.AddEvent(fmt.Sprintf("the request header has no primary [%s] header", authHeaderAPIKey))return c.Next()}diff --git a/api/pkg/middlewares/phone_api_key_auth_middleware.go b/api/pkg/middlewares/phone_api_key_auth_middleware.gonew file mode 100644index 00000000..dc19c3b8--- /dev/null+++ b/api/pkg/middlewares/phone_api_key_auth_middleware.go@@ -0,0 +1,37 @@+package middlewares++import (+ "fmt"+ "strings"++ "github.com/NdoleStudio/httpsms/pkg/repositories"+ "github.com/NdoleStudio/httpsms/pkg/telemetry"+ "github.com/gofiber/fiber/v2"+ "github.com/palantir/stacktrace"+)++// PhoneAPIKeyAuth authenticates a user from the X-API-Key header+func PhoneAPIKeyAuth(logger telemetry.Logger, tracer telemetry.Tracer, repository repositories.PhoneAPIKeyRepository) fiber.Handler {+ logger = logger.WithService("middlewares.APIKeyAuth")++ return func(c *fiber.Ctx) error {+ ctx, span, ctxLogger := tracer.StartFromFiberCtxWithLogger(c, logger, "middlewares.APIKeyAuth")+ defer span.End()++ apiKey := c.Get(authHeaderAPIKey)+ if len(apiKey) == 0 || apiKey == "undefined" || !strings.HasPrefix(apiKey, "pk_") {+ span.AddEvent(fmt.Sprintf("the request header has no [%s] header for the phone key", authHeaderAPIKey))+ return c.Next()+ }++ authUser, err := repository.LoadAuthContext(ctx, apiKey)+ if err != nil {+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot load user with phone api key [%s]", apiKey)))+ return c.Next()+ }++ c.Locals(ContextKeyAuthUserID, authUser)+ ctxLogger.Info(fmt.Sprintf("[%T] set successfully for user with ID [%s]", authUser, authUser.ID))+ return c.Next()+ }+}diff --git a/api/pkg/repositories/gorm_message_repository.go b/api/pkg/repositories/gorm_message_repository.goindex 955f1f0d..607af44e 100644--- a/api/pkg/repositories/gorm_message_repository.go+++ b/api/pkg/repositories/gorm_message_repository.go@@ -223,18 +223,23 @@ func (repository *gormMessageRepository) Update(ctx context.Context, message *en}// GetOutstanding fetches messages that still to be sent to the phone-func (repository *gormMessageRepository) GetOutstanding(ctx context.Context, userID entities.UserID, messageID uuid.UUID) (*entities.Message, error) {+func (repository *gormMessageRepository) GetOutstanding(ctx context.Context, userID entities.UserID, messageID uuid.UUID, phoneNumbers []string) (*entities.Message, error) {ctx, span := repository.tracer.Start(ctx)defer span.End()message := new(entities.Message)err := crdbgorm.ExecuteTx(ctx, repository.db, nil,func(tx *gorm.DB) error {- return tx.WithContext(ctx).Model(message).+ query := tx.WithContext(ctx).Model(message).Clauses(clause.Returning{}).Where("user_id = ?", userID).- Where("id = ?", messageID).- Where(repository.db.Where("status = ?", entities.MessageStatusScheduled).Or("status = ?", entities.MessageStatusPending).Or("status = ?", entities.MessageStatusExpired)).+ Where("id = ?", messageID)++ if len(phoneNumbers) > 0 {+ query = query.Where("owner IN ?", phoneNumbers)+ }++ return query.Where(repository.db.Where("status = ?", entities.MessageStatusScheduled).Or("status = ?", entities.MessageStatusPending).Or("status = ?", entities.MessageStatusExpired)).Update("status", entities.MessageStatusSending).Error},)diff --git a/api/pkg/repositories/gorm_phone_api_key_repository.go b/api/pkg/repositories/gorm_phone_api_key_repository.goindex 6feecd2a..86e4786b 100644--- a/api/pkg/repositories/gorm_phone_api_key_repository.go+++ b/api/pkg/repositories/gorm_phone_api_key_repository.go@@ -6,6 +6,8 @@ import ("fmt""time"+ "github.com/cockroachdb/cockroach-go/v2/crdb/crdbgorm"+"github.com/NdoleStudio/httpsms/pkg/entities""github.com/NdoleStudio/httpsms/pkg/telemetry""github.com/dgraph-io/ristretto"@@ -26,8 +28,8 @@ type gormPhoneAPIKeyRepository struct {func NewGormPhoneAPIKeyRepository(logger telemetry.Logger,tracer telemetry.Tracer,- cache *ristretto.Cache[string, entities.AuthContext],db *gorm.DB,+ cache *ristretto.Cache[string, entities.AuthContext],) PhoneAPIKeyRepository {return &gormPhoneAPIKeyRepository{logger: logger.WithService(fmt.Sprintf("%T", &gormPhoneAPIKeyRepository{})),@@ -37,7 +39,29 @@ func NewGormPhoneAPIKeyRepository(}}-// Load an entities.Integration3CX based on the entities.UserID+func (repository *gormPhoneAPIKeyRepository) RemovePhoneByID(ctx context.Context, userID entities.UserID, phoneID uuid.UUID, phoneNumber string) error {+ ctx, span := repository.tracer.Start(ctx)+ defer span.End()++ query := `+UPDATE ?+SET phone_ids = array_remove(phone_ids, ?),+ phone_numbers = array_remove(phone_numbers, ?)+WHERE user_id = ? AND array_position(phone_ids, ?) IS NOT NULL;+`+ err := repository.db.WithContext(ctx).+ Raw(query, (entities.PhoneAPIKey{}).TableName(), phoneID, phoneNumber, userID, phoneID).+ Error+ if err != nil {+ msg := fmt.Sprintf("cannot remove phone with ID [%s] and number [%s] for user with ID [%s] ", phoneID, phoneNumber, userID)+ return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ repository.cache.Clear()+ return nil+}++// Load an entities.PhoneAPIKey based on the entities.UserIDfunc (repository *gormPhoneAPIKeyRepository) Load(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID) (*entities.PhoneAPIKey, error) {ctx, span := repository.tracer.Start(ctx)defer span.End()@@ -138,27 +162,45 @@ func (repository *gormPhoneAPIKeyRepository) Delete(ctx context.Context, phoneAPreturn nil}-func (repository *gormPhoneAPIKeyRepository) AddPhone(ctx context.Context, authContext entities.AuthContext, phoneID uuid.UUID, phoneNumber string) error {+func (repository *gormPhoneAPIKeyRepository) AddPhone(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey, phone *entities.Phone) error {ctx, span := repository.tracer.Start(ctx)defer span.End()- query := `+ err := crdbgorm.ExecuteTx(ctx, repository.db, nil, func(tx *gorm.DB) error {+ query := `+UPDATE ?+SET phone_ids = array_remove(phone_ids, ?),+ phone_numbers = array_remove(phone_numbers, ?)+WHERE user_id = ?;+`+ err := tx.WithContext(ctx).+ Raw(query, phoneAPIKey.TableName(), phone.ID, phone.PhoneNumber, phone.UserID).+ Error+ if err != nil {+ msg := fmt.Sprintf("cannot remove phone with ID [%s] from API Key with ID [%s] for user with ID [%s]", phone.ID, phoneAPIKey.ID, phone.UserID)+ return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ query = `UPDATE ?SET phone_ids = array_append(phone_ids, ?),phone_numbers = array_append(phone_numbers, ?)WHERE array_position(phone_ids, ?) IS NULL AND id = ?;`-- err := repository.db.WithContext(ctx).- Raw(query, (entities.PhoneAPIKey{}).TableName(), phoneID, phoneNumber, phoneID, *authContext.PhoneAPIKeyID).- Error+ err = repository.db.WithContext(ctx).+ Raw(query, phoneAPIKey.TableName(), phone.ID, phone.PhoneNumber, phoneAPIKey.ID).+ Error+ if err != nil {+ msg := fmt.Sprintf("cannot add [%T] with ID [%s] from API Key with ID [%s] for user with ID [%s]", phone, phone.ID, phoneAPIKey.ID, phone.UserID)+ return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }+ return nil+ })if err != nil {- msg := fmt.Sprintf("cannot add phone with ID [%s] to phone API key with ID [%s]", phoneID, *authContext.PhoneAPIKeyID)+ msg := fmt.Sprintf("cannot add [%T] with ID [%s] from API Key with ID [%s] for user with ID [%s]", phone, phone.ID, phoneAPIKey.ID, phone.UserID)return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))}-repository.cache.Clear()-return nil}@@ -173,7 +215,7 @@ SET phone_ids = array_remove(phone_ids, ?),WHERE id = ?;`err := repository.db.WithContext(ctx).- Raw(query, (entities.PhoneAPIKey{}).TableName(), phone.ID, phone.PhoneNumber, phoneAPIKey.ID).+ Raw(query, phoneAPIKey.TableName(), phone.ID, phone.PhoneNumber, phoneAPIKey.ID).Errorif err != nil {msg := fmt.Sprintf("cannot remove phone with ID [%s] from phone API key with ID [%s]", phone.ID, phoneAPIKey.ID)diff --git a/api/pkg/repositories/message_repository.go b/api/pkg/repositories/message_repository.goindex 3f742cc6..3ad70015 100644--- a/api/pkg/repositories/message_repository.go+++ b/api/pkg/repositories/message_repository.go@@ -28,7 +28,7 @@ type MessageRepository interface {Search(ctx context.Context, userID entities.UserID, owners []string, types []entities.MessageType, statuses []entities.MessageStatus, params IndexParams) ([]*entities.Message, error)// GetOutstanding fetches an entities.Message which is outstanding- GetOutstanding(ctx context.Context, userID entities.UserID, messageID uuid.UUID) (*entities.Message, error)+ GetOutstanding(ctx context.Context, userID entities.UserID, messageID uuid.UUID, phoneNumbers []string) (*entities.Message, error)// Delete an entities.Message by IDDelete(ctx context.Context, userID entities.UserID, messageID uuid.UUID) errordiff --git a/api/pkg/repositories/phone_api_key_repository.go b/api/pkg/repositories/phone_api_key_repository.goindex 52828980..8894e4ac 100644--- a/api/pkg/repositories/phone_api_key_repository.go+++ b/api/pkg/repositories/phone_api_key_repository.go@@ -26,11 +26,14 @@ type PhoneAPIKeyRepository interface {Delete(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey) error// AddPhone adds an entities.Phone to an entities.PhoneAPIKey- AddPhone(ctx context.Context, authContext entities.AuthContext, phoneID uuid.UUID, phoneNumber string) error+ AddPhone(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey, phone *entities.Phone) error// RemovePhone removes an entities.Phone to an entities.PhoneAPIKeyRemovePhone(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey, phone *entities.Phone) error// DeleteAllForUser deletes all entities.PhoneAPIKey for a userDeleteAllForUser(ctx context.Context, userID entities.UserID) error++ // RemovePhoneByID removes a phone by ID and phone number+ RemovePhoneByID(ctx context.Context, userID entities.UserID, phoneID uuid.UUID, phoneNumber string) error}diff --git a/api/pkg/requests/message_outstanding_request.go b/api/pkg/requests/message_outstanding_request.goindex a1a768eb..3d3209e9 100644--- a/api/pkg/requests/message_outstanding_request.go+++ b/api/pkg/requests/message_outstanding_request.go@@ -22,11 +22,12 @@ func (input *MessageOutstanding) Sanitize() MessageOutstanding {}// ToGetOutstandingParams converts MessageOutstanding into services.MessageGetOutstandingParams-func (input *MessageOutstanding) ToGetOutstandingParams(source string, userID entities.UserID, timestamp time.Time) services.MessageGetOutstandingParams {+func (input *MessageOutstanding) ToGetOutstandingParams(source string, authCtx entities.AuthContext, timestamp time.Time) services.MessageGetOutstandingParams {return services.MessageGetOutstandingParams{- Source: source,- UserID: userID,- MessageID: uuid.MustParse(input.MessageID),- Timestamp: timestamp,+ Source: source,+ PhoneNumbers: authCtx.PhoneNumbers,+ UserID: authCtx.ID,+ MessageID: uuid.MustParse(input.MessageID),+ Timestamp: timestamp,}}diff --git a/api/pkg/requests/phone_fcm_token_request.go b/api/pkg/requests/phone_fcm_token_request.gonew file mode 100644index 00000000..dde935b5--- /dev/null+++ b/api/pkg/requests/phone_fcm_token_request.go@@ -0,0 +1,40 @@+package requests++import (+ "strings"++ "github.com/nyaruka/phonenumbers"++ "github.com/NdoleStudio/httpsms/pkg/entities"+ "github.com/NdoleStudio/httpsms/pkg/services"+)++// PhoneFCMToken is the payload for updating the FCM token of a phone+type PhoneFCMToken struct {+ request+ PhoneNumber string `json:"phone_number" example:"[+18005550199]"`+ FcmToken string `json:"fcm_token" example:"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzd....."`+ // SIM is the SIM slot of the phone in case the phone has more than 1 SIM slot+ SIM string `json:"sim" example:"SIM1"`+}++// Sanitize sets defaults to MessageOutstanding+func (input *PhoneFCMToken) Sanitize() PhoneFCMToken {+ input.FcmToken = strings.TrimSpace(input.FcmToken)+ input.PhoneNumber = input.sanitizeAddress(input.PhoneNumber)+ input.SIM = input.sanitizeSIM(input.SIM)+ return *input+}++// ToPhoneFCMTokenParams converts PhoneFCMToken to services.PhoneFCMTokenParams+func (input *PhoneFCMToken) ToPhoneFCMTokenParams(user entities.AuthContext, source string) *services.PhoneFCMTokenParams {+ phone, _ := phonenumbers.Parse(input.PhoneNumber, phonenumbers.UNKNOWN_REGION)+ return &services.PhoneFCMTokenParams{+ Source: source,+ PhoneNumber: phone,+ PhoneAPIKeyID: user.PhoneAPIKeyID,+ UserID: user.ID,+ FcmToken: &input.FcmToken,+ SIM: entities.SIM(input.SIM),+ }+}diff --git a/api/pkg/services/message_service.go b/api/pkg/services/message_service.goindex c972709e..890908f6 100644--- a/api/pkg/services/message_service.go+++ b/api/pkg/services/message_service.go@@ -49,10 +49,11 @@ func NewMessageService(// MessageGetOutstandingParams parameters for sending a new messagetype MessageGetOutstandingParams struct {- Source string- UserID entities.UserID- Timestamp time.Time- MessageID uuid.UUID+ Source string+ UserID entities.UserID+ PhoneNumbers []string+ Timestamp time.Time+ MessageID uuid.UUID}// GetOutstanding fetches messages that still to be sent to the phone@@ -62,7 +63,7 @@ func (service *MessageService) GetOutstanding(ctx context.Context, params MessagctxLogger := service.tracer.CtxLogger(service.logger, span)- message, err := service.repository.GetOutstanding(ctx, params.UserID, params.MessageID)+ message, err := service.repository.GetOutstanding(ctx, params.UserID, params.MessageID, params.PhoneNumbers)if err != nil {msg := fmt.Sprintf("could not fetch outstanding messages with params [%s]", spew.Sdump(params))return nil, service.tracer.WrapErrorSpan(span, stacktrace.PropagateWithCode(err, stacktrace.GetCode(err), msg))diff --git a/api/pkg/services/phone_api_key_service.go b/api/pkg/services/phone_api_key_service.goindex fd8f2f5e..b3460478 100644--- a/api/pkg/services/phone_api_key_service.go+++ b/api/pkg/services/phone_api_key_service.go@@ -40,7 +40,7 @@ func NewPhoneAPIKeyService(// Create a new entities.PhoneAPIKeyfunc (service *PhoneAPIKeyService) Create(ctx context.Context, authContext entities.AuthContext, name string) (*entities.PhoneAPIKey, error) {- ctx, span := service.tracer.Start(ctx)+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)defer span.End()apiKey, err := service.generateAPIKey(64)@@ -65,12 +65,13 @@ func (service *PhoneAPIKeyService) Create(ctx context.Context, authContext entitreturn nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))}+ ctxLogger.Info(fmt.Sprintf("created [%T] with ID [%s] for user ID [%s]", phoneAPIKey, phoneAPIKey.ID, authContext.ID))return phoneAPIKey, nil}// Delete an entities.PhoneAPIKeyfunc (service *PhoneAPIKeyService) Delete(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID) error {- ctx, span := service.tracer.Start(ctx)+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)defer span.End()phoneAPIKey, err := service.repository.Load(ctx, userID, phoneAPIKeyID)@@ -84,12 +85,13 @@ func (service *PhoneAPIKeyService) Delete(ctx context.Context, userID entities.Ureturn service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))}+ ctxLogger.Info(fmt.Sprintf("deleted [%T] with ID [%s] for user ID [%s]", phoneAPIKey, phoneAPIKey.ID, userID))return nil}// RemovePhone removes the phone from the phone API keyfunc (service *PhoneAPIKeyService) RemovePhone(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID, phoneID uuid.UUID) error {- ctx, span := service.tracer.Start(ctx)+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)defer span.End()phone, err := service.phoneRepository.LoadByID(ctx, userID, phoneID)@@ -109,6 +111,61 @@ func (service *PhoneAPIKeyService) RemovePhone(ctx context.Context, userID entitreturn service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))}+ ctxLogger.Info(fmt.Sprintf("removed [%T] with ID [%s] from [%T] with ID [%s] for user ID [%s]", phone, phoneID, phoneAPIKey, phoneAPIKeyID, userID))+ return nil+}++// RemovePhoneByID removes the phone from the phone API key by phone number and phoneID+func (service *PhoneAPIKeyService) RemovePhoneByID(ctx context.Context, userID entities.UserID, phoneID uuid.UUID, phoneNumber string) error {+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)+ defer span.End()++ if err := service.repository.RemovePhoneByID(ctx, userID, phoneID, phoneNumber); err != nil {+ msg := fmt.Sprintf("cannot remove [%T] with ID [%s] and number [%s] for user [%s]", &entities.Phone{}, phoneID, phoneNumber, userID.String())+ return stacktrace.Propagate(err, msg)+ }++ ctxLogger.Info(fmt.Sprintf("removed phone with ID [%s] from [%T] for user ID [%s]", phoneID, &entities.PhoneAPIKey{}, userID))+ return nil+}++// DeleteAllForUser removes all entities.PhoneAPIKey for a user+func (service *PhoneAPIKeyService) DeleteAllForUser(ctx context.Context, userID entities.UserID) error {+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)+ defer span.End()++ if err := service.repository.DeleteAllForUser(ctx, userID); err != nil {+ msg := fmt.Sprintf("cannot delete all [%T] for user ID [%s]", &entities.PhoneAPIKey{}, userID)+ return stacktrace.Propagate(err, msg)+ }++ ctxLogger.Info(fmt.Sprintf("deleted all [%T] for user ID [%s]", &entities.PhoneAPIKey{}, userID))+ return nil+}++// AddPhone adds a phone to the phone API key+func (service *PhoneAPIKeyService) AddPhone(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID, phoneID uuid.UUID) error {+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)+ defer span.End()++ phone, err := service.phoneRepository.LoadByID(ctx, userID, phoneID)+ if err != nil {+ msg := fmt.Sprintf("cannot load [%T] with ID [%s] for user [%s]", &entities.Phone{}, phoneID, userID.String())+ return stacktrace.Propagate(err, msg)+ }++ phoneAPIKey, err := service.repository.Load(ctx, userID, phoneAPIKeyID)+ if err != nil {+ msg := fmt.Sprintf("cannot load [%T] with ID [%s] for user [%s]", &entities.PhoneAPIKey{}, phoneAPIKeyID, userID.String())+ return stacktrace.Propagate(err, msg)+ }++ if err = service.repository.AddPhone(ctx, phoneAPIKey, phone); err != nil {+ msg := fmt.Sprintf("cannot add [%T] with ID [%s] to phone API key with ID [%s] for user [%s]", phone, phone.ID, phoneAPIKey.ID, userID)+ return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ ctxLogger.Info(fmt.Sprintf("added [%T] with ID [%s] to [%T] with ID [%s] for user ID [%s]", phone, phone.ID, phoneAPIKey, phoneAPIKeyID, userID))return nil}diff --git a/api/pkg/services/phone_service.go b/api/pkg/services/phone_service.goindex e4960ff6..df8e2104 100644--- a/api/pkg/services/phone_service.go+++ b/api/pkg/services/phone_service.go@@ -104,7 +104,14 @@ func (service *PhoneService) Upsert(ctx context.Context, params *PhoneUpsertParaphone, err := service.repository.Load(ctx, params.UserID, phonenumbers.Format(params.PhoneNumber, phonenumbers.E164))if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {- return service.createPhone(ctx, params)+ return service.createPhone(ctx, &PhoneFCMTokenParams{+ Source: params.Source,+ PhoneNumber: params.PhoneNumber,+ PhoneAPIKeyID: nil,+ UserID: params.UserID,+ FcmToken: params.FcmToken,+ SIM: params.SIM,+ })}if err != nil {@@ -118,19 +125,27 @@ func (service *PhoneService) Upsert(ctx context.Context, params *PhoneUpsertPara}ctxLogger.Info(fmt.Sprintf("phone updated with id [%s] in the phone repository for user [%s]", phone.ID, phone.UserID))- return phone, service.dispatchPhoneUpdatedEvent(ctx, params.Source, phone)+ return phone, service.dispatchPhoneUpdatedEvent(ctx, phone, &PhoneFCMTokenParams{+ Source: params.Source,+ PhoneNumber: params.PhoneNumber,+ PhoneAPIKeyID: nil,+ UserID: params.UserID,+ FcmToken: params.FcmToken,+ SIM: params.SIM,+ })}-func (service *PhoneService) dispatchPhoneUpdatedEvent(ctx context.Context, source string, phone *entities.Phone) error {+func (service *PhoneService) dispatchPhoneUpdatedEvent(ctx context.Context, phone *entities.Phone, input *PhoneFCMTokenParams) error {ctx, span := service.tracer.Start(ctx)defer span.End()- event, err := service.createPhoneUpdatedEvent(source, events.PhoneUpdatedPayload{- PhoneID: phone.ID,- UserID: phone.UserID,- Timestamp: phone.UpdatedAt,- Owner: phone.PhoneNumber,- SIM: phone.SIM,+ event, err := service.createPhoneUpdatedEvent(input.Source, events.PhoneUpdatedPayload{+ PhoneID: phone.ID,+ UserID: phone.UserID,+ Timestamp: phone.UpdatedAt,+ PhoneAPIKeyID: input.PhoneAPIKeyID,+ Owner: phone.PhoneNumber,+ SIM: phone.SIM,})if err != nil {msg := fmt.Sprintf("cannot create event when phone [%s] is updated for user [%s]", phone.ID, phone.UserID)@@ -184,7 +199,44 @@ func (service *PhoneService) Delete(ctx context.Context, source string, userID ereturn nil}-func (service *PhoneService) createPhone(ctx context.Context, params *PhoneUpsertParams) (*entities.Phone, error) {+// PhoneFCMTokenParams are parameters for upserting an entities.Phone+type PhoneFCMTokenParams struct {+ Source string+ PhoneNumber *phonenumbers.PhoneNumber+ PhoneAPIKeyID *uuid.UUID+ UserID entities.UserID+ FcmToken *string+ SIM entities.SIM+}++// UpsertFCMToken the FCM token for an entities.Phone+func (service *PhoneService) UpsertFCMToken(ctx context.Context, params *PhoneFCMTokenParams) (*entities.Phone, error) {+ ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)+ defer span.End()++ phone, err := service.repository.Load(ctx, params.UserID, phonenumbers.Format(params.PhoneNumber, phonenumbers.E164))+ if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {+ return service.createPhone(ctx, params)+ }++ if err != nil {+ msg := fmt.Sprintf("cannot upsert FCM token for user with id [%s] and number [%s]", params.UserID, params.PhoneNumber)+ return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ phone.FcmToken = params.FcmToken+ phone.SIM = params.SIM++ if err = service.repository.Save(ctx, phone); err != nil {+ msg := fmt.Sprintf("cannot update phone with id [%s] and number [%s]", phone.ID, phone.PhoneNumber)+ return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))+ }++ ctxLogger.Info(fmt.Sprintf("phone updated with id [%s] in the phone repository for user [%s]", phone.ID, phone.UserID))+ return phone, service.dispatchPhoneUpdatedEvent(ctx, phone, params)+}++func (service *PhoneService) createPhone(ctx context.Context, params *PhoneFCMTokenParams) (*entities.Phone, error) {ctx, span, ctxLogger := service.tracer.StartWithLogger(ctx, service.logger)defer span.End()@@ -210,7 +262,7 @@ func (service *PhoneService) createPhone(ctx context.Context, params *PhoneUpser}ctxLogger.Info(fmt.Sprintf("phone updated with id [%s] in the phone repository for user [%s]", phone.ID, phone.UserID))- return phone, service.dispatchPhoneUpdatedEvent(ctx, params.Source, phone)+ return phone, service.dispatchPhoneUpdatedEvent(ctx, phone, params)}func (service *PhoneService) createPhoneUpdatedEvent(source string, payload events.PhoneUpdatedPayload) (cloudevents.Event, error) {diff --git a/api/pkg/validators/phone_api_key_handler_validator.go b/api/pkg/validators/phone_api_key_handler_validator.goindex 85b7b4f1..47fb870e 100644--- a/api/pkg/validators/phone_api_key_handler_validator.go+++ b/api/pkg/validators/phone_api_key_handler_validator.go@@ -21,8 +21,8 @@ type PhoneAPIKeyHandlerValidator struct {func NewPhoneAPIKeyHandlerValidator(logger telemetry.Logger,tracer telemetry.Tracer,-) (v *PhoneHandlerValidator) {- return &PhoneHandlerValidator{+) (v *PhoneAPIKeyHandlerValidator) {+ return &PhoneAPIKeyHandlerValidator{logger: logger.WithService(fmt.Sprintf("%T", v)),tracer: tracer,}diff --git a/api/pkg/validators/phone_handler_validator.go b/api/pkg/validators/phone_handler_validator.goindex 1beba13d..2369214e 100644--- a/api/pkg/validators/phone_handler_validator.go+++ b/api/pkg/validators/phone_handler_validator.go@@ -99,6 +99,29 @@ func (validator *PhoneHandlerValidator) ValidateUpsert(_ context.Context, requesreturn result}+// ValidateFCMToken validates requests.PhoneFCMToken+func (validator *PhoneHandlerValidator) ValidateFCMToken(_ context.Context, request requests.PhoneFCMToken) url.Values {+ v := govalidator.New(govalidator.Options{+ Data: &request,+ Rules: govalidator.MapData{+ "phone_number": []string{+ "required",+ phoneNumberRule,+ },+ "fcm_token": []string{+ "min:0",+ "max:1000",+ },+ "sim": []string{+ "required",+ "in:" + strings.Join([]string{entities.SIM1.String(), entities.SIM2.String()}, ","),+ },+ },+ })++ return v.ValidateStruct()+}+// ValidateDelete ValidateUpsert validates requests.PhoneDeletefunc (validator *PhoneHandlerValidator) ValidateDelete(_ context.Context, request requests.PhoneDelete) url.Values {v := govalidator.New(govalidator.Options{