Skip to content

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.go
index 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.Authenticated
func (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.Logger
func (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.Integration3CxRepository
func (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.DiscordHandler
func (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.Client
func (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 prefix
func (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.WebhookListener
func (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.PhoneNotificationService
func (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 prefix
func (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 prefix
func (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 prefix
func (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 prefix
func (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 prefix
func (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 prefix
func (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 prefix
func (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 prefix
func (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 swagger
diff --git a/api/pkg/events/phone_updated_event.go b/api/pkg/events/phone_updated_event.go
index 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 event
type 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.go
index 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 user
diff --git a/api/pkg/handlers/bulk_message_handler.go b/api/pkg/handlers/bulk_message_handler.go
index 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.go
index 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 event
diff --git a/api/pkg/handlers/handler.go b/api/pkg/handlers/handler.go
index 55dfb353..e6d4cc09 100644
--- a/api/pkg/handlers/handler.go
+++ b/api/pkg/handlers/handler.go
@@ -1,7 +1,10 @@
package handlers
import (
+ "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.go
index 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.go
index 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.go
index 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.go
index 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 requests
type 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.go
index 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.go
index 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.User
diff --git a/api/pkg/handlers/webhook_handler.go b/api/pkg/handlers/webhook_handler.go
index 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 user
diff --git a/api/pkg/listeners/phone_api_key_listener.go b/api/pkg/listeners/phone_api_key_listener.go
new file mode 100644
index 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.go
index 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 middlewares
import (
"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, userRepository
ctxLogger := 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.go
new file mode 100644
index 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.go
index 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.go
index 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.UserID
func (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, phoneAP
return 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).
Error
if 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.go
index 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 ID
Delete(ctx context.Context, userID entities.UserID, messageID uuid.UUID) error
diff --git a/api/pkg/repositories/phone_api_key_repository.go b/api/pkg/repositories/phone_api_key_repository.go
index 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.PhoneAPIKey
RemovePhone(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey, phone *entities.Phone) error
// DeleteAllForUser deletes all entities.PhoneAPIKey for a user
DeleteAllForUser(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.go
index 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.go
new file mode 100644
index 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.go
index 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 message
type 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 Messag
ctxLogger := 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.go
index 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.PhoneAPIKey
func (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 entit
return 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.PhoneAPIKey
func (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.U
return 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 key
func (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 entit
return 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.go
index 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 *PhoneUpsertPara
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)
+ 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 e
return 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.go
index 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.go
index 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, reques
return 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.PhoneDelete
func (validator *PhoneHandlerValidator) ValidateDelete(_ context.Context, request requests.PhoneDelete) url.Values {
v := govalidator.New(govalidator.Options{