Add Tiers and Game Prize

internal/processor/game_prize_processor.go

@@ -0,0 +1,148 @@
+package processor
+
+import (
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/repository"
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+type GamePrizeProcessor struct {
+	gamePrizeRepo *repository.GamePrizeRepository
+}
+
+func NewGamePrizeProcessor(gamePrizeRepo *repository.GamePrizeRepository) *GamePrizeProcessor {
+	return &GamePrizeProcessor{
+		gamePrizeRepo: gamePrizeRepo,
+	}
+}
+
+// CreateGamePrize creates a new game prize
+func (p *GamePrizeProcessor) CreateGamePrize(ctx context.Context, req *models.CreateGamePrizeRequest) (*models.GamePrizeResponse, error) {
+	// Convert request to entity
+	gamePrize := mappers.ToGamePrizeEntity(req)
+
+	// Create game prize
+	err := p.gamePrizeRepo.Create(ctx, gamePrize)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create game prize: %w", err)
+	}
+
+	return mappers.ToGamePrizeResponse(gamePrize), nil
+}
+
+// GetGamePrize retrieves a game prize by ID
+func (p *GamePrizeProcessor) GetGamePrize(ctx context.Context, id uuid.UUID) (*models.GamePrizeResponse, error) {
+	gamePrize, err := p.gamePrizeRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("game prize not found: %w", err)
+	}
+
+	return mappers.ToGamePrizeResponse(gamePrize), nil
+}
+
+// GetGamePrizesByGameID retrieves all prizes for a specific game
+func (p *GamePrizeProcessor) GetGamePrizesByGameID(ctx context.Context, gameID uuid.UUID) ([]models.GamePrizeResponse, error) {
+	gamePrizes, err := p.gamePrizeRepo.GetByGameID(ctx, gameID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get game prizes: %w", err)
+	}
+
+	return mappers.ToGamePrizeResponses(gamePrizes), nil
+}
+
+// ListGamePrizes retrieves game prizes with pagination and filtering
+func (p *GamePrizeProcessor) ListGamePrizes(ctx context.Context, query *models.ListGamePrizesQuery) (*models.PaginatedResponse[models.GamePrizeResponse], error) {
+	// Set default values
+	if query.Page <= 0 {
+		query.Page = 1
+	}
+	if query.Limit <= 0 {
+		query.Limit = 10
+	}
+	if query.Limit > 100 {
+		query.Limit = 100
+	}
+
+	offset := (query.Page - 1) * query.Limit
+
+	// Get game prizes from repository
+	gamePrizes, total, err := p.gamePrizeRepo.List(
+		ctx,
+		offset,
+		query.Limit,
+		query.Search,
+		query.GameID,
+		query.SortBy,
+		query.SortOrder,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list game prizes: %w", err)
+	}
+
+	// Convert to responses
+	responses := mappers.ToGamePrizeResponses(gamePrizes)
+
+	// Calculate pagination info
+	totalPages := int((total + int64(query.Limit) - 1) / int64(query.Limit))
+
+	return &models.PaginatedResponse[models.GamePrizeResponse]{
+		Data: responses,
+		Pagination: models.Pagination{
+			Page:       query.Page,
+			Limit:      query.Limit,
+			Total:      total,
+			TotalPages: totalPages,
+		},
+	}, nil
+}
+
+// UpdateGamePrize updates an existing game prize
+func (p *GamePrizeProcessor) UpdateGamePrize(ctx context.Context, id uuid.UUID, req *models.UpdateGamePrizeRequest) (*models.GamePrizeResponse, error) {
+	// Get existing game prize
+	gamePrize, err := p.gamePrizeRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("game prize not found: %w", err)
+	}
+
+	// Update game prize fields
+	mappers.UpdateGamePrizeEntity(gamePrize, req)
+
+	// Save updated game prize
+	err = p.gamePrizeRepo.Update(ctx, gamePrize)
+	if err != nil {
+		return nil, fmt.Errorf("failed to update game prize: %w", err)
+	}
+
+	return mappers.ToGamePrizeResponse(gamePrize), nil
+}
+
+// DeleteGamePrize deletes a game prize
+func (p *GamePrizeProcessor) DeleteGamePrize(ctx context.Context, id uuid.UUID) error {
+	// Get existing game prize
+	_, err := p.gamePrizeRepo.GetByID(ctx, id)
+	if err != nil {
+		return fmt.Errorf("game prize not found: %w", err)
+	}
+
+	// Delete game prize
+	err = p.gamePrizeRepo.Delete(ctx, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete game prize: %w", err)
+	}
+
+	return nil
+}
+
+// GetAvailablePrizes gets all available prizes for a game (with stock > 0)
+func (p *GamePrizeProcessor) GetAvailablePrizes(ctx context.Context, gameID uuid.UUID) ([]models.GamePrizeResponse, error) {
+	gamePrizes, err := p.gamePrizeRepo.GetAvailablePrizes(ctx, gameID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get available prizes: %w", err)
+	}
+
+	return mappers.ToGamePrizeResponses(gamePrizes), nil
+}