cid/service/strategy_service.go

package service

import (
	"cidService/dao"
	"cidService/model/dto"
	"cidService/model/entity"
	"context"
	"encoding/json"
	"strconv"

	"gitee.com/red-future---jilin-g/common/utils"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

var (
	Strategy = strategyService{}
)

type strategyService struct{}

// CreateStrategy 创建策略
func (s *strategyService) CreateStrategy(ctx context.Context, req *dto.CreateStrategyReq) (id int64, err error) {
	// 检查策略名称是否已存在
	existingStrategy, err := dao.Strategy.GetByName(ctx, req.Name)
	if err != nil {
		return 0, err
	}
	if existingStrategy != nil {
		return 0, gerror.New("策略名称已存在")
	}

	// 验证转化率范围
	if req.MaxConversion <= req.MinConversion {
		return 0, gerror.New("最高转化率必须大于最低转化率")
	}

	// 序列化权重配置
	weightsJson, err := json.Marshal(req.SourceWeights)
	if err != nil {
		return 0, gerror.Wrap(err, "权重配置序列化失败")
	}

	// 获取当前用户信息
	userInfo, err := utils.GetUserInfo(ctx)
	if err != nil {
		return 0, gerror.Wrap(err, "获取用户信息失败")
	}

	// 将UserName转换为int64，如果失败则使用0
	var userId int64
	if uid, ok := userInfo.UserName.(string); ok {
		if parsedId, err := strconv.ParseInt(uid, 10, 64); err == nil {
			userId = parsedId
		}
	}

	strategy := &entity.Strategy{
		Name:          req.Name,
		Description:   req.Description,
		TenantLevel:   req.TenantLevel,
		MinConversion: req.MinConversion,
		MaxConversion: req.MaxConversion,
		SourceWeights: string(weightsJson),
		MaxAdsPerReq:  req.MaxAdsPerReq,
		Priority:      req.Priority,
		Status:        req.Status,
		CreatedBy:     userId,
		UpdatedBy:     userId,
	}

	return dao.Strategy.Create(ctx, strategy)
}

// UpdateStrategy 更新策略
func (s *strategyService) UpdateStrategy(ctx context.Context, req *dto.UpdateStrategyReq) (affected int64, err error) {
	// 检查策略是否存在
	existingStrategy, err := dao.Strategy.GetByID(ctx, req.Id)
	if err != nil {
		return 0, err
	}
	if existingStrategy == nil {
		return 0, gerror.New("策略不存在")
	}

	// 如果更新名称，检查是否与其他策略冲突
	if req.Name != "" && req.Name != existingStrategy.Name {
		conflictStrategy, err := dao.Strategy.GetByName(ctx, req.Name)
		if err != nil {
			return 0, err
		}
		if conflictStrategy != nil {
			return 0, gerror.New("策略名称已存在")
		}
	}

	// 验证转化率范围
	if req.MaxConversion <= req.MinConversion {
		return 0, gerror.New("最高转化率必须大于最低转化率")
	}

	// 序列化权重配置
	weightsJson, err := json.Marshal(req.SourceWeights)
	if err != nil {
		return 0, gerror.Wrap(err, "权重配置序列化失败")
	}

	// 获取当前用户信息
	userInfo, err := utils.GetUserInfo(ctx)
	if err != nil {
		return 0, gerror.Wrap(err, "获取用户信息失败")
	}

	// 将UserName转换为int64，如果失败则使用0
	var userId int64
	if uid, ok := userInfo.UserName.(string); ok {
		if parsedId, err := strconv.ParseInt(uid, 10, 64); err == nil {
			userId = parsedId
		}
	}

	strategy := &entity.Strategy{
		Id:            req.Id,
		Name:          req.Name,
		Description:   req.Description,
		TenantLevel:   req.TenantLevel,
		MinConversion: req.MinConversion,
		MaxConversion: req.MaxConversion,
		SourceWeights: string(weightsJson),
		MaxAdsPerReq:  req.MaxAdsPerReq,
		Priority:      req.Priority,
		Status:        req.Status,
		UpdatedBy:     userId,
	}

	return dao.Strategy.Update(ctx, strategy)
}

// DeleteStrategy 删除策略
func (s *strategyService) DeleteStrategy(ctx context.Context, id int64) (affected int64, err error) {
	// 检查策略是否存在
	existingStrategy, err := dao.Strategy.GetByID(ctx, id)
	if err != nil {
		return 0, err
	}
	if existingStrategy == nil {
		return 0, gerror.New("策略不存在")
	}

	return dao.Strategy.Delete(ctx, id)
}

// GetStrategyByID 根据ID获取策略
func (s *strategyService) GetStrategyByID(ctx context.Context, id int64) (strategy *dto.StrategyRes, err error) {
	entity, err := dao.Strategy.GetByID(ctx, id)
	if err != nil {
		return nil, err
	}
	if entity == nil {
		return nil, gerror.New("策略不存在")
	}

	// 反序列化权重配置
	var weights map[string]int
	if entity.SourceWeights != "" {
		err = json.Unmarshal([]byte(entity.SourceWeights), &weights)
		if err != nil {
			return nil, gerror.Wrap(err, "权重配置反序列化失败")
		}
	}

	return &dto.StrategyRes{
		Id:            entity.Id,
		Name:          entity.Name,
		Description:   entity.Description,
		TenantLevel:   entity.TenantLevel,
		MinConversion: entity.MinConversion,
		MaxConversion: entity.MaxConversion,
		SourceWeights: weights,
		MaxAdsPerReq:  entity.MaxAdsPerReq,
		Priority:      entity.Priority,
		Status:        entity.Status,
		CreatedAt:     entity.CreatedAt.String(),
		UpdatedAt:     entity.UpdatedAt.String(),
		CreatedBy:     entity.CreatedBy,
		UpdatedBy:     entity.UpdatedBy,
	}, nil
}

// GetStrategyList 获取策略列表
func (s *strategyService) GetStrategyList(ctx context.Context, req *dto.GetStrategyListReq) (res *dto.GetStrategyListRes, err error) {
	list, total, err := dao.Strategy.GetList(ctx, req.Page, req.Size, req.TenantLevel, req.Status)
	if err != nil {
		return nil, err
	}

	var strategyList []*dto.StrategyRes
	for _, entity := range list {
		// 反序列化权重配置
		var weights map[string]int
		if entity.SourceWeights != "" {
			err = json.Unmarshal([]byte(entity.SourceWeights), &weights)
			if err != nil {
				g.Log().Warningf(ctx, "策略 %d 权重配置反序列化失败: %v", entity.Id, err)
				weights = make(map[string]int)
			}
		}

		strategyList = append(strategyList, &dto.StrategyRes{
			Id:            entity.Id,
			Name:          entity.Name,
			Description:   entity.Description,
			TenantLevel:   entity.TenantLevel,
			MinConversion: entity.MinConversion,
			MaxConversion: entity.MaxConversion,
			SourceWeights: weights,
			MaxAdsPerReq:  entity.MaxAdsPerReq,
			Priority:      entity.Priority,
			Status:        entity.Status,
			CreatedAt:     entity.CreatedAt.String(),
			UpdatedAt:     entity.UpdatedAt.String(),
			CreatedBy:     entity.CreatedBy,
			UpdatedBy:     entity.UpdatedBy,
		})
	}

	return &dto.GetStrategyListRes{
		List:  strategyList,
		Total: total,
		Page:  req.Page,
		Size:  req.Size,
	}, nil
}

// GetStrategyByTenantLevel 根据租户级别获取策略
func (s *strategyService) GetStrategyByTenantLevel(ctx context.Context, tenantLevel string) (strategy *entity.Strategy, err error) {
	return dao.Strategy.GetByTenantLevel(ctx, tenantLevel)
}