qnc-server-tob/app/user/cmd/api/internal/logic/agent/activateagentmembershiplogic.go

package agent

import (
	"context"
	"encoding/json"
	"fmt"
	"qnc-server/common/ctxdata"
	"qnc-server/common/xerr"
	"time"

	"github.com/pkg/errors"

	"qnc-server/app/user/cmd/api/internal/svc"
	"qnc-server/app/user/cmd/api/internal/types"
	"qnc-server/app/user/model"

	"github.com/zeromicro/go-zero/core/logx"
)

type ActivateAgentMembershipLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewActivateAgentMembershipLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ActivateAgentMembershipLogic {
	return &ActivateAgentMembershipLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}
func (l *ActivateAgentMembershipLogic) ActivateAgentMembership(req *types.AgentActivateMembershipReq) (resp *types.AgentActivateMembershipResp, err error) {
	userID, err := ctxdata.GetUidFromCtx(l.ctx)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取用户ID失败: %v", err)
	}
	// 查询用户代理信息
	agentModel, err := l.svcCtx.AgentModel.FindOneByUserId(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询代理信息失败: %v", err)
	}
	// 定义等级顺序映射
	levelOrder := map[string]int{
		"":                        1,
		model.AgentLeveNameNormal: 1,
		model.AgentLeveNameVIP:    2,
		model.AgentLeveNameSVIP:   3,
	}

	// 验证请求等级合法性
	if _, valid := levelOrder[req.Type]; !valid {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "无效的代理等级: %s", req.Type)
	}

	// 如果存在代理记录，进行等级验证
	if agentModel != nil {
		currentLevel, exists := levelOrder[agentModel.LevelName]
		if !exists {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR),
				"非法的当前代理等级: %s", agentModel.LevelName)
		}

		requestedLevel := levelOrder[req.Type]
		if requestedLevel < currentLevel {
			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR),
				"禁止降级操作（当前等级：%s，请求等级：%s）", agentModel.LevelName, req.Type)
		}
		// 同等级视为续费，允许操作
	}
	outTradeNo := "A_" + l.svcCtx.AlipayService.GenerateOutTradeNo()
	redisKey := fmt.Sprintf(types.AgentVipCacheKey, userID, outTradeNo)
	agentVipCache := types.AgentVipCache{Type: req.Type}
	jsonData, err := json.Marshal(agentVipCache)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "序列化代理VIP缓存失败: %v", err)
	}
	cacheErr := l.svcCtx.Redis.SetexCtx(l.ctx, redisKey, string(jsonData), int(2*time.Hour))
	if cacheErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "设置缓存失败: %v", cacheErr)
	}
	return &types.AgentActivateMembershipResp{
		Id: outTradeNo,
	}, nil
}

// func (l *ActivateAgentMembershipLogic) ActivateAgentMembership(req *types.AgentActivateMembershipReq) (resp *types.AgentActivateMembershipResp, err error) {
// 	//userID, err := ctxdata.GetUidFromCtx(l.ctx)
// 	//if err != nil {
// 	//	return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取用户ID失败: %v", err)
// 	//}
// 	secretKey := l.svcCtx.Config.Encrypt.SecretKey
// 	encryptedMobile, err := crypto.EncryptMobile(req.Mobile, secretKey)
// 	if err != nil {
// 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "加密手机号失败: %v", err)
// 	}
// 	userModel, err := l.svcCtx.UserModel.FindOneByMobile(l.ctx, encryptedMobile)
// 	if err != nil {
// 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询代理信息失败: %v", err)
// 	}
// 	// 查询用户代理信息
// 	agentModel, err := l.svcCtx.AgentModel.FindOneByUserId(l.ctx, userModel.Id)
// 	if err != nil && err != sql.ErrNoRows {
// 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询代理信息失败: %v", err)
// 	}

// 	// 定义等级顺序映射
// 	levelOrder := map[string]int{
// 		"":                        1,
// 		model.AgentLeveNameNormal: 1,
// 		model.AgentLeveNameVIP:    2,
// 		model.AgentLeveNameSVIP:   3,
// 	}

// 	// 验证请求等级合法性
// 	if _, valid := levelOrder[req.Type]; !valid {
// 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "无效的代理等级: %s", req.Type)
// 	}

// 	// 如果存在代理记录，进行等级验证
// 	if agentModel != nil {
// 		currentLevel, exists := levelOrder[agentModel.LevelName]
// 		if !exists {
// 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR),
// 				"非法的当前代理等级: %s", agentModel.LevelName)
// 		}

// 		requestedLevel := levelOrder[req.Type]
// 		if requestedLevel < currentLevel {
// 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR),
// 				"禁止降级操作（当前等级：%s，请求等级：%s）", agentModel.LevelName, req.Type)
// 		}
// 	}

//		err = l.svcCtx.AgentModel.Trans(l.ctx, func(transCtx context.Context, session sqlx.Session) error {
//			agentModel.LevelName = req.Type
//			agentModel.MembershipExpiryTime = RenewMembership(agentModel.MembershipExpiryTime)
//			transErr := l.svcCtx.AgentModel.UpdateWithVersion(transCtx, session, agentModel)
//			if transErr != nil {
//				return transErr
//			}
//			agentMembershipRechargeOrder := model.AgentMembershipRechargeOrder{
//				AgentId:       agentModel.Id,
//				UserId:        userModel.Id,
//				LevelName:     req.Type,
//				Amount:        req.Amount,
//				PaymentMethod: req.PaymentMethod,
//				TransactionId: req.TransactionId,
//			}
//			_, transErr = l.svcCtx.AgentMembershipRechargeOrderModel.Insert(transCtx, session, &agentMembershipRechargeOrder)
//			if transErr != nil {
//				return transErr
//			}
//			return nil
//		})
//		if err != nil {
//			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "升级代理等级失败: %s", req.Type)
//		}
//		return &types.AgentActivateMembershipResp{
//			MembershipType: req.Type,
//			ExpireTime:     agentModel.MembershipExpiryTime.Time.Format("2006-01-02 15:04:05"),
//		}, nil
//	}