feat(user): temp

app/user/cmd/api/internal/logic/query/marriagelogic.go

@@ -94,7 +94,7 @@ func (l *MarriageLogic) Marriage(req *types.QueryReq) (resp *types.QueryResp, er
 		return nil, errors.Wrapf(xerr.NewErrMsg("验证码不正确"), "婚恋评估, 验证码不正确: %s", data.Mobile)
 	}
 
-	//// 3、二要素三要素核验
+	//// 3、二要素核验
 	//twoVerification := service.TwoFactorVerificationRequest{
 	//	Name:   data.Name,
 	//	IDCard: data.IDCard,
@@ -106,7 +106,7 @@ func (l *MarriageLogic) Marriage(req *types.QueryReq) (resp *types.QueryResp, er
 	//if !verification.Passed {
 	//	return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.SERVER_COMMON_ERROR, verification.Err.Error()), "婚恋评估, 二要素验证不通过: %+v", err)
 	//}
-	// 3、二要素三要素核验
+	// 3、三要素核验
 	threeVerification := service.ThreeFactorVerificationRequest{
 		Name:   data.Name,
 		IDCard: data.IDCard,

app/user/cmd/api/internal/logic/query/querydetailbyorderidlogic.go

@@ -65,8 +65,8 @@ func (l *QueryDetailByOrderIdLogic) QueryDetailByOrderId(req *types.QueryDetailB
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找订单错误: %+v", err)
 		}
 	}
-	if order.Status != "paid" {
-		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_WAIT, ""), "")
+	if order.Status == "failed" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
 	}
 	// 获取报告信息
 	queryModel, err := l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, req.OrderId)
@@ -125,7 +125,11 @@ func (l *QueryDetailByOrderIdLogic) QueryDetailByOrderId(req *types.QueryDetailB
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %+v", err)
 	}
-
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %+v", err)
+	}
+	query.ProductName = product.ProductName
 	return &types.QueryDetailByOrderIdResp{
 		Query: query,
 	}, nil

app/user/cmd/api/internal/logic/query/querydetailbyordernologic.go

@@ -0,0 +1,132 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+	"qnc-server/common/xerr"
+	"qnc-server/pkg/lzkit/delay"
+	"time"
+
+	"qnc-server/app/user/cmd/api/internal/svc"
+	"qnc-server/app/user/cmd/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type QueryDetailByOrderNoLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewQueryDetailByOrderNoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryDetailByOrderNoLogic {
+	return &QueryDetailByOrderNoLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryDetailByOrderNoLogic) QueryDetailByOrderNo(req *types.QueryDetailByOrderNoReq) (resp *types.QueryDetailByOrderNoResp, err error) {
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	// 创建渐进式延迟策略实例
+	progressiveDelayOrder, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待订单状态变为 "paid"
+	startTime := time.Now()
+	for order.Status == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_WAIT, ""), "")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayOrder.NextDelay()
+
+		// 等待一段时间后再查一次订单状态
+		time.Sleep(nextDelay)
+
+		// 再次查找订单
+		order, err = l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找订单错误: %+v", err)
+		}
+	}
+	if order.Status != "paid" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_WAIT, ""), "")
+	}
+	// 获取报告信息
+	queryModel, err := l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, order.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+	}
+
+	// 创建渐进式延迟实例
+	progressiveDelayQuery, err := delay.New(200*time.Millisecond, 3*time.Second, 10*time.Second, 1.5)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "初始化渐进式延迟策略失败: %+v", err)
+	}
+
+	// 等待 queryModel.QueryState 不再是 "pending"
+	startTime = time.Now()
+	for queryModel.QueryState == "pending" {
+		if time.Since(startTime) > 10*time.Second {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询超时，查询状态长时间为 'pending'")
+		}
+
+		// 使用渐进式延迟，获取下次延迟时间
+		nextDelay, _ := progressiveDelayQuery.NextDelay()
+
+		// 每隔一段时间检查一次查询状态
+		time.Sleep(nextDelay)
+
+		// 再次查询 report 状态
+		queryModel, err = l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, order.Id)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告查询, 查找报告错误: %+v", err)
+		}
+	}
+
+	// 根据 QueryState 做后续处理
+	if queryModel.QueryState == "failed" {
+		return nil, errors.Wrapf(xerr.NewErrCodeMsg(xerr.LOGIC_QUERY_ERROR, ""), "")
+	}
+
+	var query types.Query
+	query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
+	query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
+
+	// 解密查询数据
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+	key, decodeErr := hex.DecodeString(secretKey)
+	if decodeErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
+	}
+
+	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
+	if processErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", processErr)
+	}
+	// 复制报告数据
+	err = copier.Copy(&query, queryModel)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %+v", err)
+	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %+v", err)
+	}
+	query.ProductName = product.ProductName
+	return &types.QueryDetailByOrderNoResp{
+		Query: query,
+	}, nil
+}

app/user/cmd/api/internal/logic/query/querydetaillogic.go

@@ -58,6 +58,11 @@ func (l *QueryDetailLogic) QueryDetail(req *types.QueryDetailReq) (resp *types.Q
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结构体复制失败, %+v", err)
 	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取商品信息失败, %+v", err)
+	}
+	query.ProductName = product.ProductName
 	return &types.QueryDetailResp{
 		Query: query,
 	}, nil

app/user/cmd/api/internal/logic/query/queryexamplelogic.go

@@ -51,6 +51,11 @@ func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *type
 	if copyErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 示例报告结构体复制失败, %+v", err)
 	}
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取商品信息失败, %+v", err)
+	}
+	query.ProductName = product.ProductName
 	return &types.QueryExampleResp{
 		Query: query,
 	}, nil

app/user/cmd/api/internal/logic/query/querylistlogic.go

@@ -50,6 +50,11 @@ func (l *QueryListLogic) QueryList(req *types.QueryListReq) (resp *types.QueryLi
 			if copyErr != nil {
 				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 报告结构体复制失败, %+v", err)
 			}
+			product, findProductErr := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
+			if findProductErr != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 获取商品信息失败, %+v", err)
+			}
+			query.ProductName = product.ProductName
 			list = append(list, query)
 		}
 	}

app/user/cmd/api/internal/logic/query/queryservicelogic.go

@@ -0,0 +1,717 @@
+package query
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"qnc-server/app/user/cmd/api/internal/service"
+	"qnc-server/common/ctxdata"
+	"qnc-server/common/xerr"
+	"qnc-server/pkg/lzkit/crypto"
+	"qnc-server/pkg/lzkit/validator"
+	"time"
+
+	"qnc-server/app/user/cmd/api/internal/svc"
+	"qnc-server/app/user/cmd/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)
+}
+
+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,
+}
+
+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
+	}
+
+	// 校验三要素 后期应改为企业二要素
+	//verifyErr := l.Verify(data, data.IDCard, data.Mobile)
+	//if verifyErr != nil {
+	//	return nil, verifyErr
+	//}
+
+	// 缓存
+	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) 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 {
+	codeRedisKey := fmt.Sprintf("%s:%s", "query", mobile)
+	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 l.svcCtx.Config.SystemConfig.ThreeVerify {
+		// 三要素验证
+		threeVerification := service.ThreeFactorVerificationRequest{
+			Name,
+			IDCard,
+			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)
+		}
+	} else {
+		twoVerification := service.TwoFactorVerificationRequest{
+			Name,
+			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
+}
+
+// 缓存
+func (l *QueryServiceLogic) CacheData(params map[string]interface{}, Product string, userID int64) (string, error) {
+	queryCache := types.QueryCacheLoad{
+		Params:  params,
+		Product: Product,
+	}
+	jsonData, marshalErr := json.Marshal(queryCache)
+	if marshalErr != nil {
+		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 序列化参数失败: %+v", marshalErr)
+	}
+	outTradeNo := l.svcCtx.WechatPayService.GenerateOutTradeNo()
+	redisKey := fmt.Sprintf("%d:%s", userID, outTradeNo)
+	cacheErr := l.svcCtx.Redis.SetexCtx(l.ctx, redisKey, string(jsonData), int(2*time.Hour))
+	if cacheErr != nil {
+		return "", cacheErr
+	}
+	return outTradeNo, nil
+}