Add Campaign

2025-09-17 23:55:11 +07:00
parent 201e24041b
commit 155016dec8
26 changed files with 3399 additions and 1 deletions
@@ -0,0 +1,292 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/repository"
+)
+
+type CampaignProcessor interface {
+	CreateCampaign(ctx context.Context, req *contract.CreateCampaignRequest) (*models.CampaignResponse, error)
+	GetCampaign(ctx context.Context, id string) (*models.CampaignResponse, error)
+	ListCampaigns(ctx context.Context, req *contract.ListCampaignsRequest) (*models.ListCampaignsResponse, error)
+	UpdateCampaign(ctx context.Context, req *contract.UpdateCampaignRequest) (*models.CampaignResponse, error)
+	DeleteCampaign(ctx context.Context, id string) error
+	GetActiveCampaigns(ctx context.Context) ([]models.CampaignResponse, error)
+	GetCampaignsForApp(ctx context.Context) ([]models.CampaignResponse, error)
+}
+
+type campaignProcessor struct {
+	campaignRepo repository.CampaignRepository
+}
+
+func NewCampaignProcessor(campaignRepo repository.CampaignRepository) CampaignProcessor {
+	return &campaignProcessor{
+		campaignRepo: campaignRepo,
+	}
+}
+
+func (p *campaignProcessor) CreateCampaign(ctx context.Context, req *contract.CreateCampaignRequest) (*models.CampaignResponse, error) {
+	// Convert request to entity
+	entity := mappers.ToCampaignEntity(req)
+	if entity == nil {
+		return nil, fmt.Errorf("invalid request data")
+	}
+
+	// Create in repository
+	if err := p.campaignRepo.Create(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to create campaign: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignResponse(entity)
+	return response, nil
+}
+
+func (p *campaignProcessor) GetCampaign(ctx context.Context, id string) (*models.CampaignResponse, error) {
+	// Get from repository
+	entity, err := p.campaignRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get campaign: %w", err)
+	}
+
+	if entity == nil {
+		return nil, fmt.Errorf("campaign not found")
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignResponse(entity)
+	return response, nil
+}
+
+func (p *campaignProcessor) ListCampaigns(ctx context.Context, req *contract.ListCampaignsRequest) (*models.ListCampaignsResponse, error) {
+	// Convert request to entity request
+	entityReq := &entities.ListCampaignsRequest{
+		Page:      req.Page,
+		Limit:     req.Limit,
+		Search:    req.Search,
+		Type:      req.Type,
+		IsActive:  req.IsActive,
+		ShowOnApp: req.ShowOnApp,
+		StartDate: req.StartDate,
+		EndDate:   req.EndDate,
+	}
+
+	// Get from repository
+	entities, total, err := p.campaignRepo.List(ctx, entityReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list campaigns: %w", err)
+	}
+
+	// Convert entities to response
+	campaigns := mappers.ToCampaignResponseSlice(entities)
+
+	response := &models.ListCampaignsResponse{
+		Campaigns: campaigns,
+		Total:     total,
+		Page:      req.Page,
+		Limit:     req.Limit,
+	}
+
+	return response, nil
+}
+
+func (p *campaignProcessor) UpdateCampaign(ctx context.Context, req *contract.UpdateCampaignRequest) (*models.CampaignResponse, error) {
+	// Convert request to entity
+	entity := mappers.ToCampaignEntityFromUpdate(req)
+	if entity == nil {
+		return nil, fmt.Errorf("invalid request data")
+	}
+
+	// Update in repository
+	if err := p.campaignRepo.Update(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to update campaign: %w", err)
+	}
+
+	// Get updated entity
+	updatedEntity, err := p.campaignRepo.GetByID(ctx, req.ID.String())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get updated campaign: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignResponse(updatedEntity)
+	return response, nil
+}
+
+func (p *campaignProcessor) DeleteCampaign(ctx context.Context, id string) error {
+	// Delete from repository
+	if err := p.campaignRepo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("failed to delete campaign: %w", err)
+	}
+
+	return nil
+}
+
+func (p *campaignProcessor) GetActiveCampaigns(ctx context.Context) ([]models.CampaignResponse, error) {
+	// Get from repository
+	entities, err := p.campaignRepo.GetActiveCampaigns(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get active campaigns: %w", err)
+	}
+
+	// Convert entities to response
+	campaigns := mappers.ToCampaignResponseSlice(entities)
+	return campaigns, nil
+}
+
+func (p *campaignProcessor) GetCampaignsForApp(ctx context.Context) ([]models.CampaignResponse, error) {
+	// Get from repository
+	entities, err := p.campaignRepo.GetCampaignsForApp(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get campaigns for app: %w", err)
+	}
+
+	// Convert entities to response
+	campaigns := mappers.ToCampaignResponseSlice(entities)
+	return campaigns, nil
+}
+
+// Campaign Rule Processor
+type CampaignRuleProcessor interface {
+	CreateCampaignRule(ctx context.Context, req *contract.CreateCampaignRuleRequest) (*models.CampaignRuleResponse, error)
+	GetCampaignRule(ctx context.Context, id string) (*models.CampaignRuleResponse, error)
+	ListCampaignRules(ctx context.Context, req *contract.ListCampaignRulesRequest) (*models.ListCampaignRulesResponse, error)
+	UpdateCampaignRule(ctx context.Context, req *contract.UpdateCampaignRuleRequest) (*models.CampaignRuleResponse, error)
+	DeleteCampaignRule(ctx context.Context, id string) error
+	GetCampaignRulesByCampaignID(ctx context.Context, campaignID string) ([]models.CampaignRuleResponse, error)
+}
+
+type campaignRuleProcessor struct {
+	campaignRuleRepo repository.CampaignRuleRepository
+}
+
+func NewCampaignRuleProcessor(campaignRuleRepo repository.CampaignRuleRepository) CampaignRuleProcessor {
+	return &campaignRuleProcessor{
+		campaignRuleRepo: campaignRuleRepo,
+	}
+}
+
+func (p *campaignRuleProcessor) CreateCampaignRule(ctx context.Context, req *contract.CreateCampaignRuleRequest) (*models.CampaignRuleResponse, error) {
+	// Convert request to entity
+	entity := &entities.CampaignRule{
+		CampaignID:     req.CampaignID,
+		RuleType:       entities.RuleType(req.RuleType),
+		ConditionValue: req.ConditionValue,
+		RewardType:     entities.CampaignRewardType(req.RewardType),
+		RewardValue:    req.RewardValue,
+		RewardSubtype:  (*entities.RewardSubtype)(req.RewardSubtype),
+		RewardRefID:    req.RewardRefID,
+		Metadata:       req.Metadata,
+	}
+
+	// Create in repository
+	if err := p.campaignRuleRepo.Create(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to create campaign rule: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignRuleResponse(entity)
+	return response, nil
+}
+
+func (p *campaignRuleProcessor) GetCampaignRule(ctx context.Context, id string) (*models.CampaignRuleResponse, error) {
+	// Get from repository
+	entity, err := p.campaignRuleRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get campaign rule: %w", err)
+	}
+
+	if entity == nil {
+		return nil, fmt.Errorf("campaign rule not found")
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignRuleResponse(entity)
+	return response, nil
+}
+
+func (p *campaignRuleProcessor) ListCampaignRules(ctx context.Context, req *contract.ListCampaignRulesRequest) (*models.ListCampaignRulesResponse, error) {
+	// Convert request to entity request
+	entityReq := &entities.ListCampaignRulesRequest{
+		Page:       req.Page,
+		Limit:      req.Limit,
+		CampaignID: req.CampaignID,
+		RuleType:   req.RuleType,
+		RewardType: req.RewardType,
+	}
+
+	// Get from repository
+	entities, total, err := p.campaignRuleRepo.List(ctx, entityReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list campaign rules: %w", err)
+	}
+
+	// Convert entities to response
+	rules := mappers.ToCampaignRuleResponseSlice(entities)
+
+	response := &models.ListCampaignRulesResponse{
+		Rules: rules,
+		Total: total,
+		Page:  req.Page,
+		Limit: req.Limit,
+	}
+
+	return response, nil
+}
+
+func (p *campaignRuleProcessor) UpdateCampaignRule(ctx context.Context, req *contract.UpdateCampaignRuleRequest) (*models.CampaignRuleResponse, error) {
+	// Convert request to entity
+	entity := &entities.CampaignRule{
+		ID:             req.ID,
+		CampaignID:     req.CampaignID,
+		RuleType:       entities.RuleType(req.RuleType),
+		ConditionValue: req.ConditionValue,
+		RewardType:     entities.CampaignRewardType(req.RewardType),
+		RewardValue:    req.RewardValue,
+		RewardSubtype:  (*entities.RewardSubtype)(req.RewardSubtype),
+		RewardRefID:    req.RewardRefID,
+		Metadata:       req.Metadata,
+	}
+
+	// Update in repository
+	if err := p.campaignRuleRepo.Update(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to update campaign rule: %w", err)
+	}
+
+	// Get updated entity
+	updatedEntity, err := p.campaignRuleRepo.GetByID(ctx, req.ID.String())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get updated campaign rule: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToCampaignRuleResponse(updatedEntity)
+	return response, nil
+}
+
+func (p *campaignRuleProcessor) DeleteCampaignRule(ctx context.Context, id string) error {
+	// Delete from repository
+	if err := p.campaignRuleRepo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("failed to delete campaign rule: %w", err)
+	}
+
+	return nil
+}
+
+func (p *campaignRuleProcessor) GetCampaignRulesByCampaignID(ctx context.Context, campaignID string) ([]models.CampaignRuleResponse, error) {
+	// Get from repository
+	entities, err := p.campaignRuleRepo.GetByCampaignID(ctx, campaignID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get campaign rules by campaign ID: %w", err)
+	}
+
+	// Convert entities to response
+	rules := mappers.ToCampaignRuleResponseSlice(entities)
+	return rules, nil
+}
@@ -0,0 +1,149 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/repository"
+)
+
+type RewardProcessor interface {
+	CreateReward(ctx context.Context, req *contract.CreateRewardRequest) (*models.RewardResponse, error)
+	GetReward(ctx context.Context, id string) (*models.RewardResponse, error)
+	ListRewards(ctx context.Context, req *contract.ListRewardsRequest) (*models.ListRewardsResponse, error)
+	UpdateReward(ctx context.Context, req *contract.UpdateRewardRequest) (*models.RewardResponse, error)
+	DeleteReward(ctx context.Context, id string) error
+	UpdateRewardStock(ctx context.Context, id string, newStock int) error
+	GetRewardsByType(ctx context.Context, rewardType string) ([]models.RewardResponse, error)
+}
+
+type rewardProcessor struct {
+	rewardRepo repository.RewardRepository
+}
+
+func NewRewardProcessor(rewardRepo repository.RewardRepository) RewardProcessor {
+	return &rewardProcessor{
+		rewardRepo: rewardRepo,
+	}
+}
+
+func (p *rewardProcessor) CreateReward(ctx context.Context, req *contract.CreateRewardRequest) (*models.RewardResponse, error) {
+	// Convert request to entity
+	entity := mappers.ToRewardEntity(req)
+	if entity == nil {
+		return nil, fmt.Errorf("invalid request data")
+	}
+
+	// Create in repository
+	if err := p.rewardRepo.Create(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to create reward: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToRewardResponse(entity)
+	return response, nil
+}
+
+func (p *rewardProcessor) GetReward(ctx context.Context, id string) (*models.RewardResponse, error) {
+	// Get from repository
+	entity, err := p.rewardRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get reward: %w", err)
+	}
+
+	if entity == nil {
+		return nil, fmt.Errorf("reward not found")
+	}
+
+	// Convert entity to response
+	response := mappers.ToRewardResponse(entity)
+	return response, nil
+}
+
+func (p *rewardProcessor) ListRewards(ctx context.Context, req *contract.ListRewardsRequest) (*models.ListRewardsResponse, error) {
+	// Convert request to entity request
+	entityReq := &entities.ListRewardsRequest{
+		Page:       req.Page,
+		Limit:      req.Limit,
+		Search:     req.Search,
+		RewardType: req.RewardType,
+		MinPoints:  req.MinPoints,
+		MaxPoints:  req.MaxPoints,
+		HasStock:   req.HasStock,
+	}
+
+	// Get from repository
+	entities, total, err := p.rewardRepo.List(ctx, entityReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list rewards: %w", err)
+	}
+
+	// Convert entities to response
+	rewards := mappers.ToRewardResponseSlice(entities)
+
+	response := &models.ListRewardsResponse{
+		Rewards: rewards,
+		Total:   total,
+		Page:    req.Page,
+		Limit:   req.Limit,
+	}
+
+	return response, nil
+}
+
+func (p *rewardProcessor) UpdateReward(ctx context.Context, req *contract.UpdateRewardRequest) (*models.RewardResponse, error) {
+	// Convert request to entity
+	entity := mappers.ToRewardEntityFromUpdate(req)
+	if entity == nil {
+		return nil, fmt.Errorf("invalid request data")
+	}
+
+	// Update in repository
+	if err := p.rewardRepo.Update(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to update reward: %w", err)
+	}
+
+	// Get updated entity
+	updatedEntity, err := p.rewardRepo.GetByID(ctx, req.ID.String())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get updated reward: %w", err)
+	}
+
+	// Convert entity to response
+	response := mappers.ToRewardResponse(updatedEntity)
+	return response, nil
+}
+
+func (p *rewardProcessor) DeleteReward(ctx context.Context, id string) error {
+	// Delete from repository
+	if err := p.rewardRepo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("failed to delete reward: %w", err)
+	}
+
+	return nil
+}
+
+func (p *rewardProcessor) UpdateRewardStock(ctx context.Context, id string, newStock int) error {
+	// Update stock in repository
+	if err := p.rewardRepo.UpdateStock(ctx, id, newStock); err != nil {
+		return fmt.Errorf("failed to update reward stock: %w", err)
+	}
+
+	return nil
+}
+
+func (p *rewardProcessor) GetRewardsByType(ctx context.Context, rewardType string) ([]models.RewardResponse, error) {
+	// Get from repository
+	entities, err := p.rewardRepo.GetByRewardType(ctx, entities.RewardType(rewardType))
+	if err != nil {
+		return nil, fmt.Errorf("failed to get rewards by type: %w", err)
+	}
+
+	// Convert entities to response
+	rewards := mappers.ToRewardResponseSlice(entities)
+	return rewards, nil
+}