team/tyc-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增新接口

Browse Source
This commit is contained in:
liangzai
2025-03-20 02:03:28 +08:00
parent b1375f0343
commit 115a67f537
16 changed files with 1295 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
app/user/cmd/api/internal/logic/query/queryexamplelogic.go
View File

@@ -3,12 +3,13 @@ package query
import (
"context"
"encoding/hex"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
"qnc-server/app/user/cmd/api/internal/svc"
"qnc-server/app/user/cmd/api/internal/types"
"qnc-server/common/xerr"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/logx"
)
@@ -27,60 +28,17 @@ func NewQueryExampleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Quer
}
func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *types.QueryExampleResp, err error) {
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 = 74
case "toc_PersonalLawsuit":
exampleID = 75
case "toc_EnterpriseLawsuit":
exampleID = 81
case "toc_Marriage":
exampleID = 367
case "toc_PersonalConsumptionRestriction":
exampleID = 2089
case "toc_PersonalDiscredit":
exampleID = 2088
default:
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, req.Feature)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取商品信息失败: %v", err)
}
queryModel, err := l.svcCtx.QueryModel.FindOne(l.ctx, exampleID)
exampleModel, err := l.svcCtx.ExampleModel.FindOneByProductId(l.ctx, product.Id)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
}
var query types.Query
query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
query.CreateTime = exampleModel.CreateTime.Format("2006-01-02 15:04:05")
query.UpdateTime = exampleModel.UpdateTime.Format("2006-01-02 15:04:05")
// 解密查询数据
secretKey := l.svcCtx.Config.Encrypt.SecretKey
@@ -88,23 +46,19 @@ func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *type
if decodeErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %+v", err)
}
processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
processParamsErr := ProcessQueryParams(exampleModel.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)
processErr := ProcessQueryData(exampleModel.QueryData, &query.QueryData, key)
if processErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结果处理失败: %v", processErr)
}
// 复制报告数据
err = copier.Copy(&query, queryModel)
err = copier.Copy(&query, exampleModel)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结构体复制失败, %+v", err)
}
product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取商品信息失败, %+v", err)
}
query.ProductName = product.ProductName
return &types.QueryExampleResp{
Query: query,

452
app/user/cmd/api/internal/logic/query/queryservicelogic.go
View File

@@ -5,8 +5,6 @@ import (
"encoding/hex"
"encoding/json"
"fmt"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/stores/redis"
"qnc-server/app/user/cmd/api/internal/service"
"qnc-server/common/ctxdata"
"qnc-server/common/xerr"
@@ -14,6 +12,9 @@ import (
"qnc-server/pkg/lzkit/validator"
"time"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/stores/redis"
"qnc-server/app/user/cmd/api/internal/svc"
"qnc-server/app/user/cmd/api/internal/types"
@@ -65,13 +66,24 @@ var productProcessors = map[string]func(*QueryServiceLogic, *types.QueryServiceR
"toc_PersonalDiscredit": (*QueryServiceLogic).ProcessTocPersonalDiscreditLogic,
// 车辆部分
"toc_BankCardBlacklist": (*QueryServiceLogic).ProcessTocBankCardBlacklistLogic,
"toc_VehiclesUnderName": (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
"toc_vehicleInsuranceSummary": (*QueryServiceLogic).ProcessTocVehicleInsuranceSummaryLogic,
"toc_vehicleMaintenanceRecord": (*QueryServiceLogic).ProcessTocVehicleMaintenanceRecordLogic,
"toc_vehicleValuation": (*QueryServiceLogic).ProcessTocVehicleValuationLogic,
"toc_chassisNumberCheck": (*QueryServiceLogic).ProcessTocChassisNumberCheckLogic,
"toc_vehicleTransferCount": (*QueryServiceLogic).ProcessTocVehicleTransferCountLogic,
"toc_BankCardBlacklist": (*QueryServiceLogic).ProcessTocBankCardBlacklistLogic,
"toc_VehiclesUnderName": (*QueryServiceLogic).ProcessTocVehiclesUnderNameLogic,
"toc_vehicleInsuranceSummary": (*QueryServiceLogic).ProcessTocVehicleInsuranceSummaryLogic,
"toc_vehicleMaintenanceRecord": (*QueryServiceLogic).ProcessTocVehicleMaintenanceRecordLogic,
"toc_vehicleValuation": (*QueryServiceLogic).ProcessTocVehicleValuationLogic,
"toc_chassisNumberCheck": (*QueryServiceLogic).ProcessTocChassisNumberCheckLogic,
"toc_vehicleTransferCount": (*QueryServiceLogic).ProcessTocVehicleTransferCountLogic,
"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,
}
func (l *QueryServiceLogic) PreprocessLogic(req *types.QueryServiceReq, product string) (*types.QueryServiceResp, error) {
@@ -1316,6 +1328,428 @@ func (l *QueryServiceLogic) ProcessTocPersonalDiscreditLogic(req *types.QuerySer
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
}
func (l *QueryServiceLogic) DecryptData(data string) ([]byte, error) {
secretKey := l.svcCtx.Config.Encrypt.SecretKey
key, decodeErr := hex.DecodeString(secretKey)

12
app/user/cmd/api/internal/logic/query/querysingletestlogic.go
View File

@@ -3,9 +3,10 @@ package query
import (
"context"
"encoding/json"
"github.com/pkg/errors"
"qnc-server/common/xerr"
"github.com/pkg/errors"
"qnc-server/app/user/cmd/api/internal/svc"
"qnc-server/app/user/cmd/api/internal/types"
@@ -27,10 +28,11 @@ func NewQuerySingleTestLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Q
}
func (l *QuerySingleTestLogic) QuerySingleTest(req *types.QuerySingleTestReq) (resp *types.QuerySingleTestResp, err error) {
//featrueModel, err := l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, req.Api)
//if err != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 获取接口失败 : %d", err)
//}
_, err = l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, req.Api)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 获取接口失败 : %d", err)
}
marshalParams, err := json.Marshal(req.Params)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "单查测试, 序列化参数失败 : %d", err)

229
app/user/cmd/api/internal/service/apirequestService.go
View File

@@ -5,10 +5,6 @@ import (
"encoding/json"
"errors"
"fmt"
"github.com/Masterminds/squirrel"
"github.com/bytedance/sonic"
"github.com/tidwall/gjson"
"github.com/zeromicro/go-zero/core/logx"
"io"
"net/http"
"net/url"
@@ -20,6 +16,11 @@ import (
"sync"
"sync/atomic"
"time"
"github.com/Masterminds/squirrel"
"github.com/bytedance/sonic"
"github.com/tidwall/gjson"
"github.com/zeromicro/go-zero/core/logx"
)
type ApiRequestService struct {
@@ -201,6 +202,17 @@ var requestProcessors = map[string]func(*ApiRequestService, []byte) ([]byte, err
"G36SC01": (*ApiRequestService).ProcessG36SC01Request,
"G22SC01": (*ApiRequestService).ProcessG22SC01Request,
"Q03SC01": (*ApiRequestService).ProcessQ03SC01Request,
"COM187": (*ApiRequestService).ProcessCOM187Request,
"MOB035": (*ApiRequestService).ProcessMOB035Request,
"PCB915": (*ApiRequestService).ProcessPCB915Request,
"RIS031": (*ApiRequestService).ProcessRIS031Request,
"PCB601": (*ApiRequestService).ProcessPCB601Request,
"PCB148": (*ApiRequestService).ProcessPCB148Request,
"FIN011": (*ApiRequestService).ProcessFIN011Request,
"FIN020": (*ApiRequestService).ProcessFIN020Request,
"FIN018": (*ApiRequestService).ProcessFIN018Request,
"MOB032": (*ApiRequestService).ProcessMOB032Request,
"FIN032": (*ApiRequestService).ProcessFIN032Request,
}
// PreprocessRequestApi 调用指定的请求处理函数
@@ -1204,3 +1216,212 @@ func (a *ApiRequestService) ProcessQ03SC01Request(params []byte) ([]byte, error)
}
return marshal, nil
}
// 出境限制查询
func (a *ApiRequestService) ProcessCOM187Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
if !name.Exists() {
return nil, errors.New("api请求, COM187, 获取相关参数失败")
}
request := map[string]interface{}{
"keyword": name.String(),
}
resp, err := a.yushanService.request("COM187", request)
if err != nil {
return nil, fmt.Errorf("出境限制查询失败: %+v", err)
}
return resp, nil
}
// 手机月消费档次查询
func (a *ApiRequestService) ProcessMOB035Request(params []byte) ([]byte, error) {
mobile := gjson.GetBytes(params, "mobile")
if !mobile.Exists() {
return nil, errors.New("api请求, MOB035, 获取相关参数失败")
}
request := map[string]interface{}{
"mobile": mobile.String(),
}
resp, err := a.yushanService.request("MOB035", request)
if err != nil {
return nil, fmt.Errorf("手机月消费档次查询失败: %+v", err)
}
return resp, nil
}
// 学历信息验证
func (a *ApiRequestService) ProcessPCB915Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
certificateNumber := gjson.GetBytes(params, "certificate_number")
if !name.Exists() || !idCard.Exists() || !certificateNumber.Exists() {
return nil, errors.New("api请求, PCB915, 获取相关参数失败")
}
request := map[string]interface{}{
"name": name.String(),
"cardNo": idCard.String(),
"certificateNo": certificateNumber.String(),
}
resp, err := a.yushanService.request("PCB915", request)
if err != nil {
return nil, fmt.Errorf("学历信息验证失败: %+v", err)
}
return resp, nil
}
// 反诈反赌风险核验
func (a *ApiRequestService) ProcessRIS031Request(params []byte) ([]byte, error) {
keyword := gjson.GetBytes(params, "keyword")
typeName := gjson.GetBytes(params, "type")
if !keyword.Exists() || !typeName.Exists() {
return nil, errors.New("api请求, RIS031, 获取相关参数失败")
}
request := map[string]interface{}{
"keyWord": keyword.String(),
"type": typeName.Int(),
}
resp, err := a.yushanService.request("RIS031", request)
if err != nil {
return nil, fmt.Errorf("反诈反赌风险核验失败: %+v", err)
}
return resp, nil
}
// 手机号空号检测
func (a *ApiRequestService) ProcessPCB601Request(params []byte) ([]byte, error) {
mobile := gjson.GetBytes(params, "mobile")
if !mobile.Exists() {
return nil, errors.New("api请求, PCB601, 获取相关参数失败")
}
request := map[string]interface{}{
"mobile": mobile.String(),
}
resp, err := a.yushanService.request("PCB601", request)
if err != nil {
return nil, fmt.Errorf("手机号空号检测失败: %+v", err)
}
return resp, nil
}
// 银行卡归属地查询
func (a *ApiRequestService) ProcessPCB148Request(params []byte) ([]byte, error) {
bankCard := gjson.GetBytes(params, "bank_card")
if !bankCard.Exists() {
return nil, errors.New("api请求, PCB148, 获取相关参数失败")
}
request := map[string]interface{}{
"cardId": bankCard.String(),
}
resp, err := a.yushanService.request("PCB148", request)
if err != nil {
return nil, fmt.Errorf("银行卡归属地查询失败: %+v", err)
}
return resp, nil
}
// 银行卡姓名二要素验证
func (a *ApiRequestService) ProcessFIN011Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
bankCard := gjson.GetBytes(params, "bank_card")
if !name.Exists() || !bankCard.Exists() {
return nil, errors.New("api请求, FIN011, 获取相关参数失败")
}
request := map[string]interface{}{
"name": name.String(),
"cardId": bankCard.String(),
}
resp, err := a.yushanService.request("FIN011", request)
if err != nil {
return nil, fmt.Errorf("银行卡姓名二要素验证失败: %+v", err)
}
return resp, nil
}
// 银行卡号码二要素验证
func (a *ApiRequestService) ProcessFIN020Request(params []byte) ([]byte, error) {
idCard := gjson.GetBytes(params, "id_card")
bankCard := gjson.GetBytes(params, "bank_card")
if !idCard.Exists() || !bankCard.Exists() {
return nil, errors.New("api请求, FIN020, 获取相关参数失败")
}
request := map[string]interface{}{
"cardNo": idCard.String(),
"cardId": bankCard.String(),
}
resp, err := a.yushanService.request("FIN020", request)
if err != nil {
return nil, fmt.Errorf("银行卡号码二要素验证失败: %+v", err)
}
return resp, nil
}
// 银行卡三要素综合验证
func (a *ApiRequestService) ProcessFIN018Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
bankCard := gjson.GetBytes(params, "bank_card")
if !name.Exists() || !idCard.Exists() || !bankCard.Exists() {
return nil, errors.New("api请求, FIN018, 获取相关参数失败")
}
request := map[string]interface{}{
"name": name.String(),
"cardNo": idCard.String(),
"cardId": bankCard.String(),
}
resp, err := a.yushanService.request("FIN018", request)
if err != nil {
return nil, fmt.Errorf("银行卡三要素综合验证失败: %+v", err)
}
return resp, nil
}
// 手机号码风险评估
func (a *ApiRequestService) ProcessMOB032Request(params []byte) ([]byte, error) {
mobile := gjson.GetBytes(params, "mobile")
if !mobile.Exists() {
return nil, errors.New("api请求, MOB032, 获取相关参数失败")
}
request := map[string]interface{}{
"mobile": mobile.String(),
}
resp, err := a.yushanService.request("MOB032", request)
if err != nil {
return nil, fmt.Errorf("手机号码风险评估失败: %+v", err)
}
return resp, nil
}
// 手机号贩毒反诈风险查询
func (a *ApiRequestService) ProcessFIN032Request(params []byte) ([]byte, error) {
keyword := gjson.GetBytes(params, "keyword")
typeName := gjson.GetBytes(params, "type")
if !keyword.Exists() || !typeName.Exists() {
return nil, errors.New("api请求, FIN032, 获取相关参数失败")
}
request := map[string]interface{}{
"keyWord": keyword.String(),
"type": typeName.Int(),
}
resp, err := a.yushanService.request("FIN032", request)
if err != nil {
return nil, fmt.Errorf("手机号贩毒反诈风险查询失败: %+v", err)
}
return resp, nil
}

11
app/user/cmd/api/internal/svc/servicecontext.go
View File

@@ -1,15 +1,16 @@
package svc
import (
"qnc-server/app/user/cmd/api/internal/config"
"qnc-server/app/user/cmd/api/internal/middleware"
"qnc-server/app/user/cmd/api/internal/service"
"qnc-server/app/user/model"
"github.com/hibiken/asynq"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stores/redis"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/rest"
"qnc-server/app/user/cmd/api/internal/config"
"qnc-server/app/user/cmd/api/internal/middleware"
"qnc-server/app/user/cmd/api/internal/service"
"qnc-server/app/user/model"
)
type ServiceContext struct {
@@ -30,6 +31,7 @@ type ServiceContext struct {
AgentCommissionModel model.AgentCommissionModel
AgentWalletModel model.AgentWalletModel
GlobalNotificationsModel model.GlobalNotificationsModel
ExampleModel model.ExampleModel
AlipayService *service.AliPayService
WechatPayService *service.WechatPayService
ApplePayService *service.ApplePayService
@@ -82,6 +84,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
ProductRenderModel: model.NewProductRenderModel(db, c.CacheRedis),
OrderModel: model.NewOrderModel(db, c.CacheRedis),
QueryModel: model.NewQueryModel(db, c.CacheRedis),
ExampleModel: model.NewExampleModel(db, c.CacheRedis),
GlobalNotificationsModel: model.NewGlobalNotificationsModel(db, c.CacheRedis),
AgentModel: model.NewAgentModel(db, c.CacheRedis),
AgentAuditModel: model.NewAgentAuditModel(db, c.CacheRedis),

65
app/user/cmd/api/internal/types/query.go
View File

@@ -112,3 +112,68 @@ type TocPhoneSecondaryCard struct {
Mobile string `json:"mobile" validate:"required,mobile"`
StartDate string `json:"start_date" validate:"required"`
}
// 出境限制查询
type TocExitRestriction struct {
Name string `json:"name" validate:"required,name"`
}
// 手机月消费档次查询
type TocMonthlyMobileConsumptionLevel struct {
Mobile string `json:"mobile" validate:"required,mobile"`
}
// 学历信息验证
type TocEducationVerification struct {
Name string `json:"name" validate:"required,name"`
IDCard string `json:"id_card" validate:"required,idCard"`
CertificateNumber string `json:"certificate_number" validate:"required"`
}
// 反诈反赌风险核验
type TocFraudGamblingCheck struct {
Mobile string `json:"mobile,omitempty" validate:"omitempty,mobile"`
BankCard string `json:"bank_card,omitempty" validate:"omitempty,bankCard"`
IDCard string `json:"id_card,omitempty" validate:"omitempty,idCard"`
}
// 手机号反赌反诈风险查询
type TocMobileDrugFraudRiskCheck struct {
Mobile string `json:"mobile,omitempty" validate:"omitempty,mobile"`
BankCard string `json:"bank_card,omitempty" validate:"omitempty,bankCard"`
IDCard string `json:"id_card,omitempty" validate:"omitempty,idCard"`
}
// 手机号空号检测
type TocMobileNumberValidation struct {
Mobile string `json:"mobile" validate:"required,mobile"`
}
// 银行卡归属地查询
type TocBankCardLocation struct {
BankCard string `json:"bank_card" validate:"required"`
}
// 银行卡姓名二要素验证
type TocBankCardNameElementVerification struct {
Name string `json:"name" validate:"required,name"`
BankCard string `json:"bank_card" validate:"required"`
}
// 银行卡号码二要素验证
type TocBankCardIDElementVerification struct {
IDCard string `json:"id_card" validate:"required,idCard"`
BankCard string `json:"bank_card" validate:"required"`
}
// 银行卡三要素综合验证
type TocBankCardThreeElementsVerification struct {
Name string `json:"name" validate:"required,name"`
IDCard string `json:"id_card" validate:"required,idCard"`
BankCard string `json:"bank_card" validate:"required"`
}
// 手机号码风险评估
type TocMobileRiskAssessment struct {
Mobile string `json:"mobile" validate:"required,mobile"`
}