Add Tiers and Game Prize

internal/mappers/customer_points_mapper.go

@@ -0,0 +1,46 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToCustomerPointsResponse converts a customer points entity to a customer points response
+func ToCustomerPointsResponse(customerPoints *entities.CustomerPoints) *models.CustomerPointsResponse {
+	if customerPoints == nil {
+		return nil
+	}
+
+	return &models.CustomerPointsResponse{
+		ID:         customerPoints.ID,
+		CustomerID: customerPoints.CustomerID,
+		Balance:    customerPoints.Balance,
+		Customer:   ToCustomerResponse(&customerPoints.Customer),
+		CreatedAt:  customerPoints.CreatedAt,
+		UpdatedAt:  customerPoints.UpdatedAt,
+	}
+}
+
+// ToCustomerPointsResponses converts a slice of customer points entities to customer points responses
+func ToCustomerPointsResponses(customerPoints []entities.CustomerPoints) []models.CustomerPointsResponse {
+	responses := make([]models.CustomerPointsResponse, len(customerPoints))
+	for i, cp := range customerPoints {
+		responses[i] = *ToCustomerPointsResponse(&cp)
+	}
+	return responses
+}
+
+// ToCustomerPointsEntity converts a create customer points request to a customer points entity
+func ToCustomerPointsEntity(req *models.CreateCustomerPointsRequest) *entities.CustomerPoints {
+	return &entities.CustomerPoints{
+		CustomerID: req.CustomerID,
+		Balance:    req.Balance,
+	}
+}
+
+// UpdateCustomerPointsEntity updates a customer points entity with update request data
+func UpdateCustomerPointsEntity(customerPoints *entities.CustomerPoints, req *models.UpdateCustomerPointsRequest) {
+	if req.Balance >= 0 {
+		customerPoints.Balance = req.Balance
+	}
+}

internal/mappers/customer_tokens_mapper.go

@@ -0,0 +1,48 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToCustomerTokensResponse converts a customer tokens entity to a customer tokens response
+func ToCustomerTokensResponse(customerTokens *entities.CustomerTokens) *models.CustomerTokensResponse {
+	if customerTokens == nil {
+		return nil
+	}
+
+	return &models.CustomerTokensResponse{
+		ID:         customerTokens.ID,
+		CustomerID: customerTokens.CustomerID,
+		TokenType:  string(customerTokens.TokenType),
+		Balance:    customerTokens.Balance,
+		Customer:   ToCustomerResponse(&customerTokens.Customer),
+		CreatedAt:  customerTokens.CreatedAt,
+		UpdatedAt:  customerTokens.UpdatedAt,
+	}
+}
+
+// ToCustomerTokensResponses converts a slice of customer tokens entities to customer tokens responses
+func ToCustomerTokensResponses(customerTokens []entities.CustomerTokens) []models.CustomerTokensResponse {
+	responses := make([]models.CustomerTokensResponse, len(customerTokens))
+	for i, ct := range customerTokens {
+		responses[i] = *ToCustomerTokensResponse(&ct)
+	}
+	return responses
+}
+
+// ToCustomerTokensEntity converts a create customer tokens request to a customer tokens entity
+func ToCustomerTokensEntity(req *models.CreateCustomerTokensRequest) *entities.CustomerTokens {
+	return &entities.CustomerTokens{
+		CustomerID: req.CustomerID,
+		TokenType:  entities.TokenType(req.TokenType),
+		Balance:    req.Balance,
+	}
+}
+
+// UpdateCustomerTokensEntity updates a customer tokens entity with update request data
+func UpdateCustomerTokensEntity(customerTokens *entities.CustomerTokens, req *models.UpdateCustomerTokensRequest) {
+	if req.Balance >= 0 {
+		customerTokens.Balance = req.Balance
+	}
+}

internal/mappers/game_mapper.go

@@ -0,0 +1,58 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToGameResponse converts a game entity to a game response
+func ToGameResponse(game *entities.Game) *models.GameResponse {
+	if game == nil {
+		return nil
+	}
+
+	return &models.GameResponse{
+		ID:        game.ID,
+		Name:      game.Name,
+		Type:      string(game.Type),
+		IsActive:  game.IsActive,
+		Metadata:  game.Metadata,
+		CreatedAt: game.CreatedAt,
+		UpdatedAt: game.UpdatedAt,
+	}
+}
+
+// ToGameResponses converts a slice of game entities to game responses
+func ToGameResponses(games []entities.Game) []models.GameResponse {
+	responses := make([]models.GameResponse, len(games))
+	for i, game := range games {
+		responses[i] = *ToGameResponse(&game)
+	}
+	return responses
+}
+
+// ToGameEntity converts a create game request to a game entity
+func ToGameEntity(req *models.CreateGameRequest) *entities.Game {
+	return &entities.Game{
+		Name:     req.Name,
+		Type:     entities.GameType(req.Type),
+		IsActive: req.IsActive,
+		Metadata: req.Metadata,
+	}
+}
+
+// UpdateGameEntity updates a game entity with update request data
+func UpdateGameEntity(game *entities.Game, req *models.UpdateGameRequest) {
+	if req.Name != nil {
+		game.Name = *req.Name
+	}
+	if req.Type != nil {
+		game.Type = entities.GameType(*req.Type)
+	}
+	if req.IsActive != nil {
+		game.IsActive = *req.IsActive
+	}
+	if req.Metadata != nil {
+		game.Metadata = req.Metadata
+	}
+}

internal/mappers/game_play_mapper.go

@@ -0,0 +1,45 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToGamePlayResponse converts a game play entity to a game play response
+func ToGamePlayResponse(gamePlay *entities.GamePlay) *models.GamePlayResponse {
+	if gamePlay == nil {
+		return nil
+	}
+
+	return &models.GamePlayResponse{
+		ID:         gamePlay.ID,
+		GameID:     gamePlay.GameID,
+		CustomerID: gamePlay.CustomerID,
+		PrizeID:    gamePlay.PrizeID,
+		TokenUsed:  gamePlay.TokenUsed,
+		RandomSeed: gamePlay.RandomSeed,
+		CreatedAt:  gamePlay.CreatedAt,
+		Game:       ToGameResponse(&gamePlay.Game),
+		Customer:   ToCustomerResponse(&gamePlay.Customer),
+		Prize:      ToGamePrizeResponse(gamePlay.Prize),
+	}
+}
+
+// ToGamePlayResponses converts a slice of game play entities to game play responses
+func ToGamePlayResponses(gamePlays []entities.GamePlay) []models.GamePlayResponse {
+	responses := make([]models.GamePlayResponse, len(gamePlays))
+	for i, gp := range gamePlays {
+		responses[i] = *ToGamePlayResponse(&gp)
+	}
+	return responses
+}
+
+// ToGamePlayEntity converts a create game play request to a game play entity
+func ToGamePlayEntity(req *models.CreateGamePlayRequest) *entities.GamePlay {
+	return &entities.GamePlay{
+		GameID:     req.GameID,
+		CustomerID: req.CustomerID,
+		TokenUsed:  req.TokenUsed,
+		RandomSeed: req.RandomSeed,
+	}
+}

internal/mappers/game_prize_mapper.go

@@ -0,0 +1,77 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToGamePrizeResponse converts a game prize entity to a game prize response
+func ToGamePrizeResponse(gamePrize *entities.GamePrize) *models.GamePrizeResponse {
+	if gamePrize == nil {
+		return nil
+	}
+
+	return &models.GamePrizeResponse{
+		ID:              gamePrize.ID,
+		GameID:          gamePrize.GameID,
+		Name:            gamePrize.Name,
+		Weight:          gamePrize.Weight,
+		Stock:           gamePrize.Stock,
+		MaxStock:        gamePrize.MaxStock,
+		Threshold:       gamePrize.Threshold,
+		FallbackPrizeID: gamePrize.FallbackPrizeID,
+		Metadata:        gamePrize.Metadata,
+		Game:            ToGameResponse(&gamePrize.Game),
+		FallbackPrize:   ToGamePrizeResponse(gamePrize.FallbackPrize),
+		CreatedAt:       gamePrize.CreatedAt,
+		UpdatedAt:       gamePrize.UpdatedAt,
+	}
+}
+
+// ToGamePrizeResponses converts a slice of game prize entities to game prize responses
+func ToGamePrizeResponses(gamePrizes []entities.GamePrize) []models.GamePrizeResponse {
+	responses := make([]models.GamePrizeResponse, len(gamePrizes))
+	for i, gp := range gamePrizes {
+		responses[i] = *ToGamePrizeResponse(&gp)
+	}
+	return responses
+}
+
+// ToGamePrizeEntity converts a create game prize request to a game prize entity
+func ToGamePrizeEntity(req *models.CreateGamePrizeRequest) *entities.GamePrize {
+	return &entities.GamePrize{
+		GameID:          req.GameID,
+		Name:            req.Name,
+		Weight:          req.Weight,
+		Stock:           req.Stock,
+		MaxStock:        req.MaxStock,
+		Threshold:       req.Threshold,
+		FallbackPrizeID: req.FallbackPrizeID,
+		Metadata:        req.Metadata,
+	}
+}
+
+// UpdateGamePrizeEntity updates a game prize entity with update request data
+func UpdateGamePrizeEntity(gamePrize *entities.GamePrize, req *models.UpdateGamePrizeRequest) {
+	if req.Name != nil {
+		gamePrize.Name = *req.Name
+	}
+	if req.Weight != nil {
+		gamePrize.Weight = *req.Weight
+	}
+	if req.Stock != nil {
+		gamePrize.Stock = *req.Stock
+	}
+	if req.MaxStock != nil {
+		gamePrize.MaxStock = req.MaxStock
+	}
+	if req.Threshold != nil {
+		gamePrize.Threshold = req.Threshold
+	}
+	if req.FallbackPrizeID != nil {
+		gamePrize.FallbackPrizeID = req.FallbackPrizeID
+	}
+	if req.Metadata != nil {
+		gamePrize.Metadata = req.Metadata
+	}
+}

internal/mappers/omset_tracker_mapper.go

@@ -0,0 +1,64 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToOmsetTrackerResponse converts an omset tracker entity to an omset tracker response
+func ToOmsetTrackerResponse(omsetTracker *entities.OmsetTracker) *models.OmsetTrackerResponse {
+	if omsetTracker == nil {
+		return nil
+	}
+
+	return &models.OmsetTrackerResponse{
+		ID:          omsetTracker.ID,
+		PeriodType:  string(omsetTracker.PeriodType),
+		PeriodStart: omsetTracker.PeriodStart,
+		PeriodEnd:   omsetTracker.PeriodEnd,
+		Total:       omsetTracker.Total,
+		GameID:      omsetTracker.GameID,
+		Game:        ToGameResponse(omsetTracker.Game),
+		CreatedAt:   omsetTracker.CreatedAt,
+		UpdatedAt:   omsetTracker.UpdatedAt,
+	}
+}
+
+// ToOmsetTrackerResponses converts a slice of omset tracker entities to omset tracker responses
+func ToOmsetTrackerResponses(omsetTrackers []entities.OmsetTracker) []models.OmsetTrackerResponse {
+	responses := make([]models.OmsetTrackerResponse, len(omsetTrackers))
+	for i, ot := range omsetTrackers {
+		responses[i] = *ToOmsetTrackerResponse(&ot)
+	}
+	return responses
+}
+
+// ToOmsetTrackerEntity converts a create omset tracker request to an omset tracker entity
+func ToOmsetTrackerEntity(req *models.CreateOmsetTrackerRequest) *entities.OmsetTracker {
+	return &entities.OmsetTracker{
+		PeriodType:  entities.PeriodType(req.PeriodType),
+		PeriodStart: req.PeriodStart,
+		PeriodEnd:   req.PeriodEnd,
+		Total:       req.Total,
+		GameID:      req.GameID,
+	}
+}
+
+// UpdateOmsetTrackerEntity updates an omset tracker entity with update request data
+func UpdateOmsetTrackerEntity(omsetTracker *entities.OmsetTracker, req *models.UpdateOmsetTrackerRequest) {
+	if req.PeriodType != nil {
+		omsetTracker.PeriodType = entities.PeriodType(*req.PeriodType)
+	}
+	if req.PeriodStart != nil {
+		omsetTracker.PeriodStart = *req.PeriodStart
+	}
+	if req.PeriodEnd != nil {
+		omsetTracker.PeriodEnd = *req.PeriodEnd
+	}
+	if req.Total != nil {
+		omsetTracker.Total = *req.Total
+	}
+	if req.GameID != nil {
+		omsetTracker.GameID = req.GameID
+	}
+}

internal/mappers/tier_mapper.go

@@ -0,0 +1,53 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+// ToTierResponse converts a tier entity to a tier response
+func ToTierResponse(tier *entities.Tier) *models.TierResponse {
+	if tier == nil {
+		return nil
+	}
+
+	return &models.TierResponse{
+		ID:        tier.ID,
+		Name:      tier.Name,
+		MinPoints: tier.MinPoints,
+		Benefits:  tier.Benefits,
+		CreatedAt: tier.CreatedAt,
+		UpdatedAt: tier.UpdatedAt,
+	}
+}
+
+// ToTierResponses converts a slice of tier entities to tier responses
+func ToTierResponses(tiers []entities.Tier) []models.TierResponse {
+	responses := make([]models.TierResponse, len(tiers))
+	for i, tier := range tiers {
+		responses[i] = *ToTierResponse(&tier)
+	}
+	return responses
+}
+
+// ToTierEntity converts a create tier request to a tier entity
+func ToTierEntity(req *models.CreateTierRequest) *entities.Tier {
+	return &entities.Tier{
+		Name:      req.Name,
+		MinPoints: req.MinPoints,
+		Benefits:  req.Benefits,
+	}
+}
+
+// UpdateTierEntity updates a tier entity with update request data
+func UpdateTierEntity(tier *entities.Tier, req *models.UpdateTierRequest) {
+	if req.Name != nil {
+		tier.Name = *req.Name
+	}
+	if req.MinPoints != nil {
+		tier.MinPoints = *req.MinPoints
+	}
+	if req.Benefits != nil {
+		tier.Benefits = req.Benefits
+	}
+}