feat(enakgame): spin as an EnakGame game; remove the old game flow

EnakGame phase 10 of docs/tasks-enakgame.md (EG-1001 to EG-1003).

Spin (EG-1001)
- PROBABILITY entries take an optional label (a wheel segment). The customer game
  list shows a PROBABILITY game's prizes (entry, label, amount, never weights), and
  completing returns the drawn prize, so the client can draw the wheel and stop it
  on the server's draw.
- docs/enakgame-spin.md: the admin steps to set up spin per organization (no
  seeder) and the customer app flow. An HTTP test plays it end to end.

Old game flow removed (EG-1002)
- Routes POST /customer/spin, GET /customer/games, GET /customer/ferris-wheel, and
  admin /marketing/games, /marketing/game-prizes, /marketing/rewards, with their
  handlers, services, processors, repositories, validators, models, contracts,
  mappers and tests (GamePlayProcessor, SpinGameService, rewards, ...). This also
  closes RFC §15 findings 1 and 2 (double charge, spinning another org's game).
- Tables games, game_prizes, game_plays and rewards stay for ledger history.
  entities.StringSlice moves to its own file; the omset tracker (unrouted) keeps
  game_id but no longer embeds the old game response.

games.is_active dropped (EG-1003)
- Migration 000115; nothing reads metadata.coin_cost any more.

The EnakPoint integration docs now point at /customer/enakgame. The Postgres tests
were not run: no test database here. Migration 000115 has not been run anywhere.
The customer app must stop calling the removed endpoints before this is deployed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
efrilm
2026-10-07 21:31:56 +07:00
co-authored by Claude Opus 5.5
parent 296708244e
commit 18e87398bb
68 changed files with 467 additions and 5064 deletions
@@ -14,21 +14,6 @@ type GamificationValidator interface {
ValidateUpdateTierRequest(req *contract.UpdateTierRequest) (error, string)
ValidateListTiersRequest(req *contract.ListTiersRequest) (error, string)
// Games
ValidateCreateGameRequest(req *contract.CreateGameRequest) (error, string)
ValidateUpdateGameRequest(req *contract.UpdateGameRequest) (error, string)
ValidateListGamesRequest(req *contract.ListGamesRequest) (error, string)
// Game Prizes
ValidateCreateGamePrizeRequest(req *contract.CreateGamePrizeRequest) (error, string)
ValidateUpdateGamePrizeRequest(req *contract.UpdateGamePrizeRequest) (error, string)
ValidateListGamePrizesRequest(req *contract.ListGamePrizesRequest) (error, string)
// Game Plays
ValidateCreateGamePlayRequest(req *contract.CreateGamePlayRequest) (error, string)
ValidateListGamePlaysRequest(req *contract.ListGamePlaysRequest) (error, string)
ValidatePlayGameRequest(req *contract.PlayGameRequest) (error, string)
// Omset Tracker
ValidateCreateOmsetTrackerRequest(req *contract.CreateOmsetTrackerRequest) (error, string)
ValidateUpdateOmsetTrackerRequest(req *contract.UpdateOmsetTrackerRequest) (error, string)
@@ -109,206 +94,6 @@ func (v *GamificationValidatorImpl) ValidateListTiersRequest(req *contract.ListT
return nil, ""
}
// Game Validators
func (v *GamificationValidatorImpl) ValidateCreateGameRequest(req *contract.CreateGameRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Name != "" {
req.Name = strings.TrimSpace(req.Name)
if req.Name == "" {
return errors.New("name cannot be empty or whitespace only"), "INVALID_NAME"
}
if len(req.Name) > 255 {
return errors.New("name cannot exceed 255 characters"), "INVALID_NAME"
}
}
validGameTypes := []string{"SPIN", "RAFFLE", "MINIGAME"}
if !contains(validGameTypes, req.Type) {
return errors.New("invalid game type"), "INVALID_GAME_TYPE"
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidateUpdateGameRequest(req *contract.UpdateGameRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Name != nil && *req.Name != "" {
*req.Name = strings.TrimSpace(*req.Name)
if *req.Name == "" {
return errors.New("name cannot be empty or whitespace only"), "INVALID_NAME"
}
if len(*req.Name) > 255 {
return errors.New("name cannot exceed 255 characters"), "INVALID_NAME"
}
}
if req.Type != nil {
validGameTypes := []string{"SPIN", "RAFFLE", "MINIGAME"}
if !contains(validGameTypes, *req.Type) {
return errors.New("invalid game type"), "INVALID_GAME_TYPE"
}
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidateListGamesRequest(req *contract.ListGamesRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Page <= 0 {
req.Page = 1
}
if req.Limit <= 0 {
req.Limit = 10
}
if req.Limit > 100 {
req.Limit = 100
}
if req.Type != "" {
validGameTypes := []string{"SPIN", "RAFFLE", "MINIGAME"}
if !contains(validGameTypes, req.Type) {
return errors.New("invalid game type"), "INVALID_GAME_TYPE"
}
}
return nil, ""
}
// Game Prize Validators
func (v *GamificationValidatorImpl) ValidateCreateGamePrizeRequest(req *contract.CreateGamePrizeRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Name != "" {
req.Name = strings.TrimSpace(req.Name)
if req.Name == "" {
return errors.New("name cannot be empty or whitespace only"), "INVALID_NAME"
}
if len(req.Name) > 255 {
return errors.New("name cannot exceed 255 characters"), "INVALID_NAME"
}
}
if req.Weight <= 0 {
return errors.New("weight must be greater than 0"), "INVALID_WEIGHT"
}
if req.Stock < 0 {
return errors.New("stock cannot be negative"), "INVALID_STOCK"
}
if req.MaxStock != nil && *req.MaxStock <= 0 {
return errors.New("max stock must be greater than 0"), "INVALID_MAX_STOCK"
}
if req.Threshold != nil && *req.Threshold < 0 {
return errors.New("threshold cannot be negative"), "INVALID_THRESHOLD"
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidateUpdateGamePrizeRequest(req *contract.UpdateGamePrizeRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Name != nil && *req.Name != "" {
*req.Name = strings.TrimSpace(*req.Name)
if *req.Name == "" {
return errors.New("name cannot be empty or whitespace only"), "INVALID_NAME"
}
if len(*req.Name) > 255 {
return errors.New("name cannot exceed 255 characters"), "INVALID_NAME"
}
}
if req.Weight != nil && *req.Weight <= 0 {
return errors.New("weight must be greater than 0"), "INVALID_WEIGHT"
}
if req.Stock != nil && *req.Stock < 0 {
return errors.New("stock cannot be negative"), "INVALID_STOCK"
}
if req.MaxStock != nil && *req.MaxStock <= 0 {
return errors.New("max stock must be greater than 0"), "INVALID_MAX_STOCK"
}
if req.Threshold != nil && *req.Threshold < 0 {
return errors.New("threshold cannot be negative"), "INVALID_THRESHOLD"
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidateListGamePrizesRequest(req *contract.ListGamePrizesRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Page <= 0 {
req.Page = 1
}
if req.Limit <= 0 {
req.Limit = 10
}
if req.Limit > 100 {
req.Limit = 100
}
return nil, ""
}
// Game Play Validators
func (v *GamificationValidatorImpl) ValidateCreateGamePlayRequest(req *contract.CreateGamePlayRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.CoinsUsed < 0 {
return errors.New("coins used cannot be negative"), "INVALID_COINS_USED"
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidateListGamePlaysRequest(req *contract.ListGamePlaysRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
if req.Page <= 0 {
req.Page = 1
}
if req.Limit <= 0 {
req.Limit = 10
}
if req.Limit > 100 {
req.Limit = 100
}
return nil, ""
}
func (v *GamificationValidatorImpl) ValidatePlayGameRequest(req *contract.PlayGameRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
return err, "VALIDATION_ERROR"
}
return nil, ""
}
// Omset Tracker Validators
func (v *GamificationValidatorImpl) ValidateCreateOmsetTrackerRequest(req *contract.CreateOmsetTrackerRequest) (error, string) {
if err := v.validate.Struct(req); err != nil {
-263
View File
@@ -1,263 +0,0 @@
package validator
import (
"errors"
"regexp"
"strings"
"apskel-pos-be/internal/constants"
"apskel-pos-be/internal/contract"
)
type RewardValidator interface {
ValidateCreateRewardRequest(req *contract.CreateRewardRequest) (error, string)
ValidateUpdateRewardRequest(req *contract.UpdateRewardRequest) (error, string)
ValidateListRewardsRequest(req *contract.ListRewardsRequest) (error, string)
ValidateGetRewardRequest(req *contract.GetRewardRequest) (error, string)
ValidateDeleteRewardRequest(req *contract.DeleteRewardRequest) (error, string)
}
type RewardValidatorImpl struct{}
func NewRewardValidator() RewardValidator {
return &RewardValidatorImpl{}
}
func (v *RewardValidatorImpl) ValidateCreateRewardRequest(req *contract.CreateRewardRequest) (error, string) {
if req == nil {
return errors.New("request is required"), constants.ValidationErrorCode
}
// Validate name
if strings.TrimSpace(req.Name) == "" {
return errors.New("reward name is required"), constants.ValidationErrorCode
}
if len(req.Name) > 150 {
return errors.New("reward name cannot exceed 150 characters"), constants.ValidationErrorCode
}
// Validate reward type
if !v.isValidRewardType(req.RewardType) {
return errors.New("invalid reward type. Valid types are: VOUCHER, PHYSICAL, DIGITAL, BALANCE"), constants.ValidationErrorCode
}
// Validate cost points
if req.CostPoints <= 0 {
return errors.New("cost points must be greater than 0"), constants.ValidationErrorCode
}
// Validate stock
if req.Stock != nil && *req.Stock < 0 {
return errors.New("stock cannot be negative"), constants.ValidationErrorCode
}
// Validate max per customer
if req.MaxPerCustomer <= 0 {
return errors.New("max per customer must be greater than 0"), constants.ValidationErrorCode
}
// Validate TNC if provided
if req.Tnc != nil {
if err := v.validateTermsAndConditions(req.Tnc); err != nil {
return err, constants.ValidationErrorCode
}
}
// Validate images if provided
if req.Images != nil {
if err := v.validateImages(*req.Images); err != nil {
return err, constants.ValidationErrorCode
}
}
return nil, ""
}
func (v *RewardValidatorImpl) ValidateUpdateRewardRequest(req *contract.UpdateRewardRequest) (error, string) {
if req == nil {
return errors.New("request is required"), constants.ValidationErrorCode
}
// Validate ID
if req.ID.String() == "" {
return errors.New("reward ID is required"), constants.ValidationErrorCode
}
// Validate name
if strings.TrimSpace(req.Name) == "" {
return errors.New("reward name is required"), constants.ValidationErrorCode
}
if len(req.Name) > 150 {
return errors.New("reward name cannot exceed 150 characters"), constants.ValidationErrorCode
}
// Validate reward type
if !v.isValidRewardType(req.RewardType) {
return errors.New("invalid reward type. Valid types are: VOUCHER, PHYSICAL, DIGITAL, BALANCE"), constants.ValidationErrorCode
}
// Validate cost points
if req.CostPoints <= 0 {
return errors.New("cost points must be greater than 0"), constants.ValidationErrorCode
}
// Validate stock
if req.Stock != nil && *req.Stock < 0 {
return errors.New("stock cannot be negative"), constants.ValidationErrorCode
}
// Validate max per customer
if req.MaxPerCustomer <= 0 {
return errors.New("max per customer must be greater than 0"), constants.ValidationErrorCode
}
// Validate TNC if provided
if req.Tnc != nil {
if err := v.validateTermsAndConditions(req.Tnc); err != nil {
return err, constants.ValidationErrorCode
}
}
// Validate images if provided
if req.Images != nil {
if err := v.validateImages(*req.Images); err != nil {
return err, constants.ValidationErrorCode
}
}
return nil, ""
}
func (v *RewardValidatorImpl) ValidateListRewardsRequest(req *contract.ListRewardsRequest) (error, string) {
if req == nil {
return errors.New("request is required"), constants.ValidationErrorCode
}
// Validate pagination
if req.Page < 1 {
return errors.New("page must be greater than 0"), constants.ValidationErrorCode
}
if req.Limit < 1 {
return errors.New("limit must be greater than 0"), constants.ValidationErrorCode
}
if req.Limit > 100 {
return errors.New("limit cannot exceed 100"), constants.ValidationErrorCode
}
// Validate reward type filter if provided
if req.RewardType != "" && !v.isValidRewardType(req.RewardType) {
return errors.New("invalid reward type filter. Valid types are: VOUCHER, PHYSICAL, DIGITAL, BALANCE"), constants.ValidationErrorCode
}
// Validate points range if provided
if req.MinPoints != nil && req.MaxPoints != nil {
if *req.MinPoints > *req.MaxPoints {
return errors.New("min points cannot be greater than max points"), constants.ValidationErrorCode
}
if *req.MinPoints < 0 {
return errors.New("min points cannot be negative"), constants.ValidationErrorCode
}
if *req.MaxPoints < 0 {
return errors.New("max points cannot be negative"), constants.ValidationErrorCode
}
}
return nil, ""
}
func (v *RewardValidatorImpl) ValidateGetRewardRequest(req *contract.GetRewardRequest) (error, string) {
if req == nil {
return errors.New("request is required"), constants.ValidationErrorCode
}
if req.ID.String() == "" {
return errors.New("reward ID is required"), constants.ValidationErrorCode
}
return nil, ""
}
func (v *RewardValidatorImpl) ValidateDeleteRewardRequest(req *contract.DeleteRewardRequest) (error, string) {
if req == nil {
return errors.New("request is required"), constants.ValidationErrorCode
}
if req.ID.String() == "" {
return errors.New("reward ID is required"), constants.ValidationErrorCode
}
return nil, ""
}
func (v *RewardValidatorImpl) isValidRewardType(rewardType string) bool {
validTypes := []string{"VOUCHER", "PHYSICAL", "DIGITAL", "BALANCE"}
return contains(validTypes, rewardType)
}
func (v *RewardValidatorImpl) validateTermsAndConditions(tnc *contract.TermsAndConditionsStruct) error {
if tnc == nil {
return nil
}
// Validate expiry days
if tnc.ExpiryDays < 0 {
return errors.New("expiry days cannot be negative")
}
// Validate sections
if len(tnc.Sections) == 0 {
return errors.New("terms and conditions must have at least one section")
}
for i, section := range tnc.Sections {
if strings.TrimSpace(section.Title) == "" {
return errors.New("section title is required")
}
if len(section.Rules) == 0 {
return errors.New("section must have at least one rule")
}
for j, rule := range section.Rules {
if strings.TrimSpace(rule) == "" {
return errors.New("rule cannot be empty")
}
if len(rule) > 500 {
return errors.New("rule cannot exceed 500 characters")
}
// Validate rule content (basic validation)
if len(rule) < 10 {
return errors.New("rule must be at least 10 characters long")
}
_ = j // Avoid unused variable warning
}
_ = i // Avoid unused variable warning
}
return nil
}
func (v *RewardValidatorImpl) validateImages(images []string) error {
if len(images) == 0 {
return errors.New("at least one image is required")
}
for i, imgURL := range images {
if strings.TrimSpace(imgURL) == "" {
return errors.New("image URL is required")
}
// Validate URL format (basic validation)
if !v.isValidURL(imgURL) {
return errors.New("invalid image URL format")
}
_ = i // Avoid unused variable warning
}
return nil
}
func (v *RewardValidatorImpl) isValidURL(url string) bool {
// Basic URL validation regex
urlRegex := regexp.MustCompile(`^https?://[^\s/$.?#].[^\s]*$`)
return urlRegex.MatchString(url)
}