apskel-pos-backend/internal/mappers/campaign_mapper.go

package mappers

import (
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/entities"
	"apskel-pos-be/internal/models"

	"github.com/google/uuid"
)

func ToCampaignResponse(entity *entities.Campaign) *models.CampaignResponse {
	if entity == nil {
		return nil
	}

	var rules []models.CampaignRuleResponse
	if entity.Rules != nil {
		for _, rule := range entity.Rules {
			rules = append(rules, *ToCampaignRuleResponse(&rule))
		}
	}

	return &models.CampaignResponse{
		ID:          entity.ID,
		Name:        entity.Name,
		Description: entity.Description,
		Type:        string(entity.Type),
		StartDate:   entity.StartDate,
		EndDate:     entity.EndDate,
		IsActive:    entity.IsActive,
		ShowOnApp:   entity.ShowOnApp,
		Position:    entity.Position,
		Metadata:    entity.Metadata,
		Rules:       rules,
		CreatedAt:   entity.CreatedAt,
		UpdatedAt:   entity.UpdatedAt,
	}
}

func ToCampaignRuleResponse(entity *entities.CampaignRule) *models.CampaignRuleResponse {
	if entity == nil {
		return nil
	}

	var rewardSubtype *string
	if entity.RewardSubtype != nil {
		subtype := string(*entity.RewardSubtype)
		rewardSubtype = &subtype
	}

	return &models.CampaignRuleResponse{
		ID:             entity.ID,
		CampaignID:     entity.CampaignID,
		RuleType:       string(entity.RuleType),
		ConditionValue: entity.ConditionValue,
		RewardType:     string(entity.RewardType),
		RewardValue:    entity.RewardValue,
		RewardSubtype:  rewardSubtype,
		RewardRefID:    entity.RewardRefID,
		Metadata:       entity.Metadata,
		CreatedAt:      entity.CreatedAt,
		UpdatedAt:      entity.UpdatedAt,
	}
}

func ToCampaignEntity(request *contract.CreateCampaignRequest) *entities.Campaign {
	if request == nil {
		return nil
	}

	var rules []entities.CampaignRule
	if request.Rules != nil {
		for _, rule := range request.Rules {
			// For create request, we'll use a temporary UUID that will be set by the repository
			rules = append(rules, *ToCampaignRuleEntity(&rule, uuid.Nil))
		}
	}

	return &entities.Campaign{
		Name:        request.Name,
		Description: request.Description,
		Type:        entities.CampaignType(request.Type),
		StartDate:   request.StartDate,
		EndDate:     request.EndDate,
		IsActive:    request.IsActive,
		ShowOnApp:   request.ShowOnApp,
		Position:    request.Position,
		Metadata:    request.Metadata,
		Rules:       rules,
	}
}

func ToCampaignEntityFromUpdate(request *contract.UpdateCampaignRequest) *entities.Campaign {
	if request == nil {
		return nil
	}

	var rules []entities.CampaignRule
	if request.Rules != nil {
		for _, rule := range request.Rules {
			rules = append(rules, *ToCampaignRuleEntityFromUpdate(&rule, request.ID))
		}
	}

	return &entities.Campaign{
		ID:          request.ID,
		Name:        request.Name,
		Description: request.Description,
		Type:        entities.CampaignType(request.Type),
		StartDate:   request.StartDate,
		EndDate:     request.EndDate,
		IsActive:    request.IsActive,
		ShowOnApp:   request.ShowOnApp,
		Position:    request.Position,
		Metadata:    request.Metadata,
		Rules:       rules,
	}
}

func ToCampaignRuleEntity(request *contract.CampaignRuleStruct, campaignID uuid.UUID) *entities.CampaignRule {
	if request == nil {
		return nil
	}

	var rewardSubtype *entities.RewardSubtype
	if request.RewardSubtype != nil {
		subtype := entities.RewardSubtype(*request.RewardSubtype)
		rewardSubtype = &subtype
	}

	return &entities.CampaignRule{
		CampaignID:     campaignID,
		RuleType:       entities.RuleType(request.RuleType),
		ConditionValue: request.ConditionValue,
		RewardType:     entities.CampaignRewardType(request.RewardType),
		RewardValue:    request.RewardValue,
		RewardSubtype:  rewardSubtype,
		RewardRefID:    request.RewardRefID,
		Metadata:       request.Metadata,
	}
}

func ToCampaignRuleEntityFromUpdate(request *contract.CampaignRuleStruct, campaignID uuid.UUID) *entities.CampaignRule {
	if request == nil {
		return nil
	}

	var rewardSubtype *entities.RewardSubtype
	if request.RewardSubtype != nil {
		subtype := entities.RewardSubtype(*request.RewardSubtype)
		rewardSubtype = &subtype
	}

	return &entities.CampaignRule{
		CampaignID:     campaignID,
		RuleType:       entities.RuleType(request.RuleType),
		ConditionValue: request.ConditionValue,
		RewardType:     entities.CampaignRewardType(request.RewardType),
		RewardValue:    request.RewardValue,
		RewardSubtype:  rewardSubtype,
		RewardRefID:    request.RewardRefID,
		Metadata:       request.Metadata,
	}
}

func ToCampaignResponseSlice(entities []entities.Campaign) []models.CampaignResponse {
	if entities == nil {
		return nil
	}

	responses := make([]models.CampaignResponse, len(entities))
	for i, entity := range entities {
		responses[i] = *ToCampaignResponse(&entity)
	}

	return responses
}

func ToCampaignRuleResponseSlice(entities []entities.CampaignRule) []models.CampaignRuleResponse {
	if entities == nil {
		return nil
	}

	responses := make([]models.CampaignRuleResponse, len(entities))
	for i, entity := range entities {
		responses[i] = *ToCampaignRuleResponse(&entity)
	}

	return responses
}