2108 lines
76 KiB
Go
2108 lines
76 KiB
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)
|
||
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 {
|
||
return errors.Wrapf(xerr.NewErrMsg("验证码不正确"), "验证码不正确: %s", encryptedMobile)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 三要素验证
|
||
func (l *QueryServiceLogic) Verify(Name string, IDCard string, Mobile string) error {
|
||
// 2025年8月18日上午8点30分之前都是二要素，过后是三要素
|
||
now := time.Now()
|
||
// 设定分界时间：2025年8月18日8点30分
|
||
switchTime := time.Date(2025, 8, 18, 8, 30, 0, 0, now.Location())
|
||
if now.Before(switchTime) {
|
||
// 二要素验证
|
||
twoFactorsErr := l.VerifyTwoFactors(Name, IDCard)
|
||
if twoFactorsErr != nil {
|
||
return twoFactorsErr
|
||
}
|
||
} else {
|
||
// 三要素验证
|
||
threeFactorsErr := l.VerifyThreeFactors(Name, IDCard, Mobile)
|
||
if threeFactorsErr != nil {
|
||
return threeFactorsErr
|
||
}
|
||
}
|
||
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])
|
||
}
|