138 lines
3.3 KiB
Go
138 lines
3.3 KiB
Go
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 TierProcessor struct {
|
|
tierRepo *repository.TierRepository
|
|
}
|
|
|
|
func NewTierProcessor(tierRepo *repository.TierRepository) *TierProcessor {
|
|
return &TierProcessor{
|
|
tierRepo: tierRepo,
|
|
}
|
|
}
|
|
|
|
// CreateTier creates a new tier
|
|
func (p *TierProcessor) CreateTier(ctx context.Context, req *models.CreateTierRequest) (*models.TierResponse, error) {
|
|
// Convert request to entity
|
|
tier := mappers.ToTierEntity(req)
|
|
|
|
// Create tier
|
|
err := p.tierRepo.Create(ctx, tier)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create tier: %w", err)
|
|
}
|
|
|
|
return mappers.ToTierResponse(tier), nil
|
|
}
|
|
|
|
// GetTier retrieves a tier by ID
|
|
func (p *TierProcessor) GetTier(ctx context.Context, id uuid.UUID) (*models.TierResponse, error) {
|
|
tier, err := p.tierRepo.GetByID(ctx, id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("tier not found: %w", err)
|
|
}
|
|
|
|
return mappers.ToTierResponse(tier), nil
|
|
}
|
|
|
|
// ListTiers retrieves tiers with pagination and filtering
|
|
func (p *TierProcessor) ListTiers(ctx context.Context, query *models.ListTiersQuery) (*models.PaginatedResponse[models.TierResponse], 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 tiers from repository
|
|
tiers, total, err := p.tierRepo.List(
|
|
ctx,
|
|
offset,
|
|
query.Limit,
|
|
query.Search,
|
|
query.SortBy,
|
|
query.SortOrder,
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to list tiers: %w", err)
|
|
}
|
|
|
|
// Convert to responses
|
|
responses := mappers.ToTierResponses(tiers)
|
|
|
|
// Calculate pagination info
|
|
totalPages := int((total + int64(query.Limit) - 1) / int64(query.Limit))
|
|
|
|
return &models.PaginatedResponse[models.TierResponse]{
|
|
Data: responses,
|
|
Pagination: models.Pagination{
|
|
Page: query.Page,
|
|
Limit: query.Limit,
|
|
Total: total,
|
|
TotalPages: totalPages,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UpdateTier updates an existing tier
|
|
func (p *TierProcessor) UpdateTier(ctx context.Context, id uuid.UUID, req *models.UpdateTierRequest) (*models.TierResponse, error) {
|
|
// Get existing tier
|
|
tier, err := p.tierRepo.GetByID(ctx, id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("tier not found: %w", err)
|
|
}
|
|
|
|
// Update tier fields
|
|
mappers.UpdateTierEntity(tier, req)
|
|
|
|
// Save updated tier
|
|
err = p.tierRepo.Update(ctx, tier)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to update tier: %w", err)
|
|
}
|
|
|
|
return mappers.ToTierResponse(tier), nil
|
|
}
|
|
|
|
// DeleteTier deletes a tier
|
|
func (p *TierProcessor) DeleteTier(ctx context.Context, id uuid.UUID) error {
|
|
// Get existing tier
|
|
_, err := p.tierRepo.GetByID(ctx, id)
|
|
if err != nil {
|
|
return fmt.Errorf("tier not found: %w", err)
|
|
}
|
|
|
|
// Delete tier
|
|
err = p.tierRepo.Delete(ctx, id)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete tier: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetTierByPoints gets the appropriate tier for a given point amount
|
|
func (p *TierProcessor) GetTierByPoints(ctx context.Context, points int64) (*models.TierResponse, error) {
|
|
tier, err := p.tierRepo.GetTierByPoints(ctx, points)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("tier not found for points: %w", err)
|
|
}
|
|
|
|
return mappers.ToTierResponse(tier), nil
|
|
}
|