tyc-server/app/main/api/internal/logic/query/queryservicelogic.go

package query

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"strconv"
	"sync/atomic"
	"time"
	"tyc-server/app/main/api/internal/service"
	"tyc-server/common/ctxdata"
	"tyc-server/common/xerr"
	"tyc-server/pkg/lzkit/crypto"
	"tyc-server/pkg/lzkit/validator"

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

	"tyc-server/app/main/api/internal/svc"
	"tyc-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) {
	return l.PreprocessLogic(req, req.Product)
}
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 {
	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)

	// 检查验证码错误次数
	failCountKey := fmt.Sprintf("%s:fail_count:%s", "query", encryptedMobile)
	failCount, err := l.svcCtx.Redis.Get(failCountKey)
	if err != nil && !errors.Is(err, redis.Nil) {
		return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "读取验证码失败次数失败, mobile: %s, err: %+v", encryptedMobile, err)
	}

	// 如果失败次数大于等于2次，删除验证码并返回错误
	if failCount != "" && failCount >= "2" {
		l.svcCtx.Redis.Del(codeRedisKey)
		l.svcCtx.Redis.Del(failCountKey)
		return errors.Wrapf(xerr.NewErrMsg("验证码已过期"), "验证码已过期: %s", encryptedMobile)
	}

	cacheCode, err := l.svcCtx.Redis.Get(codeRedisKey)
	if err != nil {
		if errors.Is(err, redis.Nil) {
			return errors.Wrapf(xerr.NewErrMsg("验证码已过期"), "验证码过期: %s", encryptedMobile)
		}
		return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "读取验证码redis缓存失败, mobile: %s, err: %+v", encryptedMobile, err)
	}

	if cacheCode != code {
		// 验证码错误，增加失败次数
		newFailCount := 1
		if failCount != "" {
			if count, parseErr := strconv.Atoi(failCount); parseErr == nil {
				newFailCount = count + 1
			}
		}
		l.svcCtx.Redis.SetexCtx(l.ctx, failCountKey, strconv.Itoa(newFailCount), int(10*time.Minute))

		return errors.Wrapf(xerr.NewErrMsg("验证码不正确"), "验证码不正确: %s", encryptedMobile)
	}

	// 验证码正确，删除失败次数记录
	l.svcCtx.Redis.Del(failCountKey)
	return nil
}

// 三要素验证
func (l *QueryServiceLogic) Verify(Name string, IDCard string, Mobile string) error {
	if l.svcCtx.Config.VerifyConfig.TwoFactor {
		twoFactorsErr := l.VerifyTwoFactors(Name, IDCard)
		if twoFactorsErr != nil {
			return twoFactorsErr
		}
	} else {
		threeFactorsErr := l.VerifyThreeFactors(Name, IDCard, Mobile)
		if threeFactorsErr != nil {
			return threeFactorsErr
		}
	}
	return nil
	// ===========================================================
	// now := time.Now()
	// hour := now.Hour()
	// minute := now.Minute()

	// // 判断当前时间是否在三要素验证时间段内
	// // 上午8:30-12:00，下午14:30-18:30为三要素，其余为二要素
	// isThreeFactor := false

	// // 上午8:30-12:00
	// if (hour == 8 && minute >= 30) || (hour > 8 && hour < 12) || (hour == 12 && minute == 0) {
	// 	isThreeFactor = true
	// }
	// // 下午14:30-18:00
	// if (hour == 14 && minute >= 30) || (hour > 14 && hour < 18) || (hour == 18 && minute == 0) {
	// 	isThreeFactor = true
	// }

	// if isThreeFactor {
	// 	// 三要素验证
	// 	threeFactorsErr := l.VerifyThreeFactors(Name, IDCard, Mobile)
	// 	if threeFactorsErr != nil {
	// 		return threeFactorsErr
	// 	}
	// } else {
	// 	// 二要素验证
	// 	twoFactorsErr := l.VerifyTwoFactors(Name, IDCard)
	// 	if twoFactorsErr != nil {
	// 		return twoFactorsErr
	// 	}
	// }
	// return nil
}

// VerifyTwoFactors 二要素验证
func (l *QueryServiceLogic) VerifyTwoFactors(Name string, IDCard string) error {
	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)
	}
	return nil
}

// VerifyThreeFactors 三要素验证
func (l *QueryServiceLogic) VerifyThreeFactors(Name string, IDCard string, Mobile string) error {
	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 int64) (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)
	}
	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,
	}
	jsonData, marshalErr := json.Marshal(queryCache)
	if marshalErr != nil {
		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 序列化参数失败: %+v", marshalErr)
	}
	cacheNo := l.GenerateCacheNo()
	redisKey := fmt.Sprintf("%d:%s", userID, cacheNo)
	cacheErr := l.svcCtx.Redis.SetexCtx(l.ctx, redisKey, string(jsonData), int(2*time.Hour))
	if cacheErr != nil {
		return "", cacheErr
	}
	return cacheNo, nil
}

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,
	"toc_Marriage":                       (*QueryServiceLogic).ProcessTocMarriageLogic,
	"toc_PersonalBadRecord":              (*QueryServiceLogic).ProcessTocPersonalBadRecordLogic,
	"toc_ShareholderBusinessRelation":    (*QueryServiceLogic).ProcessTocShareholderBusinessRelationLogic,
	"toc_PersonalLawsuit":                (*QueryServiceLogic).ProcessTocPersonalLawsuitLogic,
	"toc_EnterpriseLawsuit":              (*QueryServiceLogic).ProcessTocEnterpriseLawsuitLogic,
	"toc_PhoneThreeElements":             (*QueryServiceLogic).ProcessTocPhoneThreeElementsLogic,
	"toc_PhoneTwoElements":               (*QueryServiceLogic).ProcessTocPhoneTwoElementsLogic,
	"toc_IDCardTwoElements":              (*QueryServiceLogic).ProcessTocIDCardTwoElementsLogic,
	"toc_NaturalLifeStatus":              (*QueryServiceLogic).ProcessTocNaturalLifeStatusLogic,
	"toc_DualMarriage":                   (*QueryServiceLogic).ProcessTocDualMarriageLogic,
	"toc_PhoneNumberRisk":                (*QueryServiceLogic).ProcessTocPhoneNumberRiskLogic,
	"toc_NetworkDuration":                (*QueryServiceLogic).ProcessTocNetworkDurationLogic,
	"toc_PhoneSecondaryCard":             (*QueryServiceLogic).ProcessTocPhoneSecondaryCardLogic,
	"toc_BankCardFourElements":           (*QueryServiceLogic).ProcessTocBankCardFourElementsLogic,
	"toc_PersonalConsumptionRestriction": (*QueryServiceLogic).ProcessTocPersonalConsumptionRestrictionLogic,
	"toc_PersonalDiscredit":              (*QueryServiceLogic).ProcessTocPersonalDiscreditLogic,
	"toc_BankCardBlacklist":              (*QueryServiceLogic).ProcessTocBankCardBlacklistLogic,

	// 查车部分
	"toc_vehicleInsuranceSummary":   (*QueryServiceLogic).ProcessTocVehicleInsuranceSummaryLogic,   // 车辆出险信息
	"toc_vehicleMaintenanceRecord":  (*QueryServiceLogic).ProcessTocVehicleMaintenanceRecordLogic,  // 车辆维修记录
	"toc_VehiclesUnderName":         (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,         // 名下车辆
	"toc_vehicleValuation":          (*QueryServiceLogic).ProcessTocVehicleValuationLogic,          // 车辆估值
	"toc_chassisNumberCheck":        (*QueryServiceLogic).ProcessTocChassisNumberCheckLogic,        // 车辆识别代码
	"toc_vehicleTransferCount":      (*QueryServiceLogic).ProcessTocVehicleTransferCountLogic,      // 车辆过户次数
	"toc_PersonVehicleVerification": (*QueryServiceLogic).ProcessTocPersonVehicleVerificationLogic, // 人车核验

	"toc_ExitRestriction":                   (*QueryServiceLogic).ProcessTocExitRestrictionLogic,                   // 限制出境
	"toc_MonthlyMobileConsumptionLevel":     (*QueryServiceLogic).ProcessTocMonthlyMobileConsumptionLevelLogic,     // 月消费水平
	"toc_EducationVerification":             (*QueryServiceLogic).ProcessTocEducationVerificationLogic,             // 学历认证
	"toc_FraudGamblingCheck":                (*QueryServiceLogic).ProcessTocFraudGamblingCheckLogic,                // 反赌反诈
	"toc_MobileNumberValidation":            (*QueryServiceLogic).ProcessTocMobileNumberValidationLogic,            // 手机号验证
	"toc_BankCardLocation":                  (*QueryServiceLogic).ProcessTocBankCardLocationLogic,                  // 银行卡归属地
	"toc_BankCardNameElementVerification":   (*QueryServiceLogic).ProcessTocBankCardNameElementVerificationLogic,   // 银行卡姓名认证
	"toc_BankCardIDElementVerification":     (*QueryServiceLogic).ProcessTocBankCardIDElementVerificationLogic,     // 银行卡身份证认证
	"toc_BankCardThreeElementsVerification": (*QueryServiceLogic).ProcessTocBankCardThreeElementsVerificationLogic, // 银行卡三要素认证
	"toc_MobileRiskAssessment":              (*QueryServiceLogic).ProcessTocMobileRiskAssessmentLogic,              // 手机号风险评估
	"toc_MobileDrugFraudRiskCheck":          (*QueryServiceLogic).ProcessTocMobileDrugFraudRiskCheckLogic,          // 手机号反赌反诈
	"toc_MobileLocation":                    (*QueryServiceLogic).ProcessTocMobileLocationLogic,                    // 手机归属地
	"toc_IDCardLocation":                    (*QueryServiceLogic).ProcessTocIDCardLocationLogic,                    // 身份证归属地
	"toc_DebtRepayStress":                   (*QueryServiceLogic).ProcessTocDebtRepayStressLogic,                   // 偿贷压力
	"toc_EducationInfo":                     (*QueryServiceLogic).ProcessTocEducationInfoLogic,                     // 学历信息查询
	"toc_PersonEnterprisePro":               (*QueryServiceLogic).ProcessTocPersonEnterpriseProLogic,               // 企业法人
}

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) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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)
	}

	// 校验验证码
	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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "marriage", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理家政服务相关逻辑

func (l *QueryServiceLogic) ProcessHomeServiceLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "homeservice", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理风险评估相关逻辑
func (l *QueryServiceLogic) ProcessRiskAssessmentLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "riskassessment", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理公司信息查询相关逻辑
func (l *QueryServiceLogic) ProcessCompanyInfoLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "companyinfo", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理租赁信息查询相关逻辑
func (l *QueryServiceLogic) ProcessRentalInfoLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "rentalinfo", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理贷前背景检查相关逻辑
func (l *QueryServiceLogic) ProcessPreLoanBackgroundCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "preloanbackgroundcheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 处理人事背调相关逻辑
func (l *QueryServiceLogic) ProcessBackgroundCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "backgroundcheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

func (l *QueryServiceLogic) ProcessTocMarriageLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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)
	}

	// // 校验验证码
	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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_Marriage", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}
func (l *QueryServiceLogic) ProcessTocPersonalBadRecordLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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)
	}

	// 校验验证码
	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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonalBadRecord", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}
func (l *QueryServiceLogic) ProcessTocShareholderBusinessRelationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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)
	}

	// 校验验证码
	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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_ShareholderBusinessRelation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}
func (l *QueryServiceLogic) ProcessTocPersonalLawsuitLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

	// 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)
	}

	// 校验验证码
	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,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonalLawsuit", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}
func (l *QueryServiceLogic) ProcessTocEnterpriseLawsuitLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.EntLawsuitReq
	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
	}

	// 缓存
	params := map[string]interface{}{
		"ent_name": data.EntName,
		"ent_code": data.EntCode,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_EnterpriseLawsuit", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

func (l *QueryServiceLogic) ProcessTocPhoneThreeElementsLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPhoneThreeElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PhoneThreeElements", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}
func (l *QueryServiceLogic) ProcessTocPhoneTwoElementsLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPhoneTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":   data.Name,
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PhoneTwoElements", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 身份二要素
func (l *QueryServiceLogic) ProcessTocIDCardTwoElementsLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_IDCardTwoElements", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// 自然人生存
func (l *QueryServiceLogic) ProcessTocNaturalLifeStatusLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_NaturalLifeStatus", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocVehiclesUnderNameLogic 名下车辆那个
func (l *QueryServiceLogic) ProcessTocVehiclesUnderNameLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_VehiclesUnderName", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPersonVehicleVerificationLogic 人车核验
func (l *QueryServiceLogic) ProcessTocPersonVehicleVerificationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPersonVehicleVerification
	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)
	}

	params := map[string]interface{}{
		"name":        data.Name,
		"car_type":    data.CarType,
		"car_license": data.CarLicense,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonVehicleVerification", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocVehicleInsuranceSummaryLogic 车辆出险信息
func (l *QueryServiceLogic) ProcessTocVehicleInsuranceSummaryLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocCarVin
	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)
	}

	params := map[string]interface{}{
		"vin_code": data.VinCode,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_vehicleInsuranceSummary", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocVehicleMaintenanceRecordLogic 车辆维保记录
func (l *QueryServiceLogic) ProcessTocVehicleMaintenanceRecordLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocCarVinDrivingPermit
	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)
	}

	params := map[string]interface{}{
		"vin_code":           data.VinCode,
		"car_driving_permit": data.CarDrivingPermit,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_vehicleMaintenanceRecord", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocVehicleValuationLogic 车辆估值
func (l *QueryServiceLogic) ProcessTocVehicleValuationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocCarVinLicense
	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)
	}

	params := map[string]interface{}{
		"vin_code":    data.VinCode,
		"car_license": data.CarLicense,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_vehicleValuation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocChassisNumberCheckLogic 车架号查车
func (l *QueryServiceLogic) ProcessTocChassisNumberCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocCarVin
	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)
	}

	params := map[string]interface{}{
		"vin_code": data.VinCode,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_chassisNumberCheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocVehicleTransferCountLogic 车辆过户次数查询
func (l *QueryServiceLogic) ProcessTocVehicleTransferCountLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocCarVin
	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)
	}

	params := map[string]interface{}{
		"vin_code": data.VinCode,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_vehicleTransferCount", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardBlacklistLogic 银行卡黑名单
func (l *QueryServiceLogic) ProcessTocBankCardBlacklistLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardBlacklist
	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)
	}

	params := map[string]interface{}{
		"name":      data.Name,
		"id_card":   data.IDCard,
		"mobile":    data.Mobile,
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardBlacklist", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocDualMarriageLogic 双人婚姻
func (l *QueryServiceLogic) ProcessTocDualMarriageLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocDualMarriage
	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 verifyErrMan := l.VerifyTwoFactors(data.NameMan, data.IDCardMan); verifyErrMan != nil {
		return nil, errors.Wrapf(xerr.NewErrMsg("男方"+verifyErrMan.Error()), "查询服务, 男方二要素验证失败: %+v", verifyErrMan)
	}

	// 验证女方二要素
	if verifyErrWoman := l.VerifyTwoFactors(data.NameWoman, data.IDCardWoman); verifyErrWoman != nil {
		return nil, errors.Wrapf(xerr.NewErrMsg("女方"+verifyErrWoman.Error()), "查询服务, 女方二要素验证失败: %+v", verifyErrWoman)
	}

	params := map[string]interface{}{
		"nameMan":     data.NameMan,
		"idCardMan":   data.IDCardMan,
		"nameWoman":   data.NameWoman,
		"idCardWoman": data.IDCardWoman,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_DualMarriage", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPhoneNumberRiskLogic 手机号码风险
func (l *QueryServiceLogic) ProcessTocPhoneNumberRiskLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPhoneNumberRisk
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PhoneNumberRisk", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocNetworkDurationLogic 手机在网时长
func (l *QueryServiceLogic) ProcessTocNetworkDurationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPhoneNumberRisk
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_NetworkDuration", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPhoneSecondaryCardLogic 手机二次卡
func (l *QueryServiceLogic) ProcessTocPhoneSecondaryCardLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPhoneSecondaryCard
	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)
	}

	params := map[string]interface{}{
		"mobile":    data.Mobile,
		"startDate": data.StartDate,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PhoneSecondaryCard", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardFourElementsLogic 银行卡四要素
func (l *QueryServiceLogic) ProcessTocBankCardFourElementsLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardBlacklist
	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)
	}

	params := map[string]interface{}{
		"name":      data.Name,
		"id_card":   data.IDCard,
		"mobile":    data.Mobile,
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardFourElements", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPersonalConsumptionRestrictionLogic 个人限高
func (l *QueryServiceLogic) ProcessTocPersonalConsumptionRestrictionLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonalConsumptionRestriction", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPersonalDiscreditLogic 个人失信
func (l *QueryServiceLogic) ProcessTocPersonalDiscreditLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardTwoElements
	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)
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonalDiscredit", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocExitRestrictionLogic 出境限制查询
func (l *QueryServiceLogic) ProcessTocExitRestrictionLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocExitRestriction
	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)
	}

	params := map[string]interface{}{
		"name": data.Name,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_ExitRestriction", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocMonthlyMobileConsumptionLevelLogic 手机月消费档次查询
func (l *QueryServiceLogic) ProcessTocMonthlyMobileConsumptionLevelLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocMonthlyMobileConsumptionLevel
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_MonthlyMobileConsumptionLevel", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocEducationVerificationLogic 学历信息验证
func (l *QueryServiceLogic) ProcessTocEducationVerificationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocEducationVerification
	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)
	}

	params := map[string]interface{}{
		"name":               data.Name,
		"id_card":            data.IDCard,
		"certificate_number": data.CertificateNumber,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_EducationVerification", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocMobileNumberValidationLogic 手机号空号检测
func (l *QueryServiceLogic) ProcessTocMobileNumberValidationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocMobileNumberValidation
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_MobileNumberValidation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardLocationLogic 银行卡归属地查询
func (l *QueryServiceLogic) ProcessTocBankCardLocationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardLocation
	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)
	}

	params := map[string]interface{}{
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardLocation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardNameElementVerificationLogic 银行卡姓名二要素验证
func (l *QueryServiceLogic) ProcessTocBankCardNameElementVerificationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardNameElementVerification
	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)
	}

	params := map[string]interface{}{
		"name":      data.Name,
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardNameElementVerification", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardIDElementVerificationLogic 银行卡号码二要素验证
func (l *QueryServiceLogic) ProcessTocBankCardIDElementVerificationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardIDElementVerification
	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)
	}

	params := map[string]interface{}{
		"id_card":   data.IDCard,
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardIDElementVerification", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocBankCardThreeElementsVerificationLogic 银行卡三要素综合验证
func (l *QueryServiceLogic) ProcessTocBankCardThreeElementsVerificationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocBankCardThreeElementsVerification
	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)
	}

	params := map[string]interface{}{
		"name":      data.Name,
		"id_card":   data.IDCard,
		"bank_card": data.BankCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_BankCardThreeElementsVerification", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocMobileRiskAssessmentLogic 高风险特殊手机号
func (l *QueryServiceLogic) ProcessTocMobileRiskAssessmentLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocMobileRiskAssessment
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_MobileRiskAssessment", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocMobileDrugFraudRiskCheckLogic 手机号贩毒反诈风险查询
func (l *QueryServiceLogic) ProcessTocMobileDrugFraudRiskCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocMobileDrugFraudRiskCheck
	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)
	}

	// 确定keyword和type
	var keyword string
	var dataType int

	// 根据传入的字段确定keyword和type
	if data.Mobile != "" {
		keyword = data.Mobile
		dataType = 1
	} else if data.BankCard != "" {
		keyword = data.BankCard
		dataType = 2
	} else if data.IDCard != "" {
		keyword = data.IDCard
		dataType = 3
	} else {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, "缺少必要参数"),
			"查询服务, 参数不正确: 缺少手机号/银行卡/身份证号")
	}

	// 构建参数
	params := map[string]interface{}{
		"keyword": keyword,
		"type":    dataType,
	}

	cacheNo, cacheDataErr := l.CacheData(params, "toc_MobileDrugFraudRiskCheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocFraudGamblingCheckLogic 反诈反赌风险核验
func (l *QueryServiceLogic) ProcessTocFraudGamblingCheckLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocFraudGamblingCheck
	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)
	}
	// 确定keyword和type
	var keyword string
	var dataType int

	// 根据传入的字段确定keyword和type
	if data.Mobile != "" {
		keyword = data.Mobile
		dataType = 1
	} else if data.BankCard != "" {
		keyword = data.BankCard
		dataType = 2
	} else if data.IDCard != "" {
		keyword = data.IDCard
		dataType = 3
	} else {
		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.PARAM_VERIFICATION_ERROR, "缺少必要参数"),
			"查询服务, 参数不正确: 缺少手机号/银行卡/身份证号")
	}

	// 构建参数
	params := map[string]interface{}{
		"keyword": keyword,
		"type":    dataType,
	}

	cacheNo, cacheDataErr := l.CacheData(params, "toc_FraudGamblingCheck", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocMobileLocationLogic 手机归属地
func (l *QueryServiceLogic) ProcessTocMobileLocationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocMobileLocation
	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)
	}

	params := map[string]interface{}{
		"mobile": data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_MobileLocation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocIDCardLocationLogic 身份证归属地
func (l *QueryServiceLogic) ProcessTocIDCardLocationLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocIDCardLocation
	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)
	}

	params := map[string]interface{}{
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_IDCardLocation", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocDebtRepayStressLogic 偿贷压力
func (l *QueryServiceLogic) ProcessTocDebtRepayStressLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocDebtRepayStress
	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 verifyErr := l.VerifyThreeFactors(data.Name, data.IDCard, data.Mobile); verifyErr != nil {
		return nil, verifyErr
	}

	params := map[string]interface{}{
		"mobile":  data.Mobile,
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_DebtRepayStress", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocEducationInfoLogic 学历信息查询
func (l *QueryServiceLogic) ProcessTocEducationInfoLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocEducationInfo
	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 verifyErr := l.VerifyTwoFactors(data.Name, data.IDCard); verifyErr != nil {
		return nil, verifyErr
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_EducationInfo", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil
}

// ProcessTocPersonEnterpriseProLogic 人企关系加强版
func (l *QueryServiceLogic) ProcessTocPersonEnterpriseProLogic(req *types.QueryServiceReq) (*types.QueryServiceResp, error) {
	userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUidErr != nil {
		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 获取用户信息失败, %+v", getUidErr)
	}

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

	// 校验参数
	var data types.TocPersonEnterprisePro
	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 verifyErr := l.VerifyTwoFactors(data.Name, data.IDCard); verifyErr != nil {
		return nil, verifyErr
	}

	params := map[string]interface{}{
		"name":    data.Name,
		"id_card": data.IDCard,
		"mobile":  data.Mobile,
	}
	cacheNo, cacheDataErr := l.CacheData(params, "toc_PersonEnterprisePro", userID)
	if cacheDataErr != nil {
		return nil, cacheDataErr
	}

	return &types.QueryServiceResp{Id: cacheNo}, nil

}

// 全局原子计数器
var CacheNoCounter uint32 = 0

func (l *QueryServiceLogic) GenerateCacheNo() string {
	// 获取当前时间戳（秒级）
	timestamp := time.Now().Unix()
	timeStr := strconv.FormatInt(timestamp, 10)

	// 原子递增计数器
	counter := atomic.AddUint32(&CacheNoCounter, 1)

	// 生成4字节真随机数
	randomBytes := make([]byte, 4)
	_, err := rand.Read(randomBytes)
	if err != nil {
		// 如果随机数生成失败，回退到使用时间纳秒数据
		randomBytes = []byte(strconv.FormatInt(time.Now().UnixNano()%1000000, 16))
	}
	randomHex := hex.EncodeToString(randomBytes)

	// 组合所有部分: 前缀 + 时间戳 + 计数器 + 随机数
	return fmt.Sprintf("query_%s%06x%s", timeStr, counter%0xFFFFFF, randomHex[:6])
}