Skip to content

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

Fix code

Acho Arnold5a64c0813d18
diff --git a/api/pkg/di/container.go b/api/pkg/di/container.go
index cf8360f4..1dc808b5 100644
--- a/api/pkg/di/container.go
+++ b/api/pkg/di/container.go
@@ -663,6 +663,7 @@ func (container *Container) PhoneHandlerValidator() (validator *validators.Phone
return validators.NewPhoneHandlerValidator(
container.Logger(),
container.Tracer(),
+ container.MessageSendScheduleService(),
)
}
@@ -1117,7 +1118,6 @@ func (container *Container) PhoneHandler() (handler *handlers.PhoneHandler) {
container.Logger(),
container.Tracer(),
container.PhoneService(),
- container.MessageSendScheduleService(),
container.PhoneHandlerValidator(),
)
}
diff --git a/api/pkg/entities/message_send_schedule.go b/api/pkg/entities/message_send_schedule.go
index 17b8a7b7..20c9b628 100644
--- a/api/pkg/entities/message_send_schedule.go
+++ b/api/pkg/entities/message_send_schedule.go
@@ -19,7 +19,6 @@ type MessageSendSchedule struct {
UserID UserID `json:"user_id" example:"WB7DRDWrJZRGbYrv2CKGkqbzvqdC"`
Name string `json:"name" example:"Business Hours"`
Timezone string `json:"timezone" example:"Europe/Tallinn"`
- IsActive bool `json:"is_active" gorm:"default:true" example:"true"`
Windows []MessageSendScheduleWindow `json:"windows" gorm:"type:jsonb;serializer:json"`
CreatedAt time.Time `json:"created_at" example:"2022-06-05T14:26:02.302718+03:00"`
UpdatedAt time.Time `json:"updated_at" example:"2022-06-05T14:26:10.303278+03:00"`
@@ -30,11 +29,7 @@ type MessageSendSchedule struct {
// the current time is returned in UTC. An active schedule with no windows
// is treated as inactive (messages are sent immediately).
func (schedule *MessageSendSchedule) ResolveScheduledAt(current time.Time) time.Time {
- if schedule == nil || !schedule.IsActive {
- return current.UTC()
- }
-
- if len(schedule.Windows) == 0 {
+ if schedule == nil || len(schedule.Windows) == 0 {
return current.UTC()
}
@@ -55,27 +50,11 @@ func (schedule *MessageSendSchedule) ResolveScheduledAt(current time.Time) time.
continue
}
- start := time.Date(
- day.Year(),
- day.Month(),
- day.Day(),
- 0,
- 0,
- 0,
- 0,
- location,
- ).Add(time.Duration(window.StartMinute) * time.Minute)
-
- end := time.Date(
- day.Year(),
- day.Month(),
- day.Day(),
- 0,
- 0,
- 0,
- 0,
- location,
- ).Add(time.Duration(window.EndMinute) * time.Minute)
+ start := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, location).
+ Add(time.Duration(window.StartMinute) * time.Minute)
+
+ end := time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, location).
+ Add(time.Duration(window.EndMinute) * time.Minute)
var candidate time.Time
diff --git a/api/pkg/entities/message_send_schedule_test.go b/api/pkg/entities/message_send_schedule_test.go
index 1480aa2f..2554fda3 100644
--- a/api/pkg/entities/message_send_schedule_test.go
+++ b/api/pkg/entities/message_send_schedule_test.go
@@ -16,7 +16,7 @@ func TestResolveScheduledAt_NilSchedule_ReturnsCurrentUTC(t *testing.T) {
func TestResolveScheduledAt_InactiveSchedule_ReturnsCurrentUTC(t *testing.T) {
now := time.Now()
- schedule := &MessageSendSchedule{IsActive: false}
+ schedule := &MessageSendSchedule{}
result := schedule.ResolveScheduledAt(now)
assert.Equal(t, now.UTC(), result)
}
@@ -24,7 +24,6 @@ func TestResolveScheduledAt_InactiveSchedule_ReturnsCurrentUTC(t *testing.T) {
func TestResolveScheduledAt_NoWindows_ReturnsCurrentUTC(t *testing.T) {
now := time.Now()
schedule := &MessageSendSchedule{
- IsActive: true,
Timezone: "UTC",
Windows: []MessageSendScheduleWindow{},
}
@@ -36,7 +35,6 @@ func TestResolveScheduledAt_WithinWindow_ReturnsCurrentUTC(t *testing.T) {
// Wednesday at 10:00 UTC, window is Wed 9:00-17:00 (540-1020 minutes)
now := time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC) // Wednesday
schedule := &MessageSendSchedule{
- IsActive: true,
Timezone: "UTC",
Windows: []MessageSendScheduleWindow{
{DayOfWeek: int(now.Weekday()), StartMinute: 540, EndMinute: 1020},
@@ -50,7 +48,6 @@ func TestResolveScheduledAt_BeforeWindow_ReturnsWindowStart(t *testing.T) {
// Wednesday at 7:00 UTC, window is Wed 9:00-17:00
now := time.Date(2025, 1, 1, 7, 0, 0, 0, time.UTC) // Wednesday
schedule := &MessageSendSchedule{
- IsActive: true,
Timezone: "UTC",
Windows: []MessageSendScheduleWindow{
{DayOfWeek: int(now.Weekday()), StartMinute: 540, EndMinute: 1020},
diff --git a/api/pkg/entities/phone.go b/api/pkg/entities/phone.go
index f97212ce..d52e452a 100644
--- a/api/pkg/entities/phone.go
+++ b/api/pkg/entities/phone.go
@@ -8,14 +8,14 @@ import (
// Phone represents an android phone which has installed the http sms app
type Phone struct {
- ID uuid.UUID `json:"id" gorm:"primaryKey;type:uuid;" example:"32343a19-da5e-4b1b-a767-3298a73703cb"`
- UserID UserID `json:"user_id" example:"WB7DRDWrJZRGbYrv2CKGkqbzvqdC"`
- FcmToken *string `json:"fcm_token" example:"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzd....." validate:"optional"`
- PhoneNumber string `json:"phone_number" example:"+18005550199"`
- MessagesPerMinute uint `json:"messages_per_minute" example:"1"`
- SIM SIM `json:"sim" gorm:"default:SIM1"`
- ScheduleID *uuid.UUID `json:"schedule_id" gorm:"type:uuid" example:"32343a19-da5e-4b1b-a767-3298a73703cb"`
- Schedule *MessageSendSchedule `json:"-" gorm:"foreignKey:ScheduleID;constraint:OnDelete:SET NULL"`
+ ID uuid.UUID `json:"id" gorm:"primaryKey;type:uuid;" example:"32343a19-da5e-4b1b-a767-3298a73703cb"`
+ UserID UserID `json:"user_id" example:"WB7DRDWrJZRGbYrv2CKGkqbzvqdC"`
+ FcmToken *string `json:"fcm_token" example:"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzd....." validate:"optional"`
+ PhoneNumber string `json:"phone_number" example:"+18005550199"`
+ MessagesPerMinute uint `json:"messages_per_minute" example:"1"`
+ SIM SIM `json:"sim" gorm:"default:SIM1"`
+ MessageSendScheduleID *uuid.UUID `json:"message_send_schedule_id" gorm:"type:uuid" example:"32343a19-da5e-4b1b-a767-3298a73703cb"`
+
// MaxSendAttempts determines how many times to retry sending an SMS message
MaxSendAttempts uint `json:"max_send_attempts" example:"2"`
diff --git a/api/pkg/handlers/message_send_schedule_handler.go b/api/pkg/handlers/message_send_schedule_handler.go
index a688987c..446f50e1 100644
--- a/api/pkg/handlers/message_send_schedule_handler.go
+++ b/api/pkg/handlers/message_send_schedule_handler.go
@@ -54,7 +54,7 @@ func (h *MessageSendScheduleHandler) RegisterRoutes(router fiber.Router, middlew
// @Summary List send schedules
// @Description List all send schedules owned by the authenticated user.
// @Security ApiKeyAuth
-// @Tags Send Schedules
+// @Tags SendSchedules
// @Produce json
// @Success 200 {object} responses.MessageSendSchedulesResponse
// @Failure 401 {object} responses.Unauthorized
@@ -64,9 +64,11 @@ func (h *MessageSendScheduleHandler) Index(c *fiber.Ctx) error {
ctx, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
defer span.End()
- schedules, err := h.service.Index(ctx, h.userIDFomContext(c))
+ userID := h.userIDFomContext(c)
+
+ schedules, err := h.service.Index(ctx, userID)
if err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot list send schedules"))
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot list send schedules for user [%s]", userID)))
return h.responseInternalServerError(c)
}
@@ -78,7 +80,7 @@ func (h *MessageSendScheduleHandler) Index(c *fiber.Ctx) error {
// @Summary Create send schedule
// @Description Create a new send schedule for the authenticated user.
// @Security ApiKeyAuth
-// @Tags Send Schedules
+// @Tags SendSchedules
// @Accept json
// @Produce json
// @Param payload body requests.MessageSendScheduleStore true "Payload of new send schedule."
@@ -95,15 +97,11 @@ func (h *MessageSendScheduleHandler) Store(c *fiber.Ctx) error {
userID := h.userIDFomContext(c)
- count, err := h.service.CountByUser(ctx, userID)
+ result, err := h.entitlementService.Check(ctx, userID, "MessageSendSchedule", func() (int, error) {
+ return h.service.CountByUser(ctx, userID)
+ })
if err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot count send schedules for entitlement check"))
- return h.responseInternalServerError(c)
- }
-
- result, err := h.entitlementService.Check(ctx, userID, "MessageSendSchedule", count)
- if err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot check entitlement for send schedules"))
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot check entitlement for send schedules for user [%s]", userID)))
return h.responseInternalServerError(c)
}
if !result.Allowed {
@@ -111,7 +109,7 @@ func (h *MessageSendScheduleHandler) Store(c *fiber.Ctx) error {
}
var request requests.MessageSendScheduleStore
- if err := c.BodyParser(&request); err != nil {
+ if err = c.BodyParser(&request); err != nil {
return h.responseBadRequest(c, err)
}
@@ -127,7 +125,7 @@ func (h *MessageSendScheduleHandler) Store(c *fiber.Ctx) error {
schedule, err := h.service.Store(ctx, request.ToParams(h.userFromContext(c)))
if err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot create send schedule"))
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot create send schedule for user [%s]", userID)))
return h.responseInternalServerError(c)
}
@@ -139,7 +137,7 @@ func (h *MessageSendScheduleHandler) Store(c *fiber.Ctx) error {
// @Summary Update send schedule
// @Description Update a send schedule owned by the authenticated user.
// @Security ApiKeyAuth
-// @Tags Send Schedules
+// @Tags SendSchedules
// @Accept json
// @Produce json
// @Param scheduleID path string true "Schedule ID"
@@ -170,14 +168,11 @@ func (h *MessageSendScheduleHandler) Update(c *fiber.Ctx) error {
return h.responseUnprocessableEntity(c, errors, "validation errors while updating send schedule")
}
- schedule, err := h.service.Update(
- ctx,
- h.userIDFomContext(c),
- scheduleID,
- request.ToParams(h.userFromContext(c)),
- )
+ userID := h.userIDFomContext(c)
+
+ schedule, err := h.service.Update(ctx, userID, scheduleID, request.ToParams(h.userFromContext(c)))
if err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot update send schedule"))
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot update send schedule for user [%s] and schedule [%s]", userID, scheduleID)))
if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
return h.responseNotFound(c, err.Error())
}
@@ -192,7 +187,7 @@ func (h *MessageSendScheduleHandler) Update(c *fiber.Ctx) error {
// @Summary Delete send schedule
// @Description Delete a send schedule owned by the authenticated user.
// @Security ApiKeyAuth
-// @Tags Send Schedules
+// @Tags SendSchedules
// @Produce json
// @Param scheduleID path string true "Schedule ID"
// @Success 204
@@ -210,19 +205,18 @@ func (h *MessageSendScheduleHandler) Delete(c *fiber.Ctx) error {
return h.responseBadRequest(c, err)
}
- if _, err = h.service.Load(ctx, h.userIDFomContext(c), scheduleID); err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot load send schedule for deletion"))
+ userID := h.userIDFomContext(c)
+
+ if _, err = h.service.Load(ctx, userID, scheduleID); err != nil {
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot load send schedule for deletion for user [%s] and schedule [%s]", userID, scheduleID)))
if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
return h.responseNotFound(c, err.Error())
}
return h.responseInternalServerError(c)
}
- if err = h.service.Delete(ctx, h.userIDFomContext(c), scheduleID); err != nil {
- ctxLogger.Error(stacktrace.Propagate(err, "cannot delete send schedule"))
- if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
- return h.responseNotFound(c, err.Error())
- }
+ if err = h.service.Delete(ctx, userID, scheduleID); err != nil {
+ ctxLogger.Error(stacktrace.Propagate(err, fmt.Sprintf("cannot delete send schedule for user [%s] and schedule [%s]", userID, scheduleID)))
return h.responseInternalServerError(c)
}
diff --git a/api/pkg/handlers/phone_handler.go b/api/pkg/handlers/phone_handler.go
index 62ec35b7..28db8585 100644
--- a/api/pkg/handlers/phone_handler.go
+++ b/api/pkg/handlers/phone_handler.go
@@ -2,13 +2,10 @@ package handlers
import (
"fmt"
- "net/url"
- "strings"
"github.com/NdoleStudio/httpsms/pkg/requests"
"github.com/NdoleStudio/httpsms/pkg/validators"
"github.com/davecgh/go-spew/spew"
- "github.com/google/uuid"
"github.com/NdoleStudio/httpsms/pkg/services"
"github.com/NdoleStudio/httpsms/pkg/telemetry"
@@ -19,11 +16,10 @@ import (
// PhoneHandler handles phone http requests.
type PhoneHandler struct {
handler
- logger telemetry.Logger
- tracer telemetry.Tracer
- service *services.PhoneService
- scheduleService *services.MessageSendScheduleService
- validator *validators.PhoneHandlerValidator
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+ service *services.PhoneService
+ validator *validators.PhoneHandlerValidator
}
// NewPhoneHandler creates a new PhoneHandler
@@ -31,15 +27,13 @@ func NewPhoneHandler(
logger telemetry.Logger,
tracer telemetry.Tracer,
service *services.PhoneService,
- scheduleService *services.MessageSendScheduleService,
validator *validators.PhoneHandlerValidator,
) (h *PhoneHandler) {
return &PhoneHandler{
- logger: logger.WithService(fmt.Sprintf("%T", h)),
- tracer: tracer,
- validator: validator,
- service: service,
- scheduleService: scheduleService,
+ logger: logger.WithService(fmt.Sprintf("%T", h)),
+ tracer: tracer,
+ validator: validator,
+ service: service,
}
}
@@ -127,22 +121,13 @@ func (h *PhoneHandler) Upsert(c *fiber.Ctx) error {
return h.responseBadRequest(c, err)
}
- if errors := h.validator.ValidateUpsert(ctx, request.Sanitize()); len(errors) != 0 {
+ if errors := h.validator.ValidateUpsert(ctx, h.userIDFomContext(c), 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")
}
- if request.ScheduleID != nil && strings.TrimSpace(*request.ScheduleID) != "" {
- scheduleID, _ := uuid.Parse(strings.TrimSpace(*request.ScheduleID))
- if _, err := h.scheduleService.Load(ctx, h.userFromContext(c).ID, scheduleID); err != nil {
- validationErrors := url.Values{}
- validationErrors.Add("schedule_id", "schedule_id does not belong to the authenticated user or does not exist")
- return h.responseUnprocessableEntity(c, validationErrors, "validation errors while updating phones")
- }
- }
-
- phone, err := h.service.Upsert(ctx, request.ToUpsertParams(h.userFromContext(c), c.OriginalURL()))
+ phone, err := h.service.Upsert(ctx, request.ToUpsertParams(h.userFromContext(c), c.OriginalURL(), c.Body()))
if err != nil {
msg := fmt.Sprintf("cannot update phones with params [%+#v]", request)
ctxLogger.Error(stacktrace.Propagate(err, msg))
diff --git a/api/pkg/listeners/message_send_schedule_listener.go b/api/pkg/listeners/message_send_schedule_listener.go
index 61e57b24..20d4955d 100644
--- a/api/pkg/listeners/message_send_schedule_listener.go
+++ b/api/pkg/listeners/message_send_schedule_listener.go
@@ -45,28 +45,12 @@ func (listener *MessageSendScheduleListener) onUserAccountDeleted(
var payload events.UserAccountDeletedPayload
if err := event.DataAs(&payload); err != nil {
- return listener.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(
- err,
- "cannot decode [%s] into [%T]",
- event.Data(),
- payload,
- ),
- )
+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, fmt.Sprintf("cannot decode [%s] into [%T]", event.Data(), payload)))
}
if err := listener.service.DeleteAllForUser(ctx, payload.UserID); err != nil {
- return listener.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(
- err,
- "cannot delete [entities.MessageSendSchedule] for user [%s] on [%s] event with ID [%s]",
- payload.UserID,
- event.Type(),
- event.ID(),
- ),
- )
+ msg := fmt.Sprintf("cannot delete [entities.MessageSendSchedule] for user [%s] on [%s] event with ID [%s]", payload.UserID, event.Type(), event.ID())
+ return listener.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
}
return nil
diff --git a/api/pkg/repositories/gorm_message_send_schedule_repository.go b/api/pkg/repositories/gorm_message_send_schedule_repository.go
index 919eb6a9..54e58843 100644
--- a/api/pkg/repositories/gorm_message_send_schedule_repository.go
+++ b/api/pkg/repositories/gorm_message_send_schedule_repository.go
@@ -41,10 +41,7 @@ func (r *gormMessageSendScheduleRepository) Store(
defer span.End()
if err := r.db.WithContext(ctx).Create(schedule).Error; err != nil {
- return r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot store send schedule [%s]", schedule.ID),
- )
+ return r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot store send schedule [%s]", schedule.ID))
}
return nil
@@ -59,10 +56,7 @@ func (r *gormMessageSendScheduleRepository) Update(
defer span.End()
if err := r.db.WithContext(ctx).Save(schedule).Error; err != nil {
- return r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot update send schedule [%s]", schedule.ID),
- )
+ return r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot update send schedule [%s]", schedule.ID))
}
return nil
@@ -85,19 +79,11 @@ func (r *gormMessageSendScheduleRepository) Load(
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, r.tracer.WrapErrorSpan(
span,
- stacktrace.PropagateWithCode(
- err,
- ErrCodeNotFound,
- "send schedule [%s] not found",
- scheduleID,
- ),
+ stacktrace.PropagateWithCode(err, ErrCodeNotFound, "send schedule [%s] not found for user with ID [%s]", scheduleID, userID),
)
}
if err != nil {
- return nil, r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot load send schedule [%s]", scheduleID),
- )
+ return nil, r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot load send schedule [%s]", scheduleID))
}
return item, nil
@@ -112,14 +98,12 @@ func (r *gormMessageSendScheduleRepository) Index(
defer span.End()
items := make([]entities.MessageSendSchedule, 0)
- if err := r.db.WithContext(ctx).
+ err := r.db.WithContext(ctx).
Where("user_id = ?", userID).
- Order("created_at ASC").
- Find(&items).Error; err != nil {
- return nil, r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot index send schedules for user [%s]", userID),
- )
+ Order("created_at DESC").
+ Find(&items).Error
+ if err != nil {
+ return nil, r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot index send schedules for user [%s]", userID))
}
return items, nil
@@ -134,14 +118,12 @@ func (r *gormMessageSendScheduleRepository) Delete(
ctx, span := r.tracer.Start(ctx)
defer span.End()
- if err := r.db.WithContext(ctx).
+ err := r.db.WithContext(ctx).
Where("user_id = ?", userID).
Where("id = ?", scheduleID).
- Delete(&entities.MessageSendSchedule{}).Error; err != nil {
- return r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot delete send schedule [%s]", scheduleID),
- )
+ Delete(&entities.MessageSendSchedule{}).Error
+ if err != nil {
+ return r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot delete send schedule [%s]", scheduleID))
}
return nil
@@ -155,13 +137,11 @@ func (r *gormMessageSendScheduleRepository) DeleteAllForUser(
ctx, span := r.tracer.Start(ctx)
defer span.End()
- if err := r.db.WithContext(ctx).
+ err := r.db.WithContext(ctx).
Where("user_id = ?", userID).
- Delete(&entities.MessageSendSchedule{}).Error; err != nil {
- return r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot delete send schedules for user [%s]", userID),
- )
+ Delete(&entities.MessageSendSchedule{}).Error
+ if err != nil {
+ return r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot delete send schedules for user [%s]", userID))
}
return nil
@@ -176,14 +156,12 @@ func (r *gormMessageSendScheduleRepository) CountByUser(
defer span.End()
var count int64
- if err := r.db.WithContext(ctx).
+ err := r.db.WithContext(ctx).
Model(&entities.MessageSendSchedule{}).
Where("user_id = ?", userID).
- Count(&count).Error; err != nil {
- return 0, r.tracer.WrapErrorSpan(
- span,
- stacktrace.Propagate(err, "cannot count send schedules for user [%s]", userID),
- )
+ Count(&count).Error
+ if err != nil {
+ return 0, r.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, "cannot count send schedules for user [%s]", userID))
}
return int(count), nil
diff --git a/api/pkg/requests/message_send_schedule_store_request.go b/api/pkg/requests/message_send_schedule_store_request.go
index 1796e4bd..bd69fdc9 100644
--- a/api/pkg/requests/message_send_schedule_store_request.go
+++ b/api/pkg/requests/message_send_schedule_store_request.go
@@ -20,7 +20,6 @@ type MessageSendScheduleStore struct {
request
Name string `json:"name"`
Timezone string `json:"timezone"`
- IsActive bool `json:"is_active"`
Windows []MessageSendScheduleWindow `json:"windows"`
}
@@ -48,5 +47,5 @@ func (input *MessageSendScheduleStore) ToParams(user entities.AuthContext) *serv
for _, item := range input.Windows {
windows = append(windows, entities.MessageSendScheduleWindow{DayOfWeek: item.DayOfWeek, StartMinute: item.StartMinute, EndMinute: item.EndMinute})
}
- return &services.MessageSendScheduleUpsertParams{UserID: user.ID, Name: input.Name, Timezone: input.Timezone, IsActive: input.IsActive, Windows: windows}
+ return &services.MessageSendScheduleUpsertParams{UserID: user.ID, Name: input.Name, Timezone: input.Timezone, Windows: windows}
}
diff --git a/api/pkg/requests/phone_update_request.go b/api/pkg/requests/phone_update_request.go
index 06876de8..462d6428 100644
--- a/api/pkg/requests/phone_update_request.go
+++ b/api/pkg/requests/phone_update_request.go
@@ -1,6 +1,7 @@
package requests
import (
+ "encoding/json"
"strings"
"time"
@@ -31,7 +32,7 @@ type PhoneUpsert struct {
// SIM is the SIM slot of the phone in case the phone has more than 1 SIM slot
SIM string `json:"sim" example:"SIM1"`
- ScheduleID *string `json:"schedule_id,omitempty" example:"32343a19-da5e-4b1b-a767-3298a73703cb" validate:"optional"`
+ MessageSendScheduleID string `json:"message_send_schedule_id,omitempty" example:"32343a19-da5e-4b1b-a767-3298a73703cb" validate:"optional"`
}
// Sanitize sets defaults to MessageOutstanding
@@ -45,37 +46,38 @@ func (input *PhoneUpsert) Sanitize() PhoneUpsert {
return *input
}
-// ToUpsertParams converts PhoneUpsert to services.PhoneUpsertParams
-func (input *PhoneUpsert) ToUpsertParams(user entities.AuthContext, source string) *services.PhoneUpsertParams {
+// ToUpsertParams converts PhoneUpsert to services.PhoneUpsertParams.
+// The body parameter is the raw JSON request body used to detect which fields were explicitly sent.
+func (input *PhoneUpsert) ToUpsertParams(user entities.AuthContext, source string, body []byte) *services.PhoneUpsertParams {
phone, _ := phonenumbers.Parse(input.PhoneNumber, phonenumbers.UNKNOWN_REGION)
- // ignore value if it's default
+ fields := make(map[string]json.RawMessage)
+ _ = json.Unmarshal(body, &fields)
+
var messagesPerMinute *uint
- if input.MessagesPerMinute != 0 {
+ if _, exists := fields["messages_per_minute"]; exists {
messagesPerMinute = &input.MessagesPerMinute
}
- // ignore default
var fcmToken *string
- if input.FcmToken != "" {
+ if _, exists := fields["fcm_token"]; exists {
fcmToken = &input.FcmToken
}
- // ignore default
var timeout *time.Duration
- if input.MessageExpirationSeconds != 0 {
+ if _, exists := fields["message_expiration_seconds"]; exists {
duration := time.Duration(input.MessageExpirationSeconds) * time.Second
timeout = &duration
}
var maxSendAttempts *uint
- if input.MaxSendAttempts != 0 {
+ if _, exists := fields["max_send_attempts"]; exists {
maxSendAttempts = &input.MaxSendAttempts
}
var scheduleID *uuid.UUID
- if input.ScheduleID != nil && strings.TrimSpace(*input.ScheduleID) != "" {
- if parsed, err := uuid.Parse(strings.TrimSpace(*input.ScheduleID)); err == nil {
+ if _, exists := fields["message_send_schedule_id"]; exists {
+ if parsed, err := uuid.Parse(strings.TrimSpace(input.MessageSendScheduleID)); err == nil {
scheduleID = &parsed
}
}
@@ -90,6 +92,6 @@ func (input *PhoneUpsert) ToUpsertParams(user entities.AuthContext, source strin
FcmToken: fcmToken,
UserID: user.ID,
SIM: entities.SIM(input.SIM),
- ScheduleID: scheduleID,
+ MessageSendScheduleID: scheduleID,
}
}
diff --git a/api/pkg/services/entitlement_service.go b/api/pkg/services/entitlement_service.go
index cd4d740f..59f077a2 100644
--- a/api/pkg/services/entitlement_service.go
+++ b/api/pkg/services/entitlement_service.go
@@ -58,7 +58,7 @@ func (service *EntitlementService) Check(
ctx context.Context,
userID entities.UserID,
entityName string,
- currentCount int,
+ countFunc func() (int, error),
) (*EntitlementCheckResult, error) {
ctx, span := service.tracer.Start(ctx)
defer span.End()
@@ -85,6 +85,14 @@ func (service *EntitlementService) Check(
return &EntitlementCheckResult{Allowed: true}, nil
}
+ currentCount, err := countFunc()
+ if err != nil {
+ return nil, service.tracer.WrapErrorSpan(
+ span,
+ stacktrace.Propagate(err, fmt.Sprintf("cannot count entities [%s] for user [%s]", entityName, userID)),
+ )
+ }
+
if currentCount >= limit {
return &EntitlementCheckResult{
Allowed: false,
diff --git a/api/pkg/services/message_send_schedule_service.go b/api/pkg/services/message_send_schedule_service.go
index e9140b5d..1d8cb337 100644
--- a/api/pkg/services/message_send_schedule_service.go
+++ b/api/pkg/services/message_send_schedule_service.go
@@ -39,7 +39,6 @@ type MessageSendScheduleUpsertParams struct {
UserID entities.UserID
Name string
Timezone string
- IsActive bool
Windows []entities.MessageSendScheduleWindow
}
@@ -81,7 +80,6 @@ func (service *MessageSendScheduleService) Store(
UserID: params.UserID,
Name: params.Name,
Timezone: params.Timezone,
- IsActive: params.IsActive,
Windows: sanitizeWindows(params.Windows),
CreatedAt: time.Now().UTC(),
UpdatedAt: time.Now().UTC(),
@@ -117,7 +115,6 @@ func (service *MessageSendScheduleService) Update(
schedule.Name = params.Name
schedule.Timezone = params.Timezone
- schedule.IsActive = params.IsActive
schedule.Windows = sanitizeWindows(params.Windows)
schedule.UpdatedAt = time.Now().UTC()
diff --git a/api/pkg/services/phone_notification_service.go b/api/pkg/services/phone_notification_service.go
index 9e6fb296..63b62678 100644
--- a/api/pkg/services/phone_notification_service.go
+++ b/api/pkg/services/phone_notification_service.go
@@ -15,6 +15,7 @@ import (
"github.com/NdoleStudio/httpsms/pkg/telemetry"
"github.com/google/uuid"
"github.com/palantir/stacktrace"
+ "go.opentelemetry.io/otel/trace"
)
// PhoneNotificationService sends out notifications to mobile phones
@@ -197,44 +198,19 @@ func (service *PhoneNotificationService) Schedule(ctx context.Context, params *P
UpdatedAt: time.Now().UTC(),
}
- // Bypass rate-limit and schedule window logic for exact send time
if params.ExactSendTime && params.ScheduledSendTime != nil {
- scheduledAt := *params.ScheduledSendTime
- if scheduledAt.Before(time.Now().UTC()) {
- scheduledAt = time.Now().UTC()
- }
- notification.ScheduledAt = scheduledAt
- if err = service.phoneNotificationRepository.ScheduleExact(ctx, notification); err != nil {
- msg := fmt.Sprintf("cannot schedule exact notification for message [%s] to phone [%s]", params.MessageID, phone.ID)
- return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
- }
-
- if err = service.dispatchMessageNotificationScheduled(ctx, params, notification); err != nil {
- ctxLogger.Error(err)
- }
-
- if err = service.dispatchMessageNotificationSend(ctx, params.Source, notification); err != nil {
- return service.tracer.WrapErrorSpan(span, err)
- }
-
- ctxLogger.Info(fmt.Sprintf(
- "message with id [%s] exact notification scheduled for [%s] with id [%s]",
- params.MessageID,
- notification.ScheduledAt,
- notification.ID,
- ))
- return nil
+ return service.scheduleExact(ctx, span, ctxLogger, params, phone, notification)
}
var schedule *entities.MessageSendSchedule
- if phone.ScheduleID != nil {
- schedule, err = service.messageSendScheduleRepository.Load(ctx, params.UserID, *phone.ScheduleID)
+ if phone.MessageSendScheduleID != nil {
+ schedule, err = service.messageSendScheduleRepository.Load(ctx, params.UserID, *phone.MessageSendScheduleID)
if stacktrace.GetCode(err) == repositories.ErrCodeNotFound {
schedule = nil
err = nil
}
if err != nil {
- msg := fmt.Sprintf("cannot load send schedule [%s] for phone [%s]", *phone.ScheduleID, phone.ID)
+ msg := fmt.Sprintf("cannot load send schedule [%s] for phone [%s]", *phone.MessageSendScheduleID, phone.ID)
return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
}
}
@@ -261,6 +237,42 @@ func (service *PhoneNotificationService) Schedule(ctx context.Context, params *P
return nil
}
+func (service *PhoneNotificationService) scheduleExact(
+ ctx context.Context,
+ span trace.Span,
+ ctxLogger telemetry.Logger,
+ params *PhoneNotificationScheduleParams,
+ phone *entities.Phone,
+ notification *entities.PhoneNotification,
+) error {
+ scheduledAt := *params.ScheduledSendTime
+ if scheduledAt.Before(time.Now().UTC()) {
+ scheduledAt = time.Now().UTC()
+ }
+ notification.ScheduledAt = scheduledAt
+
+ if err := service.phoneNotificationRepository.ScheduleExact(ctx, notification); err != nil {
+ msg := fmt.Sprintf("cannot schedule exact notification for message [%s] to phone [%s]", params.MessageID, phone.ID)
+ return service.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
+ }
+
+ if err := service.dispatchMessageNotificationScheduled(ctx, params, notification); err != nil {
+ ctxLogger.Error(err)
+ }
+
+ if err := service.dispatchMessageNotificationSend(ctx, params.Source, notification); err != nil {
+ return service.tracer.WrapErrorSpan(span, err)
+ }
+
+ ctxLogger.Info(fmt.Sprintf(
+ "message with id [%s] exact notification scheduled for [%s] with id [%s]",
+ params.MessageID,
+ notification.ScheduledAt,
+ notification.ID,
+ ))
+ return nil
+}
+
func (service *PhoneNotificationService) dispatchMessageNotificationSend(
ctx context.Context,
source string,
diff --git a/api/pkg/services/phone_service.go b/api/pkg/services/phone_service.go
index 9fa01ab0..1ddbf2a4 100644
--- a/api/pkg/services/phone_service.go
+++ b/api/pkg/services/phone_service.go
@@ -91,7 +91,7 @@ type PhoneUpsertParams struct {
MessageExpirationDuration *time.Duration
MissedCallAutoReply *string
SIM entities.SIM
- ScheduleID *uuid.UUID
+ MessageSendScheduleID *uuid.UUID
Source string
UserID entities.UserID
}
@@ -106,13 +106,13 @@ 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, &PhoneFCMTokenParams{
- Source: params.Source,
- PhoneNumber: params.PhoneNumber,
- PhoneAPIKeyID: nil,
- UserID: params.UserID,
- FcmToken: params.FcmToken,
- SIM: params.SIM,
- ScheduleID: params.ScheduleID,
+ Source: params.Source,
+ PhoneNumber: params.PhoneNumber,
+ PhoneAPIKeyID: nil,
+ UserID: params.UserID,
+ FcmToken: params.FcmToken,
+ SIM: params.SIM,
+ MessageSendScheduleID: params.MessageSendScheduleID,
})
}
@@ -128,13 +128,13 @@ 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, phone, &PhoneFCMTokenParams{
- Source: params.Source,
- PhoneNumber: params.PhoneNumber,
- PhoneAPIKeyID: nil,
- UserID: params.UserID,
- FcmToken: params.FcmToken,
- SIM: params.SIM,
- ScheduleID: params.ScheduleID,
+ Source: params.Source,
+ PhoneNumber: params.PhoneNumber,
+ PhoneAPIKeyID: nil,
+ UserID: params.UserID,
+ FcmToken: params.FcmToken,
+ SIM: params.SIM,
+ MessageSendScheduleID: params.MessageSendScheduleID,
})
}
@@ -204,13 +204,13 @@ func (service *PhoneService) Delete(ctx context.Context, source string, userID e
// 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
- ScheduleID *uuid.UUID
+ Source string
+ PhoneNumber *phonenumbers.PhoneNumber
+ PhoneAPIKeyID *uuid.UUID
+ UserID entities.UserID
+ FcmToken *string
+ SIM entities.SIM
+ MessageSendScheduleID *uuid.UUID
}
// UpsertFCMToken the FCM token for an entities.Phone
@@ -255,7 +255,7 @@ func (service *PhoneService) createPhone(ctx context.Context, params *PhoneFCMTo
MaxSendAttempts: 2,
SIM: params.SIM,
MissedCallAutoReply: nil,
- ScheduleID: params.ScheduleID,
+ MessageSendScheduleID: params.MessageSendScheduleID,
PhoneNumber: phonenumbers.Format(params.PhoneNumber, phonenumbers.E164),
CreatedAt: time.Now().UTC(),
UpdatedAt: time.Now().UTC(),
@@ -299,7 +299,7 @@ func (service *PhoneService) update(phone *entities.Phone, params *PhoneUpsertPa
}
phone.SIM = params.SIM
- phone.ScheduleID = params.ScheduleID
+ phone.MessageSendScheduleID = params.MessageSendScheduleID
return phone
}
diff --git a/api/pkg/validators/message_send_schedule_handler_validator.go b/api/pkg/validators/message_send_schedule_handler_validator.go
index 00e405ca..fa850de1 100644
--- a/api/pkg/validators/message_send_schedule_handler_validator.go
+++ b/api/pkg/validators/message_send_schedule_handler_validator.go
@@ -50,7 +50,7 @@ func (validator *MessageSendScheduleHandlerValidator) ValidateStore(
if request.Timezone != "" {
if _, err := time.LoadLocation(request.Timezone); err != nil {
- result.Add("timezone", "timezone must be a valid IANA timezone")
+ result.Add("timezone", "The timezone must be a valid IANA timezone e.g Europe/London.")
}
}
@@ -61,6 +61,11 @@ func (validator *MessageSendScheduleHandlerValidator) validateWindows(
result url.Values,
windows []requests.MessageSendScheduleWindow,
) {
+ if len(windows) == 0 {
+ result.Add("windows", "at least one active window is required")
+ return
+ }
+
windowsPerDay := make(map[int]int)
for index, item := range windows {
diff --git a/api/pkg/validators/phone_handler_validator.go b/api/pkg/validators/phone_handler_validator.go
index f9c78255..e9d4274e 100644
--- a/api/pkg/validators/phone_handler_validator.go
+++ b/api/pkg/validators/phone_handler_validator.go
@@ -7,27 +7,31 @@ import (
"strings"
"github.com/NdoleStudio/httpsms/pkg/entities"
-
"github.com/NdoleStudio/httpsms/pkg/requests"
+ "github.com/NdoleStudio/httpsms/pkg/services"
"github.com/NdoleStudio/httpsms/pkg/telemetry"
+ "github.com/google/uuid"
"github.com/thedevsaddam/govalidator"
)
// PhoneHandlerValidator validates models used in handlers.PhoneHandler
type PhoneHandlerValidator struct {
validator
- logger telemetry.Logger
- tracer telemetry.Tracer
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+ scheduleService *services.MessageSendScheduleService
}
// NewPhoneHandlerValidator creates a new handlers.PhoneHandler validator
func NewPhoneHandlerValidator(
logger telemetry.Logger,
tracer telemetry.Tracer,
+ scheduleService *services.MessageSendScheduleService,
) (v *PhoneHandlerValidator) {
return &PhoneHandlerValidator{
- logger: logger.WithService(fmt.Sprintf("%T", v)),
- tracer: tracer,
+ logger: logger.WithService(fmt.Sprintf("%T", v)),
+ tracer: tracer,
+ scheduleService: scheduleService,
}
}
@@ -56,7 +60,7 @@ func (validator *PhoneHandlerValidator) ValidateIndex(_ context.Context, request
}
// ValidateUpsert validates requests.PhoneUpsert
-func (validator *PhoneHandlerValidator) ValidateUpsert(_ context.Context, request requests.PhoneUpsert) url.Values {
+func (validator *PhoneHandlerValidator) ValidateUpsert(ctx context.Context, userID entities.UserID, request requests.PhoneUpsert) url.Values {
v := govalidator.New(govalidator.Options{
Data: &request,
Rules: govalidator.MapData{
@@ -84,25 +88,26 @@ func (validator *PhoneHandlerValidator) ValidateUpsert(_ context.Context, reques
"min:60",
"max:3600",
},
+ "message_send_schedule_id": []string{
+ "uuid",
+ },
},
})
result := v.ValidateStruct()
- if request.ScheduleID != nil && strings.TrimSpace(*request.ScheduleID) != "" {
- if uuidErrors := validator.ValidateUUID(strings.TrimSpace(*request.ScheduleID), "schedule_id"); len(uuidErrors) > 0 {
- for key, values := range uuidErrors {
- for _, value := range values {
- result.Add(key, value)
- }
- }
- }
+ if request.MaxSendAttempts > 0 && request.MessageExpirationSeconds == 0 {
+ result.Add("message_expiration_seconds", "message_expiration_seconds cannot be 0 when max_send_attempts is greater than 0")
}
+
if len(result) > 0 {
return result
}
- if request.MaxSendAttempts > 0 && request.MessageExpirationSeconds == 0 {
- result.Add("message_expiration_seconds", "message_expiration_seconds cannot be 0 when max_send_attempts is greater than 0")
+ if strings.TrimSpace(request.MessageSendScheduleID) != "" {
+ scheduleID, _ := uuid.Parse(strings.TrimSpace(request.MessageSendScheduleID))
+ if _, err := validator.scheduleService.Load(ctx, userID, scheduleID); err != nil {
+ result.Add("message_send_schedule_id", "The message_send_schedule_id does not belong to the authenticated user or does not exist")
+ }
}
return result
diff --git a/web/pages/settings/index.vue b/web/pages/settings/index.vue
index cbe4fe6e..6df69cd2 100644
--- a/web/pages/settings/index.vue
+++ b/web/pages/settings/index.vue
@@ -622,15 +622,17 @@
>
</v-text-field>
<v-autocomplete
- v-model="activePhone.schedule_id"
+ v-model="activePhone.message_send_schedule_id"
outlined
+ :readonly="sendSchedules.length === 0"
dense
clearable
label="Send Schedule"
:items="sendSchedules"
item-text="name"
item-value="id"
- hint="Optional: attach one availability schedule to this phone"
+ :multiple="false"
+ hint="Attach a send schedule to this phone"
persistent-hint
></v-autocomplete>
<v-textarea