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.goindex 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.goindex 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.goindex 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.goindex 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.gonew file mode 100644index 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.goindex 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.goindex 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.ContextPhoneNumbers: 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 ereturn *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).Errorif 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).Errorif 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).Errorif 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.goindex 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.PhoneAPIKeyCreate(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 apiKeyLoadAuthContext(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 userDeleteAllForUser(ctx context.Context, userID entities.UserID) errordiff --git a/api/pkg/requests/phone_api_key_store_request.go b/api/pkg/requests/phone_api_key_store_request.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 4200f592..7ca86f61 100644--- a/api/pkg/validators/validator.go+++ b/api/pkg/validators/validator.go@@ -1,7 +1,6 @@package validatorsimport (- "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,}