zac_server_v2/app/main/api/internal/logic/query/queryservicelogic.go

package query

import (
	"context"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"os"
	"qnc-server/app/main/api/internal/service"
	"qnc-server/app/main/model"
	"qnc-server/common/ctxdata"
	"qnc-server/common/xerr"
	"qnc-server/pkg/captcha"
	"qnc-server/pkg/lzkit/crypto"
	"qnc-server/pkg/lzkit/lzUtils"
	"qnc-server/pkg/lzkit/validator"
	"time"

	"github.com/google/uuid"
	"github.com/pkg/errors"
	"github.com/zeromicro/go-zero/core/stores/redis"

	"qnc-server/app/main/api/internal/svc"
	"qnc-server/app/main/api/internal/types"

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

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

func NewQueryServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryServiceLogic {
	return &QueryServiceLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

func (l *QueryServiceLogic) QueryService(req *types.QueryServiceReq) (resp *types.QueryServiceResp, err error) {
	if req.AgentIdentifier != "" {
		l.ctx = context.WithValue(l.ctx, "agentIdentifier", req.AgentIdentifier)
	} else if req.App {
		l.ctx = context.WithValue(l.ctx, "app", req.App)
	}
	return l.PreprocessLogic(req, req.Product)
}

var productProcessors = map[string]func(*QueryServiceLogic, *types.QueryServiceReq) (*types.QueryServiceResp, error){
	"marriage":               (*QueryServiceLogic).ProcessMarriageLogic,
	"homeservice":            (*QueryServiceLogic).ProcessHomeServiceLogic,
	"riskassessment":         (*QueryServiceLogic).ProcessRiskAssessmentLogic,
	"companyinfo":            (*QueryServiceLogic).ProcessCompanyInfoLogic,
	"rentalinfo":             (*QueryServiceLogic).ProcessRentalInfoLogic,
	"preloanbackgroundcheck": (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
	"backgroundcheck":        (*QueryServiceLogic).ProcessBackgroundCheckLogic,
	"personalData":           (*QueryServiceLogic).ProcessPersonalDataLogic,
	"consumerFinanceReport":  (*QueryServiceLogic).ProcessConsumerFinanceReportLogic,
}

func (l *QueryServiceLogic) PreprocessLogic(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
	if processor, exists := productProcessors[product]; exists {
		return processor(l, req) // 调用相应的处理函数
	}
	return nil, errors.New("未找到相应的处理程序")
}

func (l *QueryServiceLogic) ProcessMarriageLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {

	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.MarriageReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验拼图验证码
	if err := l.VerifyCaptcha(data.CaptchaVerifyParam); err != nil {
		return nil, err
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "marriage", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "marriage", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %v", err)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理家政服务相关逻辑
func (l *QueryServiceLogic) ProcessHomeServiceLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {

	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.HomeServiceReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "homeservice", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "homeservice", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理风险评估相关逻辑
func (l *QueryServiceLogic) ProcessRiskAssessmentLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {

	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.RiskAssessmentReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "riskassessment", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "riskassessment", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理公司信息查询相关逻辑
func (l *QueryServiceLogic) ProcessCompanyInfoLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.CompanyInfoReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "companyinfo", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "companyinfo", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理租赁信息查询相关逻辑
func (l *QueryServiceLogic) ProcessRentalInfoLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {

	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.RentalInfoReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "rentalinfo", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "rentalinfo", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理贷前背景检查相关逻辑
func (l *QueryServiceLogic) ProcessPreLoanBackgroundCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {

	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.PreLoanBackgroundCheckReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "preloanbackgroundcheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "preloanbackgroundcheck", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}

// 处理人事背调相关逻辑
func (l *QueryServiceLogic) ProcessBackgroundCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.BackgroundCheckReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "backgroundcheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "backgroundcheck", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}
func (l *QueryServiceLogic) ProcessPersonalDataLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.PersonalDataReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "personalData", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "personalData", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}
func (l *QueryServiceLogic) ProcessConsumerFinanceReportLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	// AES解密
	decryptData, DecryptDataErr := l.DecryptData(req.Data)
	if DecryptDataErr != nil {
		return nil, DecryptDataErr
	}

	// 校验参数
	var data types.ConsumerFinanceReportReq
	if unmarshalErr := json.Unmarshal(decryptData, &data); unmarshalErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 解密后的数据格式不正确: %+v", unmarshalErr)
	}

	if validatorErr := validator.Validate(data); validatorErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, validatorErr.Error()), "查询服务, 参数不正确: %+v", validatorErr)
	}

	// 校验验证码
	verifyCodeErr := l.VerifyCode(data.Mobile, data.Code)
	if verifyCodeErr != nil {
		return nil, verifyCodeErr
	}

	// 校验三要素
	verifyErr := l.Verify(data.Name, data.IDCard, data.Mobile)
	if verifyErr != nil {
		return nil, verifyErr
	}

	// 缓存
	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	userID, err := l.GetOrCreateUser()
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 处理用户失败: %v", err)
	}
	cacheNo, cacheDataErr := l.CacheData(params, "consumerFinanceReport", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}
	// 插入业务操作记录
	if insertErr := l.InsertQueryUserRecord(params, "consumerFinanceReport", cacheNo, userID); insertErr != nil {
		logx.Errorf("插入查询用户记录失败: %v", insertErr)
		// 记录失败不影响主流程，只记录日志
	}
	token, err := l.svcCtx.UserService.GeneralUserToken(l.ctx, userID)
	if err != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 生成token失败 : %d", userID)
	}

	// 获取当前时间戳
	now := time.Now().Unix()
	return &types.QueryServiceResp{
		Id:           cacheNo,
		AccessToken:  token,
		AccessExpire: now + l.svcCtx.Config.JwtAuth.AccessExpire,
		RefreshAfter: now + l.svcCtx.Config.JwtAuth.RefreshAfter,
	}, nil
}
func (l *QueryServiceLogic) DecryptData(data string) ([]byte, error) {
	secretKey := l.svcCtx.Config.Encrypt.SecretKey
	key, decodeErr := hex.DecodeString(secretKey)
	if decodeErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "秘钥获取失败: %+v", decodeErr)
	}
	decryptData, aesDecryptErr := crypto.AesDecrypt(data, key)
	if aesDecryptErr != nil || len(decryptData) == 0 {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "解密失败: %+v", aesDecryptErr)
	}
	return decryptData, nil
}

// 校验验证码
func (l *QueryServiceLogic) VerifyCode(mobile string, code string) error {
	// 开发环境下跳过验证码校验
	if os.Getenv("ENV") == "development" {
		return nil
	}
	secretKey := l.svcCtx.Config.Encrypt.SecretKey
	encryptedMobile, err := crypto.EncryptMobile(mobile, secretKey)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "加密手机号失败: %+v", err)
	}
	codeRedisKey := fmt.Sprintf("%s:%s", "query", encryptedMobile)
	cacheCode, err := l.svcCtx.Redis.Get(codeRedisKey)
	if err != nil {
		if errors.Is(err, redis.Nil) {
			return errors.Wrapf(xerr.NewErrMsg("验证码已过期"), "验证码过期: %s", mobile)
		}
		return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "读取验证码redis缓存失败, mobile: %s, err: %+v", mobile, err)
	}
	if cacheCode != code {
		return errors.Wrapf(xerr.NewErrMsg("验证码不正确"), "验证码不正确: %s", mobile)
	}
	return nil
}

// 二、三要素验证
func (l *QueryServiceLogic) Verify(Name string, IDCard string, Mobile string) error {
	// 开发环境下跳过二、三要素验证
	if os.Getenv("ENV") == "development" {
		return nil
	}
	if !l.svcCtx.Config.SystemConfig.ThreeVerify {
		twoVerification := service.TwoFactorVerificationRequest{
			Name:   Name,
			IDCard: IDCard,
		}
		verification, err := l.svcCtx.VerificationService.TwoFactorVerification(twoVerification)
		if err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "二要素验证失败: %v", err)
		}
		if !verification.Passed {
			return errors.Wrapf(xerr.NewErrCodeMsg(xerr.SERVER_COMMON_ERROR, verification.Err.Error()), "二要素验证不通过: %v", err)
		}
	} else {
		// 三要素验证
		threeVerification := service.ThreeFactorVerificationRequest{
			Name:   Name,
			IDCard: IDCard,
			Mobile: Mobile,
		}
		verification, err := l.svcCtx.VerificationService.ThreeFactorVerification(threeVerification)
		if err != nil {
			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "三要素验证失败: %v", err)
		}
		if !verification.Passed {
			return errors.Wrapf(xerr.NewErrCodeMsg(xerr.SERVER_COMMON_ERROR, verification.Err.Error()), "三要素验证不通过: %v", err)
		}
	}
	return nil
}

// 缓存
func (l *QueryServiceLogic) CacheData(params map[string]interface{}, Product string, userID string) (string, error) {
	agentIdentifier, _ := l.ctx.Value("agentIdentifier").(string)
	secretKey := l.svcCtx.Config.Encrypt.SecretKey
	key, decodeErr := hex.DecodeString(secretKey)
	if decodeErr != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取AES秘钥失败: %+v", decodeErr)
	}
	paramsMarshal, marshalErr := json.Marshal(params)
	if marshalErr != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 序列化参数失败: %+v", marshalErr)
	}
	encryptParams, aesEncryptErr := crypto.AesEncrypt(paramsMarshal, key)
	if aesEncryptErr != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 加密参数失败: %+v", aesEncryptErr)
	}
	queryCache := types.QueryCacheLoad{
		Params:          encryptParams,
		Product:         Product,
		AgentIdentifier: agentIdentifier,
	}
	jsonData, marshalErr := json.Marshal(queryCache)
	if marshalErr != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 序列化参数失败: %+v", marshalErr)
	}
	outTradeNo := "Q_" + l.svcCtx.AlipayService.GenerateOutTradeNo()
	redisKey := fmt.Sprintf(types.QueryCacheKey, userID, outTradeNo)
	cacheErr := l.svcCtx.Redis.SetexCtx(l.ctx, redisKey, string(jsonData), int(2*time.Hour))
	if cacheErr != nil {
		return "", cacheErr
	}
	return outTradeNo, nil
}

// GetOrCreateUser 获取或创建用户
// 1. 如果已登录,使用当前登录用户
// 2. 如果未登录,创建临时用户(UUID用户)
// 注意:查询服务不负责手机号绑定,手机号绑定由用户在其他地方自主选择
func (l *QueryServiceLogic) GetOrCreateUser() (string, error) {
	// 获取当前登录态
	claims, err := ctxdata.GetClaimsFromCtx(l.ctx)
	logx.Infof("claims: %+v", claims)
	if err != nil && !errors.Is(err, ctxdata.ErrNoInCtx) {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "获取用户信息失败: %v", err)
	}

	// 如果已登录,使用当前登录用户
	if claims != nil {
		return claims.UserId, nil
	}

	// 未登录:创建临时用户(UUID用户)
	userID, err := l.svcCtx.UserService.RegisterUUIDUser(l.ctx)
	if err != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "创建临时用户失败: %v", err)
	}

	return userID, nil
}

// InsertQueryUserRecord 插入查询用户记录到 query_user_record 表
// 业务场景：用户提交查询时，记录用户输入的姓名、身份证、手机号等信息
func (l *QueryServiceLogic) InsertQueryUserRecord(params map[string]interface{}, product string, queryNo string, userID string) error {
	secretKey := l.svcCtx.Config.Encrypt.SecretKey
	key, decodeErr := hex.DecodeString(secretKey)
	if decodeErr != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "插入查询用户记录, 获取AES秘钥失败: %+v", decodeErr)
	}

	// 获取姓名、身份证、手机号
	name, _ := params["name"].(string)
	idCard, _ := params["id_card"].(string)
	mobile, _ := params["mobile"].(string)

	// 加密敏感字段
	encryptedName, err := crypto.AesEcbEncrypt([]byte(name), key)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "插入查询用户记录, 加密姓名失败: %+v", err)
	}

	encryptedIdCard, err := crypto.EncryptIDCard(idCard, key)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "插入查询用户记录, 加密身份证号失败: %+v", err)
	}

	encryptedMobile, err := crypto.EncryptMobile(mobile, secretKey)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "插入查询用户记录, 加密手机号失败: %+v", err)
	}

	// 获取代理标识
	agentIdentifier, _ := l.ctx.Value("agentIdentifier").(string)

	// 创建记录
	record := &model.QueryUserRecord{
		Id:              uuid.NewString(), // 生成 UUID
		UserId:          userID,           // user_id 是 UUID 字符串
		Name:            encryptedName,
		IdCard:          encryptedIdCard,
		Mobile:          encryptedMobile,
		Product:         product,
		QueryNo:         queryNo,
		OrderId:         lzUtils.StringToNullString(""), // 初始为 NULL，创建订单后更新
		PlatformOrderId: lzUtils.StringToNullString(""), // 初始为空，支付成功后更新
		AgentIdentifier: lzUtils.StringToNullString(agentIdentifier),
		DelState:        0,
		Version:         0,
	}

	// 插入数据库
	_, err = l.svcCtx.QueryUserRecordModel.Insert(l.ctx, nil, record)
	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "插入查询用户记录失败: %+v", err)
	}

	return nil
}

// VerifyCaptcha 校验拼图验证码
func (l *QueryServiceLogic) VerifyCaptcha(captchaVerifyParam string) error {
	// 开发环境跳过验证
	if os.Getenv("ENV") == "development" {
		return nil
	}

	cfg := l.svcCtx.Config.Captcha
	if err := captcha.Verify(captcha.Config{
		AccessKeyID:     cfg.AccessKeyID,
		AccessKeySecret: cfg.AccessKeySecret,
		EndpointURL:     cfg.EndpointURL,
		SceneID:         cfg.SceneID,
	}, captchaVerifyParam); err != nil {
		return errors.Wrapf(xerr.NewErrMsg("拼图验证码校验失败"), "captcha verify failed: %v", err)
	}
	return nil
}