Skip to content

Send and receive SMS messages using your Android phone programmatically via a simple HTTP API

Add api hanlders for the phone API key endpoint

Acho Arnold2dac7f71a462
diff --git a/api/pkg/handlers/discord_handler.go b/api/pkg/handlers/discord_handler.go
index 28df3ef1..95591c2b 100644
--- a/api/pkg/handlers/discord_handler.go
+++ b/api/pkg/handlers/discord_handler.go
@@ -128,7 +128,7 @@ func (h *DiscordHandler) Delete(c *fiber.Ctx) error {
defer span.End()
discordID := c.Params("discordID")
- if errors := h.validator.ValidateUUID(ctx, discordID, "discordID"); len(errors) != 0 {
+ if errors := h.validator.ValidateUUID(discordID, "discordID"); len(errors) != 0 {
msg := fmt.Sprintf("validation errors [%s], while deleting discord integration with ID [%s]", spew.Sdump(errors), discordID)
ctxLogger.Warn(stacktrace.NewError(msg))
return h.responseUnprocessableEntity(c, errors, "validation errors while deleting discord integration")
diff --git a/api/pkg/handlers/handler.go b/api/pkg/handlers/handler.go
index bfd54dee..55dfb353 100644
--- a/api/pkg/handlers/handler.go
+++ b/api/pkg/handlers/handler.go
@@ -115,3 +115,15 @@ func (h *handler) userIDFomContext(c *fiber.Ctx) entities.UserID {
func (h *handler) computeRoute(middlewares []fiber.Handler, route fiber.Handler) []fiber.Handler {
return append(append([]fiber.Handler{}, middlewares...), route)
}
+
+func (h *handler) mergeErrors(errors ...url.Values) url.Values {
+ result := url.Values{}
+ for _, item := range errors {
+ for key, values := range item {
+ for _, value := range values {
+ result.Add(key, value)
+ }
+ }
+ }
+ return result
+}
diff --git a/api/pkg/handlers/message_handler.go b/api/pkg/handlers/message_handler.go
index c1046c73..55e574c3 100644
--- a/api/pkg/handlers/message_handler.go
+++ b/api/pkg/handlers/message_handler.go
@@ -394,7 +394,7 @@ func (h *MessageHandler) Delete(c *fiber.Ctx) error {
ctxLogger := h.tracer.CtxLogger(h.logger, span)
messageID := c.Params("messageID")
- if errors := h.validator.ValidateUUID(ctx, messageID, "messageID"); len(errors) != 0 {
+ if errors := h.validator.ValidateUUID(messageID, "messageID"); len(errors) != 0 {
msg := fmt.Sprintf("validation errors [%s], while deleting a message with ID [%s]", spew.Sdump(errors), messageID)
ctxLogger.Warn(stacktrace.NewError(msg))
return h.responseUnprocessableEntity(c, errors, "validation errors while storing event")
diff --git a/api/pkg/handlers/message_thread_handler.go b/api/pkg/handlers/message_thread_handler.go
index 823fb587..38282831 100644
--- a/api/pkg/handlers/message_thread_handler.go
+++ b/api/pkg/handlers/message_thread_handler.go
@@ -157,7 +157,7 @@ func (h *MessageThreadHandler) Delete(c *fiber.Ctx) error {
defer span.End()
messageThreadID := c.Params("messageThreadID")
- if errors := h.validator.ValidateUUID(ctx, messageThreadID, "messageThreadID"); len(errors) != 0 {
+ if errors := h.validator.ValidateUUID(messageThreadID, "messageThreadID"); len(errors) != 0 {
msg := fmt.Sprintf("validation errors [%s], while deleting a thread thread with ID [%s]", spew.Sdump(errors), messageThreadID)
ctxLogger.Warn(stacktrace.NewError(msg))
return h.responseUnprocessableEntity(c, errors, "validation errors while deleting a thread thread")
diff --git a/api/pkg/handlers/phone_api_key_handler.go b/api/pkg/handlers/phone_api_key_handler.go
new file mode 100644
index 00000000..227aa773
--- /dev/null
+++ b/api/pkg/handlers/phone_api_key_handler.go
@@ -0,0 +1,175 @@
+package handlers
+
+import (
+ "fmt"
+
+ "github.com/NdoleStudio/httpsms/pkg/repositories"
+ "github.com/NdoleStudio/httpsms/pkg/requests"
+ "github.com/NdoleStudio/httpsms/pkg/services"
+ "github.com/NdoleStudio/httpsms/pkg/telemetry"
+ "github.com/NdoleStudio/httpsms/pkg/validators"
+ "github.com/davecgh/go-spew/spew"
+ "github.com/gofiber/fiber/v2"
+ "github.com/google/uuid"
+ "github.com/palantir/stacktrace"
+)
+
+// 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
+}
+
+// NewPhoneAPIKeyHandler creates a new PhoneAPIKeyHandler
+func NewPhoneAPIKeyHandler(
+ logger telemetry.Logger,
+ 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,
+ }
+}
+
+// RegisterRoutes registers the routes for the PhoneAPIKeyHandler
+func (h *PhoneAPIKeyHandler) RegisterRoutes(app *fiber.App, middlewares ...fiber.Handler) {
+ router := app.Group("/v1/api-keys/")
+ router.Post("/", h.computeRoute(middlewares, h.Store)...)
+ router.Delete("/:phoneAPIKeyID", h.computeRoute(middlewares, h.Delete)...)
+ router.Delete("/:phoneAPIKeyID/phones/:phoneID", h.computeRoute(middlewares, h.DeletePhone)...)
+}
+
+// Store a new Phone API key
+// @Summary Store phone API key
+// @Description Creates a new phone API key which can be used to log in to the httpSMS app on your Android phone
+// @Security ApiKeyAuth
+// @Tags PhoneAPIKeys
+// @Accept json
+// @Produce json
+// @Param payload body requests.PhoneAPIKeyStoreRequest true "Payload of new phone API key."
+// @Success 200 {object} responses.Ok[*entities.PhoneAPIKey]
+// @Failure 400 {object} responses.BadRequest
+// @Failure 401 {object} responses.Unauthorized
+// @Failure 422 {object} responses.UnprocessableEntity
+// @Failure 500 {object} responses.InternalServerError
+// @Router /api-keys [post]
+func (h *PhoneAPIKeyHandler) Store(c *fiber.Ctx) error {
+ ctx, span := h.tracer.StartFromFiberCtx(c)
+ defer span.End()
+
+ ctxLogger := h.tracer.CtxLogger(h.logger, span)
+
+ var request requests.PhoneAPIKeyStoreRequest
+ 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.ValidateStore(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.Create(ctx, h.userFromContext(c), request.Name)
+ if err != nil {
+ msg := fmt.Sprintf("cannot update phones with params [%+#v]", request)
+ ctxLogger.Error(stacktrace.Propagate(err, msg))
+ return h.responseInternalServerError(c)
+ }
+
+ return h.responseOK(c, "phone updated successfully", phone)
+}
+
+// Delete a phone API Key
+// @Summary Delete a phone API key from the database.
+// @Description Delete a phone API Key from the database and cannot be used for authentication anymore.
+// @Security ApiKeyAuth
+// @Tags PhoneAPIKeys
+// @Accept json
+// @Produce json
+// @Param phoneAPIKeyID path string true "ID of the phone API key" default(32343a19-da5e-4b1b-a767-3298a73703ca)
+// @Success 204 {object} responses.NoContent
+// @Failure 400 {object} responses.BadRequest
+// @Failure 401 {object} responses.Unauthorized
+// @Failure 404 {object} responses.NotFound
+// @Failure 422 {object} responses.UnprocessableEntity
+// @Failure 500 {object} responses.InternalServerError
+// @Router /messages/{phoneAPIKeyID} [delete]
+func (h *PhoneAPIKeyHandler) Delete(c *fiber.Ctx) error {
+ ctx, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
+ defer span.End()
+
+ phoneAPIKeyID := c.Params("phoneAPIKeyID")
+ if errors := h.validator.ValidateUUID(phoneAPIKeyID, "phoneAPIKeyID"); len(errors) != 0 {
+ msg := fmt.Sprintf("validation errors [%s], while deleting a phone API key with ID [%s]", spew.Sdump(errors), phoneAPIKeyID)
+ ctxLogger.Warn(stacktrace.NewError(msg))
+ return h.responseUnprocessableEntity(c, errors, "validation errors while storing event")
+ }
+
+ err := h.service.Delete(ctx, h.userIDFomContext(c), uuid.MustParse(phoneAPIKeyID))
+ if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
+ return h.responseNotFound(c, fmt.Sprintf("cannot find phone API key with ID [%s]", phoneAPIKeyID))
+ }
+
+ if err != nil {
+ msg := fmt.Sprintf("cannot delete phone API key with ID [%s] for user with ID [%s]", phoneAPIKeyID, h.userIDFomContext(c))
+ ctxLogger.Error(h.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg)))
+ return h.responseInternalServerError(c)
+ }
+
+ return h.responseNoContent(c, "phone API key deleted successfully")
+}
+
+// DeletePhone removes a phone from a phone API key
+// @Summary Remove the association of a phone from the phone API key.
+// @Description You will need to login again to the httpSMS app on your Android phone with a new phone API key.
+// @Security ApiKeyAuth
+// @Tags PhoneAPIKeys
+// @Accept json
+// @Produce json
+// @Param phoneAPIKeyID path string true "ID of the phone API key" default(32343a19-da5e-4b1b-a767-3298a73703ca)
+// @Param phoneID path string true "ID of the phone" default(32343a19-da5e-4b1b-a767-3298a73703ca)
+// @Success 204 {object} responses.NoContent
+// @Failure 400 {object} responses.BadRequest
+// @Failure 401 {object} responses.Unauthorized
+// @Failure 404 {object} responses.NotFound
+// @Failure 422 {object} responses.UnprocessableEntity
+// @Failure 500 {object} responses.InternalServerError
+// @Router /messages/{phoneAPIKeyID}/phones/{phoneID} [delete]
+func (h *PhoneAPIKeyHandler) DeletePhone(c *fiber.Ctx) error {
+ ctx, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
+ defer span.End()
+
+ phoneAPIKeyID := c.Params("phoneAPIKeyID")
+ phoneID := c.Params("phoneID")
+ if errors := h.mergeErrors(h.validator.ValidateUUID(phoneAPIKeyID, "phoneAPIKeyID"), h.validator.ValidateUUID(phoneID, "phoneID")); len(errors) != 0 {
+ msg := fmt.Sprintf("validation errors [%s], while deleting a phone API key with ID [%s]", spew.Sdump(errors), phoneAPIKeyID)
+ ctxLogger.Warn(stacktrace.NewError(msg))
+ return h.responseUnprocessableEntity(c, errors, "validation errors while storing event")
+ }
+
+ err := h.service.RemovePhone(ctx, h.userIDFomContext(c), uuid.MustParse(phoneAPIKeyID), uuid.MustParse(phoneID))
+ if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
+ return h.responseNotFound(c, fmt.Sprintf("cannot find phone with ID [%s] which is associated with phone API key with ID [%s]", phoneID, phoneAPIKeyID))
+ }
+
+ if err != nil {
+ msg := fmt.Sprintf("cannot remove phone with ID [%s] from phone API key with ID [%s] for user with ID [%s]", phoneID, phoneAPIKeyID, h.userIDFomContext(c))
+ ctxLogger.Error(h.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg)))
+ return h.responseInternalServerError(c)
+ }
+
+ return h.responseNoContent(c, "phone has been dissociated from phone API key successfully")
+}
diff --git a/api/pkg/handlers/webhook_handler.go b/api/pkg/handlers/webhook_handler.go
index 41200856..72cb407a 100644
--- a/api/pkg/handlers/webhook_handler.go
+++ b/api/pkg/handlers/webhook_handler.go
@@ -111,7 +111,7 @@ func (h *WebhookHandler) Delete(c *fiber.Ctx) error {
defer span.End()
webhookID := c.Params("webhookID")
- if errors := h.validator.ValidateUUID(ctx, webhookID, "webhookID"); len(errors) != 0 {
+ if errors := h.validator.ValidateUUID(webhookID, "webhookID"); len(errors) != 0 {
msg := fmt.Sprintf("validation errors [%s], while deleting webhook with ID [%s]", spew.Sdump(errors), webhookID)
ctxLogger.Warn(stacktrace.NewError(msg))
return h.responseUnprocessableEntity(c, errors, "validation errors while deleting webhook")
diff --git a/api/pkg/repositories/gorm_phone_api_key_repository.go b/api/pkg/repositories/gorm_phone_api_key_repository.go
index 7e88355e..378456e2 100644
--- a/api/pkg/repositories/gorm_phone_api_key_repository.go
+++ b/api/pkg/repositories/gorm_phone_api_key_repository.go
@@ -37,6 +37,26 @@ func NewGormPhoneAPIKeyRepository(
}
}
+// Load an entities.Integration3CX 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()
+
+ phoneAPIKey := new(entities.PhoneAPIKey)
+ err := repository.db.WithContext(ctx).Where("user_id = ?", userID).Where("id = ?", phoneAPIKeyID).First(&phoneAPIKey).Error
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ msg := fmt.Sprintf("[%T] with ID [%s] for user with ID [%s] does not exist", phoneAPIKey, phoneAPIKeyID, userID)
+ return nil, repository.tracer.WrapErrorSpan(span, stacktrace.PropagateWithCode(err, ErrCodeNotFound, msg))
+ }
+
+ if err != nil {
+ msg := fmt.Sprintf("cannot load [%T] with ID [%s] for user with ID [%s]", phoneAPIKey, phoneAPIKeyID, userID)
+ return nil, repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+ }
+
+ return phoneAPIKey, nil
+}
+
func (repository *gormPhoneAPIKeyRepository) Create(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey) error {
ctx, span := repository.tracer.Start(ctx)
defer span.End()
@@ -77,7 +97,7 @@ func (repository *gormPhoneAPIKeyRepository) LoadAuthContext(ctx context.Context
PhoneNumbers: phoneAPIKey.PhoneNumbers,
}
- if result := repository.cache.SetWithTTL(apiKey, authUser, 1, 2*time.Hour); !result {
+ if result := repository.cache.SetWithTTL(apiKey, authUser, 1, 1*time.Hour); !result {
msg := fmt.Sprintf("cannot cache [%T] with ID [%s] and result [%t]", authUser, phoneAPIKey.ID, result)
ctxLogger.Error(repository.tracer.WrapErrorSpan(span, stacktrace.NewError(msg)))
}
@@ -104,23 +124,21 @@ func (repository *gormPhoneAPIKeyRepository) Index(ctx context.Context, userID e
return *phoneAPIKeys, nil
}
-func (repository *gormPhoneAPIKeyRepository) Delete(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID) error {
+func (repository *gormPhoneAPIKeyRepository) Delete(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey) error {
ctx, span := repository.tracer.Start(ctx)
defer span.End()
- err := repository.db.WithContext(ctx).
- Where("user_id = ?", userID).
- Where("id = ?", phoneAPIKeyID).
- Delete(&entities.PhoneAPIKey{}).Error
+ err := repository.db.WithContext(ctx).Delete(phoneAPIKey).Error
if err != nil {
- msg := fmt.Sprintf("cannot delete phone API key with ID [%s] and userID [%s]", phoneAPIKeyID, userID)
+ msg := fmt.Sprintf("cannot delete phone API key with ID [%s] and userID [%s]", phoneAPIKey.ID, phoneAPIKey.UserID)
return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
}
+ repository.cache.Del(phoneAPIKey.APIKey)
return nil
}
-func (repository *gormPhoneAPIKeyRepository) AddPhone(ctx context.Context, authContext entities.AuthContext, phone *entities.Phone) error {
+func (repository *gormPhoneAPIKeyRepository) AddPhone(ctx context.Context, authContext entities.AuthContext, phoneID uuid.UUID, phoneNumber string) error {
ctx, span := repository.tracer.Start(ctx)
defer span.End()
@@ -132,17 +150,19 @@ WHERE array_position(phone_ids, ?) IS NULL AND id = ?;
`
err := repository.db.WithContext(ctx).
- Raw(query, (entities.PhoneAPIKey{}).TableName(), phone.ID, phone.PhoneNumber, phone.ID, *authContext.PhoneAPIKeyID).
+ Raw(query, (entities.PhoneAPIKey{}).TableName(), phoneID, phoneNumber, phoneID, *authContext.PhoneAPIKeyID).
Error
if err != nil {
- msg := fmt.Sprintf("cannot add phone with ID [%s] to phone API key with ID [%s]", phone.ID, *authContext.PhoneAPIKeyID)
+ msg := fmt.Sprintf("cannot add phone with ID [%s] to phone API key with ID [%s]", phoneID, *authContext.PhoneAPIKeyID)
return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
}
+ repository.cache.Clear()
+
return nil
}
-func (repository *gormPhoneAPIKeyRepository) RemovePhone(ctx context.Context, authContext entities.AuthContext, phone *entities.Phone) error {
+func (repository *gormPhoneAPIKeyRepository) RemovePhone(ctx context.Context, phoneAPIKey *entities.PhoneAPIKey, phone *entities.Phone) error {
ctx, span := repository.tracer.Start(ctx)
defer span.End()
@@ -153,13 +173,15 @@ SET phone_ids = array_remove(phone_ids, ?),
WHERE id = ?;
`
err := repository.db.WithContext(ctx).
- Raw(query, (entities.PhoneAPIKey{}).TableName(), phone.ID, phone.PhoneNumber, *authContext.PhoneAPIKeyID).
+ Raw(query, (entities.PhoneAPIKey{}).TableName(), phone.ID, phone.PhoneNumber, phoneAPIKey.ID).
Error
if err != nil {
- msg := fmt.Sprintf("cannot remove phone with ID [%s] to phone API key with ID [%s]", phone.ID, *authContext.PhoneAPIKeyID)
+ msg := fmt.Sprintf("cannot remove phone with ID [%s] from phone API key with ID [%s]", phone.ID, phoneAPIKey.ID)
return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
}
+ repository.cache.Clear()
+
return nil
}
diff --git a/api/pkg/repositories/phone_api_key_repository.go b/api/pkg/repositories/phone_api_key_repository.go
index c443d521..52828980 100644
--- a/api/pkg/repositories/phone_api_key_repository.go
+++ b/api/pkg/repositories/phone_api_key_repository.go
@@ -13,6 +13,9 @@ type PhoneAPIKeyRepository interface {
// Create a new entities.PhoneAPIKey
Create(ctx context.Context, phone *entities.PhoneAPIKey) error
+ // Load an entities.PhoneAPIKey by userID and phoneAPIKeyID
+ Load(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID) (*entities.PhoneAPIKey, error)
+
// LoadAuthContext fetches an entities.AuthContext by apiKey
LoadAuthContext(ctx context.Context, apiKey string) (entities.AuthContext, error)
@@ -20,10 +23,13 @@ type PhoneAPIKeyRepository interface {
Index(ctx context.Context, userID entities.UserID, params IndexParams) ([]*entities.PhoneAPIKey, error)
// Delete an entities.PhoneAPIKey
- Delete(ctx context.Context, userID entities.UserID, phoneAPIKeyID uuid.UUID) error
+ 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 an entities.Phone to an entities.PhoneAPIKey
- AddPhone(ctx context.Context, authContext entities.AuthContext, 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
diff --git a/api/pkg/requests/phone_api_key_store_request.go b/api/pkg/requests/phone_api_key_store_request.go
new file mode 100644
index 00000000..e7df2484
--- /dev/null
+++ b/api/pkg/requests/phone_api_key_store_request.go
@@ -0,0 +1,13 @@
+package requests
+
+// PhoneAPIKeyStoreRequest is the payload for storing a phone API key
+type PhoneAPIKeyStoreRequest struct {
+ request
+ Name string `json:"name" example:"My Phone API Key"`
+}
+
+// Sanitize sets defaults to MessageReceive
+func (input *PhoneAPIKeyStoreRequest) Sanitize() PhoneAPIKeyStoreRequest {
+ input.Name = input.sanitizeAddress(input.Name)
+ return *input
+}
diff --git a/api/pkg/services/phone_api_key_service.go b/api/pkg/services/phone_api_key_service.go
new file mode 100644
index 00000000..fd8f2f5e
--- /dev/null
+++ b/api/pkg/services/phone_api_key_service.go
@@ -0,0 +1,128 @@
+package services
+
+import (
+ "context"
+ "crypto/rand"
+ "encoding/base64"
+ "fmt"
+ "time"
+
+ "github.com/NdoleStudio/httpsms/pkg/entities"
+ "github.com/NdoleStudio/httpsms/pkg/repositories"
+ "github.com/NdoleStudio/httpsms/pkg/telemetry"
+ "github.com/google/uuid"
+ "github.com/palantir/stacktrace"
+)
+
+// PhoneAPIKeyService is responsible for managing entities.PhoneAPIKey
+type PhoneAPIKeyService struct {
+ service
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+ phoneRepository repositories.PhoneRepository
+ repository repositories.PhoneAPIKeyRepository
+}
+
+// NewPhoneAPIKeyService creates a new PhoneAPIKeyService
+func NewPhoneAPIKeyService(
+ logger telemetry.Logger,
+ tracer telemetry.Tracer,
+ phoneRepository repositories.PhoneRepository,
+ repository repositories.PhoneAPIKeyRepository,
+) *PhoneAPIKeyService {
+ return &PhoneAPIKeyService{
+ logger: logger.WithService(fmt.Sprintf("%T", &PhoneAPIKeyService{})),
+ tracer: tracer,
+ phoneRepository: phoneRepository,
+ repository: repository,
+ }
+}
+
+// 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)
+ defer span.End()
+
+ apiKey, err := service.generateAPIKey(64)
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "cannot generate API key")
+ }
+
+ phoneAPIKey := &entities.PhoneAPIKey{
+ ID: uuid.New(),
+ Name: name,
+ UserID: authContext.ID,
+ UserEmail: authContext.Email,
+ PhoneNumbers: nil,
+ PhoneIDs: nil,
+ APIKey: apiKey,
+ CreatedAt: time.Now().UTC(),
+ UpdatedAt: time.Now().UTC(),
+ }
+
+ if err = service.repository.Create(ctx, phoneAPIKey); err != nil {
+ msg := fmt.Sprintf("cannot create PhoneAPIKey for user [%s]", authContext.ID)
+ return nil, service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+ }
+
+ 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)
+ defer span.End()
+
+ 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.Delete(ctx, phoneAPIKey); err != nil {
+ msg := fmt.Sprintf("cannot delete [%T] with ID [%s] for user [%s]", phoneAPIKey, phoneAPIKey.ID, phoneAPIKey.UserID)
+ return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+ }
+
+ 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)
+ 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.RemovePhone(ctx, phoneAPIKey, phone); err != nil {
+ msg := fmt.Sprintf("cannot remove [%T] with ID [%s] from phone API key with ID [%s] for user [%s]", phone, phone.ID, phoneAPIKey.ID, userID)
+ return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+ }
+
+ return nil
+}
+
+func (service *PhoneAPIKeyService) generateRandomBytes(n int) ([]byte, error) {
+ b := make([]byte, n)
+ // Note that err == nil only if we read len(b) bytes.
+ if _, err := rand.Read(b); err != nil {
+ return nil, stacktrace.Propagate(err, fmt.Sprintf("cannot generate [%d] random bytes", n))
+ }
+
+ return b, nil
+}
+
+func (service *PhoneAPIKeyService) generateAPIKey(n int) (string, error) {
+ b, err := service.generateRandomBytes(n)
+ return base64.URLEncoding.EncodeToString(b)[0:n], stacktrace.Propagate(err, fmt.Sprintf("cannot generate [%s] random bytes", n))
+}
diff --git a/api/pkg/validators/phone_api_key_handler_validator.go b/api/pkg/validators/phone_api_key_handler_validator.go
new file mode 100644
index 00000000..85b7b4f1
--- /dev/null
+++ b/api/pkg/validators/phone_api_key_handler_validator.go
@@ -0,0 +1,44 @@
+package validators
+
+import (
+ "context"
+ "fmt"
+ "net/url"
+
+ "github.com/NdoleStudio/httpsms/pkg/requests"
+ "github.com/NdoleStudio/httpsms/pkg/telemetry"
+ "github.com/thedevsaddam/govalidator"
+)
+
+// PhoneAPIKeyHandlerValidator validates models used in handlers.PhoneAPIKeyHandler
+type PhoneAPIKeyHandlerValidator struct {
+ validator
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+}
+
+// NewPhoneAPIKeyHandlerValidator creates a new handlers.PhoneAPIKeyHandler validator
+func NewPhoneAPIKeyHandlerValidator(
+ logger telemetry.Logger,
+ tracer telemetry.Tracer,
+) (v *PhoneHandlerValidator) {
+ return &PhoneHandlerValidator{
+ logger: logger.WithService(fmt.Sprintf("%T", v)),
+ tracer: tracer,
+ }
+}
+
+// ValidateStore validates requests.PhoneAPIKeyStoreRequest
+func (validator *PhoneAPIKeyHandlerValidator) ValidateStore(_ context.Context, request requests.PhoneAPIKeyStoreRequest) url.Values {
+ v := govalidator.New(govalidator.Options{
+ Data: &request,
+ Rules: govalidator.MapData{
+ "name": []string{
+ "min:1",
+ "max:60",
+ },
+ },
+ })
+
+ return v.ValidateStruct()
+}
diff --git a/api/pkg/validators/validator.go b/api/pkg/validators/validator.go
index 4200f592..7ca86f61 100644
--- a/api/pkg/validators/validator.go
+++ b/api/pkg/validators/validator.go
@@ -1,7 +1,6 @@
package validators
import (
- "context"
"fmt"
"net/url"
"regexp"
@@ -144,7 +143,7 @@ func init() {
}
// ValidateUUID that the payload is a UUID
-func (validator *validator) ValidateUUID(_ context.Context, ID string, name string) url.Values {
+func (validator *validator) ValidateUUID(ID string, name string) url.Values {
request := map[string]string{
name: ID,
}