Skip to content

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

feat: add entitlement service to limit send schedules for free users

Acho Arnold24159f1eeacf
diff --git a/api/.env.docker b/api/.env.docker
index 5441d7fe..cf8f8cda 100644
--- a/api/.env.docker
+++ b/api/.env.docker
@@ -5,6 +5,10 @@ GCP_PROJECT_ID=httpsms-docker
USE_HTTP_LOGGER=true
+# Set to "true" to enable feature entitlement checks (limits for free users).
+# Defaults to "false" for self-hosted deployments (no limits).
+ENTITLEMENT_ENABLED=false
+
EVENTS_QUEUE_TYPE=emulator
EVENTS_QUEUE_NAME=events-local
EVENTS_QUEUE_ENDPOINT=http://localhost:8000/v1/events
diff --git a/api/pkg/di/container.go b/api/pkg/di/container.go
index 676cb1dc..5727f6f7 100644
--- a/api/pkg/di/container.go
+++ b/api/pkg/di/container.go
@@ -788,6 +788,7 @@ func (container *Container) SendScheduleHandler() *handlers.SendScheduleHandler
container.Tracer(),
container.SendScheduleHandlerValidator(),
container.SendScheduleService(),
+ container.EntitlementService(),
)
}
@@ -801,6 +802,17 @@ func (container *Container) BillingUsageRepository() (repository repositories.Bi
)
}
+// EntitlementService creates a new instance of services.EntitlementService
+func (container *Container) EntitlementService() *services.EntitlementService {
+ container.logger.Debug("creating services.EntitlementService")
+ return services.NewEntitlementService(
+ container.Logger(),
+ container.Tracer(),
+ os.Getenv("ENTITLEMENT_ENABLED") == "true",
+ container.UserRepository(),
+ )
+}
+
// DiscordRepository creates a new instance of repositories.DiscordRepository
func (container *Container) DiscordRepository() (repository repositories.DiscordRepository) {
container.logger.Debug("creating GORM repositories.DiscordRepository")
diff --git a/api/pkg/handlers/send_schedule_handler.go b/api/pkg/handlers/send_schedule_handler.go
index cb636f49..ebf475a3 100644
--- a/api/pkg/handlers/send_schedule_handler.go
+++ b/api/pkg/handlers/send_schedule_handler.go
@@ -17,10 +17,11 @@ import (
// SendScheduleHandler handles HTTP requests for message send schedules.
type SendScheduleHandler struct {
handler
- logger telemetry.Logger
- tracer telemetry.Tracer
- validator *validators.SendScheduleHandlerValidator
- service *services.SendScheduleService
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+ validator *validators.SendScheduleHandlerValidator
+ service *services.SendScheduleService
+ entitlementService *services.EntitlementService
}
// NewSendScheduleHandler creates a new SendScheduleHandler.
@@ -29,12 +30,14 @@ func NewSendScheduleHandler(
tracer telemetry.Tracer,
validator *validators.SendScheduleHandlerValidator,
service *services.SendScheduleService,
+ entitlementService *services.EntitlementService,
) *SendScheduleHandler {
return &SendScheduleHandler{
- logger: logger.WithService(fmt.Sprintf("%T", &SendScheduleHandler{})),
- tracer: tracer,
- validator: validator,
- service: service,
+ logger: logger.WithService(fmt.Sprintf("%T", &SendScheduleHandler{})),
+ tracer: tracer,
+ validator: validator,
+ service: service,
+ entitlementService: entitlementService,
}
}
@@ -82,6 +85,7 @@ func (h *SendScheduleHandler) Index(c *fiber.Ctx) error {
// @Success 201 {object} responses.SendScheduleResponse
// @Failure 400 {object} responses.BadRequest
// @Failure 401 {object} responses.Unauthorized
+// @Failure 402 {object} responses.BadRequest
// @Failure 422 {object} responses.UnprocessableEntity
// @Failure 500 {object} responses.InternalServerError
// @Router /send-schedules [post]
@@ -89,6 +93,23 @@ func (h *SendScheduleHandler) Store(c *fiber.Ctx) error {
ctx, span, ctxLogger := h.tracer.StartFromFiberCtxWithLogger(c, h.logger)
defer span.End()
+ userID := h.userIDFomContext(c)
+
+ count, err := 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"))
+ return h.responseInternalServerError(c)
+ }
+ if !result.Allowed {
+ return h.responsePaymentRequired(c, result.Message)
+ }
+
var request requests.SendScheduleStore
if err := c.BodyParser(&request); err != nil {
return h.responseBadRequest(c, err)
diff --git a/api/pkg/repositories/gorm_send_schedule_repository.go b/api/pkg/repositories/gorm_send_schedule_repository.go
index afd09472..4ee3c408 100644
--- a/api/pkg/repositories/gorm_send_schedule_repository.go
+++ b/api/pkg/repositories/gorm_send_schedule_repository.go
@@ -166,3 +166,25 @@ func (r *gormSendScheduleRepository) DeleteAllForUser(
return nil
}
+
+// CountByUser returns the number of schedules owned by a user.
+func (r *gormSendScheduleRepository) CountByUser(
+ ctx context.Context,
+ userID entities.UserID,
+) (int, error) {
+ ctx, span := r.tracer.Start(ctx)
+ defer span.End()
+
+ var count int64
+ if 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),
+ )
+ }
+
+ return int(count), nil
+}
diff --git a/api/pkg/repositories/send_schedule_repository.go b/api/pkg/repositories/send_schedule_repository.go
index 57e07ca6..d57b42d7 100644
--- a/api/pkg/repositories/send_schedule_repository.go
+++ b/api/pkg/repositories/send_schedule_repository.go
@@ -26,4 +26,7 @@ type SendScheduleRepository interface {
// DeleteAllForUser removes all message send schedules owned by a user.
DeleteAllForUser(ctx context.Context, userID entities.UserID) error
+
+ // CountByUser returns the number of schedules owned by a user.
+ CountByUser(ctx context.Context, userID entities.UserID) (int, error)
}
diff --git a/api/pkg/services/entitlement_service.go b/api/pkg/services/entitlement_service.go
new file mode 100644
index 00000000..62c280ab
--- /dev/null
+++ b/api/pkg/services/entitlement_service.go
@@ -0,0 +1,96 @@
+package services
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/NdoleStudio/httpsms/pkg/entities"
+ "github.com/NdoleStudio/httpsms/pkg/repositories"
+ "github.com/NdoleStudio/httpsms/pkg/telemetry"
+ "github.com/palantir/stacktrace"
+)
+
+// entityLimits maps entity name → subscription plan → max count.
+// A limit of 0 means unlimited. If a plan is not listed, it defaults to unlimited (0).
+var entityLimits = map[string]map[entities.SubscriptionName]int{
+ "MessageSendSchedule": {
+ entities.SubscriptionNameFree: 1,
+ },
+}
+
+// EntitlementCheckResult holds the outcome of an entitlement check.
+type EntitlementCheckResult struct {
+ Allowed bool
+ Message string
+}
+
+// EntitlementService checks whether a user can create more of a given entity
+// based on their subscription plan.
+type EntitlementService struct {
+ service
+ logger telemetry.Logger
+ tracer telemetry.Tracer
+ enabled bool
+ userRepository repositories.UserRepository
+}
+
+// NewEntitlementService creates a new EntitlementService.
+// The enabled flag should come from the ENTITLEMENT_ENABLED environment variable.
+func NewEntitlementService(
+ logger telemetry.Logger,
+ tracer telemetry.Tracer,
+ enabled bool,
+ userRepository repositories.UserRepository,
+) *EntitlementService {
+ return &EntitlementService{
+ logger: logger.WithService(fmt.Sprintf("%T", &EntitlementService{})),
+ tracer: tracer,
+ enabled: enabled,
+ userRepository: userRepository,
+ }
+}
+
+// Check verifies if the user can create another instance of the given entity.
+func (service *EntitlementService) Check(
+ ctx context.Context,
+ userID entities.UserID,
+ entityName string,
+ currentCount int,
+) (*EntitlementCheckResult, error) {
+ ctx, span := service.tracer.Start(ctx)
+ defer span.End()
+
+ if !service.enabled {
+ return &EntitlementCheckResult{Allowed: true}, nil
+ }
+
+ limits, exists := entityLimits[entityName]
+ if !exists {
+ return &EntitlementCheckResult{Allowed: true}, nil
+ }
+
+ user, err := service.userRepository.Load(ctx, userID)
+ if err != nil {
+ return nil, service.tracer.WrapErrorSpan(
+ span,
+ stacktrace.Propagate(err, fmt.Sprintf("cannot load user [%s] for entitlement check", userID)),
+ )
+ }
+
+ limit, hasLimit := limits[user.SubscriptionName]
+ if !hasLimit || limit == 0 {
+ return &EntitlementCheckResult{Allowed: true}, nil
+ }
+
+ if currentCount >= limit {
+ return &EntitlementCheckResult{
+ Allowed: false,
+ Message: fmt.Sprintf(
+ "Upgrade to a paid plan to create more than %d send schedule. Visit https://httpsms.com/pricing for details.",
+ limit,
+ ),
+ }, nil
+ }
+
+ return &EntitlementCheckResult{Allowed: true}, nil
+}
diff --git a/api/pkg/services/send_schedule_service.go b/api/pkg/services/send_schedule_service.go
index 5bbddb7d..b984b32d 100644
--- a/api/pkg/services/send_schedule_service.go
+++ b/api/pkg/services/send_schedule_service.go
@@ -51,6 +51,14 @@ func (service *SendScheduleService) Index(
return service.repository.Index(ctx, userID)
}
+// CountByUser returns the number of schedules owned by a user.
+func (service *SendScheduleService) CountByUser(
+ ctx context.Context,
+ userID entities.UserID,
+) (int, error) {
+ return service.repository.CountByUser(ctx, userID)
+}
+
// Load returns a single message send schedule for a user.
func (service *SendScheduleService) Load(
ctx context.Context,