v1.0.0

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

@@ -115,7 +115,10 @@ func (l *QueryDetailByOrderIdLogic) QueryDetailByOrderId(req *types.QueryDetailB
 	if decodeErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
 	}
-
+	processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告参数处理失败: %v", processParamsErr)
+	}
 	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
 	if processErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", processErr)
@@ -155,3 +158,20 @@ func ProcessQueryData(queryData sql.NullString, target *[]map[string]interface{}
 
 	return nil
 }
+
+// ProcessQueryParams解密和反序列化 QueryParams
+func ProcessQueryParams(QueryParams string, target *map[string]interface{}, key []byte) error {
+	// 解密 QueryParams
+	decryptedData, decryptErr := crypto.AesDecrypt(QueryParams, key)
+	if decryptErr != nil {
+		return decryptErr
+	}
+
+	// 反序列化解密后的数据
+	unmarshalErr := json.Unmarshal(decryptedData, target)
+	if unmarshalErr != nil {
+		return unmarshalErr
+	}
+
+	return nil
+}

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

@@ -111,7 +111,10 @@ func (l *QueryDetailByOrderNoLogic) QueryDetailByOrderNo(req *types.QueryDetailB
 	if decodeErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 获取AES解密解药失败, %+v", err)
 	}
-
+	processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告参数处理失败: %v", processParamsErr)
+	}
 	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
 	if processErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", processErr)

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

@@ -27,7 +27,49 @@ func NewQueryExampleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Quer
 }
 
 func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *types.QueryExampleResp, err error) {
-	var exampleID int64 = 8
+	var exampleID int64
+	switch req.Feature {
+	case "toc_PhoneThreeElements":
+		exampleID = 83
+	case "toc_BankCardBlacklist":
+		exampleID = 106
+	case "toc_IDCardTwoElements":
+		exampleID = 85
+	case "toc_PhoneTwoElements":
+		exampleID = 86
+	case "toc_NetworkDuration":
+		exampleID = 117
+	case "toc_PhoneSecondaryCard":
+		exampleID = 124
+	case "toc_PhoneNumberRisk":
+		exampleID = 126
+	case "toc_BankCardFourElements":
+		exampleID = 131
+	//case "toc_BankCardThreeElements":
+	//	exampleID = 9
+	//case "toc_NaturalLifeStatus":
+	//	exampleID = 10
+	//case "toc_EducationVerification":
+	//	exampleID = 11
+	case "toc_PersonVehicleVerification":
+		exampleID = 110
+	case "toc_VehiclesUnderName":
+		exampleID = 108
+	case "toc_DualMarriage":
+		exampleID = 103
+	case "toc_PersonalBadRecord":
+		exampleID = 73
+	case "toc_ShareholderBusinessRelation":
+		exampleID = 16
+	case "toc_PersonalLawsuit":
+		exampleID = 75
+	case "toc_EnterpriseLawsuit":
+		exampleID = 81
+	case "toc_Marriage":
+		exampleID = 72
+	default:
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
+	}
 	queryModel, err := l.svcCtx.QueryModel.FindOne(l.ctx, exampleID)
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
@@ -36,20 +78,24 @@ func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *type
 	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)
 	}
-
+	processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
+	if processParamsErr != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告参数处理失败: %v", processParamsErr)
+	}
 	processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
 	if processErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结果处理失败: %v", processErr)
 	}
-
-	copyErr := copier.Copy(&query, queryModel)
-	if copyErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 示例报告结构体复制失败, %+v", err)
+	// 复制报告数据
+	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 {

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

@@ -46,11 +46,23 @@ var productProcessors = map[string]func(*QueryServiceLogic, *types.QueryServiceR
 	"rentalinfo":                      (*QueryServiceLogic).ProcessRentalInfoLogic,
 	"preloanbackgroundcheck":          (*QueryServiceLogic).ProcessPreLoanBackgroundCheckLogic,
 	"backgroundcheck":                 (*QueryServiceLogic).ProcessBackgroundCheckLogic,
-	"toc_marriage":                    (*QueryServiceLogic).ProcessTocMarriageLogic,
+	"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_PersonVehicleVerification":   (*QueryServiceLogic).ProcessTocPersonVehicleVerificationLogic,
+	"toc_BankCardBlacklist":           (*QueryServiceLogic).ProcessTocBankCardBlacklistLogic,
+	"toc_VehiclesUnderName":           (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
+	"toc_DualMarriage":                (*QueryServiceLogic).ProcessTocDualMarriageLogic,
+	"toc_PhoneNumberRisk":             (*QueryServiceLogic).ProcessTocPhoneNumberRiskLogic,
+	"toc_NetworkDuration":             (*QueryServiceLogic).ProcessTocNetworkDurationLogic,
+	"toc_PhoneSecondaryCard":          (*QueryServiceLogic).ProcessTocPhoneSecondaryCardLogic,
+	"toc_BankCardFourElements":        (*QueryServiceLogic).ProcessTocBankCardFourElementsLogic,
 }
 
 func (l *QueryServiceLogic) PreprocessLogic(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
@@ -442,7 +454,7 @@ func (l *QueryServiceLogic) ProcessTocMarriageLogic(req *types.QueryServiceReq)
 		"id_card": data.IDCard,
 		"mobile":  data.Mobile,
 	}
-	cacheNo, cacheDataErr := l.CacheData(params, "toc_marriage", userID)
+	cacheNo, cacheDataErr := l.CacheData(params, "toc_Marriage", userID)
 	if cacheDataErr != nil {
 		return nil, cacheDataErr
 	}
@@ -618,12 +630,6 @@ func (l *QueryServiceLogic) ProcessTocEnterpriseLawsuitLogic(req *types.QuerySer
 		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,
@@ -636,6 +642,429 @@ func (l *QueryServiceLogic) ProcessTocEnterpriseLawsuitLogic(req *types.QuerySer
 
 	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
+}
+
+// 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)
+	}
+
+	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
+}
 func (l *QueryServiceLogic) DecryptData(data string) ([]byte, error) {
 	secretKey := l.svcCtx.Config.Encrypt.SecretKey
 	key, decodeErr := hex.DecodeString(secretKey)
@@ -670,9 +1099,9 @@ func (l *QueryServiceLogic) Verify(Name string, IDCard string, Mobile string) er
 	if l.svcCtx.Config.SystemConfig.ThreeVerify {
 		// 三要素验证
 		threeVerification := service.ThreeFactorVerificationRequest{
-			Name,
-			IDCard,
-			Mobile,
+			Name:   Name,
+			IDCard: IDCard,
+			Mobile: Mobile,
 		}
 		verification, err := l.svcCtx.VerificationService.ThreeFactorVerification(threeVerification)
 		if err != nil {
@@ -683,8 +1112,8 @@ func (l *QueryServiceLogic) Verify(Name string, IDCard string, Mobile string) er
 		}
 	} else {
 		twoVerification := service.TwoFactorVerificationRequest{
-			Name,
-			IDCard,
+			Name:   Name,
+			IDCard: IDCard,
 		}
 		verification, err := l.svcCtx.VerificationService.TwoFactorVerification(twoVerification)
 		if err != nil {