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

fix example and new feature

Browse Source
This commit is contained in:
liangzai
2025-04-22 02:11:56 +08:00
parent bb38af71c6
commit 25e60c48b9
13 changed files with 11242 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
app/user/cmd/api/internal/logic/query/querydetailbyorderidlogic.go
View File

@@ -232,7 +232,6 @@ func (l *QueryDetailByOrderIdLogic) UpdateFeatureAndProductFeature(productID int
if pf.FeatureId == feature.Id { // 确保和 Feature 关联
sort = int(pf.Sort)
break // 找到第一个符合条件的就退出循环
}
}
featureData = map[string]interface{}{

152
app/user/cmd/api/internal/logic/query/queryexamplelogic copy.go Normal file
View File

@@ -0,0 +1,152 @@
package query
// import (
// "context"
// "encoding/hex"
// "fmt"
// "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"
// )
// type QueryExampleLogic struct {
// logx.Logger
// ctx context.Context
// svcCtx *svc.ServiceContext
// }
// func NewQueryExampleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryExampleLogic {
// return &QueryExampleLogic{
// Logger: logx.WithContext(ctx),
// ctx: ctx,
// svcCtx: svcCtx,
// }
// }
// func (l *QueryExampleLogic) QueryExample(req *types.QueryExampleReq) (resp *types.QueryExampleResp, err error) {
// var exampleID int64
// switch req.Feature {
// case "backgroundcheck":
// exampleID = 508
// case "companyinfo":
// exampleID = 506
// case "homeservice":
// exampleID = 504
// case "marriage":
// exampleID = 501
// case "preloanbackgroundcheck":
// exampleID = 509
// case "rentalinfo":
// exampleID = 505
// case "riskassessment":
// exampleID = 503
// default:
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
// }
// queryModel, err := l.svcCtx.QueryModel.FindOne(l.ctx, exampleID)
// if err != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
// }
// var query types.Query
// query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
// query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
// // 解密查询数据
// secretKey := l.svcCtx.Config.Encrypt.SecretKey
// key, decodeErr := hex.DecodeString(secretKey)
// if decodeErr != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %v", err)
// }
// processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
// if processParamsErr != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告参数处理失败: %v", processParamsErr)
// }
// processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
// if processErr != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结果处理失败: %v", processErr)
// }
// updateFeatureAndProductFeatureErr := l.UpdateFeatureAndProductFeature(queryModel.ProductId, &query.QueryData)
// if updateFeatureAndProductFeatureErr != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", updateFeatureAndProductFeatureErr)
// }
// // 复制报告数据
// err = copier.Copy(&query, queryModel)
// if err != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结构体复制失败, %v", err)
// }
// product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
// if err != nil {
// return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取商品信息失败, %v", err)
// }
// query.ProductName = product.ProductName
// return &types.QueryExampleResp{
// Query: query,
// }, nil
// }
// func (l *QueryExampleLogic) UpdateFeatureAndProductFeature(productID int64, target *[]types.QueryItem) error {
// // 遍历 target 数组，使用倒序遍历，以便删除元素时不影响索引
// for i := len(*target) - 1; i >= 0; i-- {
// queryItem := &(*target)[i]
// // 确保 Data 为 map 类型
// data, ok := queryItem.Data.(map[string]interface{})
// if !ok {
// return fmt.Errorf("queryItem.Data 必须是 map[string]interface{} 类型")
// }
// // 从 Data 中获取 apiID
// apiID, ok := data["apiID"].(string)
// if !ok {
// return fmt.Errorf("queryItem.Data 中的 apiID 必须是字符串类型")
// }
// // 查询 Feature
// feature, err := l.svcCtx.FeatureModel.FindOneByApiId(l.ctx, apiID)
// if err != nil {
// // 如果 Feature 查不到，也要删除当前 QueryItem
// *target = append((*target)[:i], (*target)[i+1:]...)
// continue
// }
// // 查询 ProductFeatureModel
// builder := l.svcCtx.ProductFeatureModel.SelectBuilder().Where("product_id = ?", productID)
// productFeatures, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "")
// if err != nil {
// return fmt.Errorf("查询 ProductFeatureModel 错误: %v", err)
// }
// // 遍历 productFeatures，找到与 feature.ID 关联且 enable == 1 的项
// var featureData map[string]interface{}
// foundFeature := false
// for _, pf := range productFeatures {
// if pf.FeatureId == feature.Id { // 确保和 Feature 关联
// foundFeature = true
// if pf.Enable == 1 {
// featureData = map[string]interface{}{
// "featureName": feature.Name,
// "sort": pf.Sort,
// }
// break // 找到第一个符合条件的就退出循环
// }
// }
// }
// // 如果没有符合条件的 feature 或者 featureData 为空，则删除当前 queryItem
// if !foundFeature || featureData == nil {
// *target = append((*target)[:i], (*target)[i+1:]...)
// continue
// }
// // 更新 queryItem 的 Feature 字段（不是数组）
// queryItem.Feature = featureData
// }
// return nil
// }

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

@@ -3,12 +3,12 @@ package query
import (
"context"
"encoding/hex"
"fmt"
"qnc-server/app/user/cmd/api/internal/svc"
"qnc-server/app/user/cmd/api/internal/types"
"qnc-server/common/xerr"
"qnc-server/pkg/lzkit/crypto"
"github.com/jinzhu/copier"
"github.com/bytedance/sonic"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/logx"
@@ -29,67 +29,89 @@ 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 "backgroundcheck":
exampleID = 508
case "companyinfo":
exampleID = 506
case "homeservice":
exampleID = 504
case "marriage":
exampleID = 501
case "preloanbackgroundcheck":
exampleID = 509
case "rentalinfo":
exampleID = 505
case "riskassessment":
exampleID = 503
default:
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
}
queryModel, err := l.svcCtx.QueryModel.FindOne(l.ctx, exampleID)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "示例报告, 获取示例报告失败: %v", err)
}
var query types.Query
query.CreateTime = queryModel.CreateTime.Format("2006-01-02 15:04:05")
query.UpdateTime = queryModel.UpdateTime.Format("2006-01-02 15:04:05")
// 解密查询数据
secretKey := l.svcCtx.Config.Encrypt.SecretKey
key, decodeErr := hex.DecodeString(secretKey)
if decodeErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %v", err)
}
processParamsErr := ProcessQueryParams(queryModel.QueryParams, &query.QueryParams, key)
if processParamsErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告参数处理失败: %v", processParamsErr)
}
processErr := ProcessQueryData(queryModel.QueryData, &query.QueryData, key)
if processErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结果处理失败: %v", processErr)
}
updateFeatureAndProductFeatureErr := l.UpdateFeatureAndProductFeature(queryModel.ProductId, &query.QueryData)
if updateFeatureAndProductFeatureErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告查询, 报告结果处理失败: %v", updateFeatureAndProductFeatureErr)
}
// 复制报告数据
err = copier.Copy(&query, queryModel)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 报告结构体复制失败, %v", err)
}
product, err := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
// 根据产品特性标识获取产品信息
product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, req.Feature)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取商品信息失败, %v", err)
}
query.ProductName = product.ProductName
// 创建一个空的Query结构体来存储结果
query := types.Query{
ProductName: product.ProductName,
QueryData: make([]types.QueryItem, 0),
QueryParams: make(map[string]interface{}),
}
query.QueryParams = map[string]interface{}{
"id_card": "45000000000000000",
"mobile": "13700000000",
"name": "张老三",
}
// 查询ProductFeatureModel获取产品相关的功能列表
builder := l.svcCtx.ProductFeatureModel.SelectBuilder().Where("product_id = ?", product.Id)
productFeatures, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "")
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 查询 ProductFeatureModel 错误: %v", err)
}
// 从每个启用的特性获取示例数据并合并
for _, pf := range productFeatures {
if pf.Enable != 1 {
continue // 跳过未启用的特性
}
// 根据特性ID查找示例数据
example, err := l.svcCtx.ExampleModel.FindOneByFeatureId(l.ctx, pf.FeatureId)
if err != nil {
logx.Infof("示例报告, 特性ID %d 无示例数据: %v", pf.FeatureId, err)
continue // 如果没有示例数据就跳过
}
// 获取对应的Feature信息
feature, err := l.svcCtx.FeatureModel.FindOne(l.ctx, pf.FeatureId)
if err != nil {
logx.Infof("示例报告, 无法获取特性ID %d 的信息: %v", pf.FeatureId, err)
continue
}
var queryItem types.QueryItem
// 解密查询数据
secretKey := l.svcCtx.Config.Encrypt.SecretKey
key, decodeErr := hex.DecodeString(secretKey)
if decodeErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 获取AES解密解药失败, %v", err)
}
// 解析示例内容
if example.Content == "000" {
queryItem.Data = example.Content
} else {
// 解密数据
decryptedData, decryptErr := crypto.AesDecrypt(example.Content, key)
if decryptErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 解密数据失败: %v", decryptErr)
}
err = sonic.Unmarshal([]byte(decryptedData), &queryItem.Data)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "示例报告, 解析示例内容失败: %v", err)
}
}
// 添加特性信息
queryItem.Feature = map[string]interface{}{
"featureName": feature.Name,
"sort": pf.Sort,
}
// 添加到查询数据中
query.QueryData = append(query.QueryData, queryItem)
}
return &types.QueryExampleResp{
Query: query,
}, nil
}
func (l *QueryExampleLogic) UpdateFeatureAndProductFeature(productID int64, target *[]types.QueryItem) error {
// 如果有重复声明的问题，可能需要将这个函数移动到公共位置或者确认是否已存在
// 暂时保留，如果仍有问题可以考虑将其移到其他文件
/* func (l *QueryExampleLogic) UpdateFeatureAndProductFeature(productID int64, target *[]types.QueryItem) error {
// 遍历 target 数组，使用倒序遍历，以便删除元素时不影响索引
for i := len(*target) - 1; i >= 0; i-- {
queryItem := &(*target)[i]
@@ -149,4 +171,4 @@ func (l *QueryExampleLogic) UpdateFeatureAndProductFeature(productID int64, targ
}
return nil
}
} */

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

@@ -12,6 +12,7 @@ import (
"qnc-server/app/user/model"
"qnc-server/pkg/lzkit/crypto"
"qnc-server/pkg/lzkit/lzUtils"
"sort"
"strings"
"sync"
"sync/atomic"
@@ -197,6 +198,14 @@ var requestProcessors = map[string]func(*ApiRequestService, []byte) ([]byte, err
"G39SC02": (*ApiRequestService).ProcessG39SC02Request,
"G38SC02": (*ApiRequestService).ProcessG38SC02Request,
"layoutIdcard": (*ApiRequestService).ProcessLayoutIdcardRequest,
// New Feature
"PersonEnterprisePro": (*ApiRequestService).ProcessPersonEnterpriseProRequest,
"BehaviorRiskScan": (*ApiRequestService).ProcessBehaviorRiskScanRequest,
"G30BJ05": (*ApiRequestService).ProcessG30BJ05Request,
"G31BJ05": (*ApiRequestService).ProcessG31BJ05Request,
"G32BJ05": (*ApiRequestService).ProcessG32BJ05Request,
"RIS031": (*ApiRequestService).ProcessRIS031Request,
}
// PreprocessRequestApi 调用指定的请求处理函数
@@ -520,7 +529,6 @@ func (a *ApiRequestService) ProcessG05HZ01Request(params []byte) ([]byte, error)
// code 不等于 "0000"，返回错误
return nil, fmt.Errorf("响应code错误%s", code.String())
}
func (a *ApiRequestService) ProcessQ23SC01Request(params []byte) ([]byte, error) {
entName := gjson.GetBytes(params, "ent_name")
entCode := gjson.GetBytes(params, "ent_code")
@@ -1109,21 +1117,77 @@ func (a *ApiRequestService) ProcessQ03SC01Request(params []byte) ([]byte, error)
if callApiErr != nil {
return nil, callApiErr
}
// 第一步：提取外层的 data 字段
dataResult := gjson.GetBytes(resp, "data")
if !dataResult.Exists() {
return nil, fmt.Errorf("外层 data 字段不存在")
}
// 保留原有的递归解析和序列化逻辑
parseResult, err := lzUtils.RecursiveParse(dataResult.Raw)
if err != nil {
return nil, fmt.Errorf("递归反序列化")
}
logx.Infof("parseResult: %v", parseResult)
marshal, err := sonic.Marshal(parseResult)
if err != nil {
return nil, fmt.Errorf("序列化失败: %v", err)
}
return marshal, nil
// 第二步：使用gjson预处理数据
dataMap := make(map[string]interface{})
// 处理entout数据
entoutArray := gjson.GetBytes(marshal, "entout").Array()
if len(entoutArray) > 0 {
// 检查是否存在count字段来判断是否有数据
countField := entoutArray[0].Get("data.count")
if countField.Exists() {
// 有count字段，表示有数据
entoutData := entoutArray[0].Get("data")
if entoutData.Exists() {
dataMap["data"] = json.RawMessage(entoutData.Raw)
}
} else {
// 没有count字段，使用空对象
dataMap["data"] = json.RawMessage("{}")
}
} else {
dataMap["data"] = json.RawMessage("{}")
}
// 处理sxbzxr数据(失信被执行人)
sxbzxrArray := dataResult.Get("sxbzxr").Array()
if len(sxbzxrArray) > 0 {
sxbzxrList := sxbzxrArray[0].Get("sxbzxr")
if sxbzxrList.Exists() && len(sxbzxrList.Array()) > 0 {
dataMap["sxbzxr"] = json.RawMessage(sxbzxrList.Raw)
} else {
dataMap["sxbzxr"] = json.RawMessage("[]")
}
} else {
dataMap["sxbzxr"] = json.RawMessage("[]")
}
// 处理xgbzxr数据(限高被执行人)
xgbzxrArray := dataResult.Get("xgbzxr").Array()
if len(xgbzxrArray) > 0 {
xgbzxrList := xgbzxrArray[0].Get("xgbzxr")
if xgbzxrList.Exists() && len(xgbzxrList.Array()) > 0 {
dataMap["xgbzxr"] = json.RawMessage(xgbzxrList.Raw)
} else {
dataMap["xgbzxr"] = json.RawMessage("[]")
}
} else {
dataMap["xgbzxr"] = json.RawMessage("[]")
}
result, err := sonic.Marshal(dataMap)
if err != nil {
return nil, fmt.Errorf("序列化预处理数据失败: %v", err)
}
return result, nil
}
// G39SC02 职业资格证书核验
@@ -1210,3 +1274,579 @@ func (a *ApiRequestService) ProcessLayoutIdcardRequest(params []byte) ([]byte, e
}
return []byte(firstChar), nil
}
// PersonEnterprisePro 人企业关系加强版
func (a *ApiRequestService) ProcessPersonEnterpriseProRequest(params []byte) ([]byte, error) {
idCard := gjson.GetBytes(params, "id_card")
// 设置最大调用次数上限
maxApiCalls := 20 // 允许最多查询20个企业
if !idCard.Exists() {
return nil, errors.New("api请求, PersonEnterprisePro, 获取相关参数失败")
}
request := map[string]interface{}{
"pid": crypto.Md5Encrypt(idCard.String()),
}
resp, callApiErr := a.westDexService.G05HZ01CallAPI("G05HZ01", request)
if callApiErr != nil {
return nil, callApiErr
}
// 处理股东人企关系的响应数据
code := gjson.GetBytes(resp, "code")
if !code.Exists() {
return nil, fmt.Errorf("响应中缺少 code 字段")
}
// 判断 code 是否等于 "0000"
if code.String() == "0000" {
// 获取 data 字段的值
data := gjson.GetBytes(resp, "data")
if !data.Exists() {
return nil, fmt.Errorf("响应中缺少 data 字段")
}
// 使用gjson获取企业列表
datalistResult := gjson.Get(data.Raw, "datalist")
if !datalistResult.Exists() {
return nil, fmt.Errorf("datalist字段不存在")
}
// 获取所有企业并进行排序
companies := datalistResult.Array()
// 创建企业对象切片，用于排序
type CompanyWithPriority struct {
Index int
Data gjson.Result
RelationshipVal int // 关系权重值
RelationCount int // 关系数量
AdminPenalty int // 行政处罚数量
Executed int // 被执行人数量
Dishonest int // 失信被执行人数量
}
companiesWithPriority := make([]CompanyWithPriority, 0, len(companies))
// 遍历企业，计算优先级
for i, companyJson := range companies {
// 统计行政处罚、被执行人、失信被执行人
adminPenalty := 0
executed := 0
dishonest := 0
// 检查行政处罚字段是否存在并获取数组长度
adminPenaltyResult := companyJson.Get("adminPenalty")
if adminPenaltyResult.Exists() && adminPenaltyResult.IsArray() {
adminPenalty = len(adminPenaltyResult.Array())
}
// 检查被执行人字段是否存在并获取数组长度
executedPersonResult := companyJson.Get("executedPerson")
if executedPersonResult.Exists() && executedPersonResult.IsArray() {
executed = len(executedPersonResult.Array())
}
// 检查失信被执行人字段是否存在并获取数组长度
dishonestExecutedPersonResult := companyJson.Get("dishonestExecutedPerson")
if dishonestExecutedPersonResult.Exists() && dishonestExecutedPersonResult.IsArray() {
dishonest = len(dishonestExecutedPersonResult.Array())
}
// 计算relationship权重
relationshipVal := 0
relationCount := 0
// 获取relationship数组
relationshipResult := companyJson.Get("relationship")
if relationshipResult.Exists() && relationshipResult.IsArray() {
relationships := relationshipResult.Array()
// 统计各类关系的数量和权重
for _, rel := range relationships {
relationCount++
relStr := rel.String()
// 根据关系类型设置权重，权重顺序：
// 股东(6) > 历史股东(5) > 法人(4) > 历史法人(3) > 高管(2) > 历史高管(1)
switch relStr {
case "sh": // 股东
if relationshipVal < 6 {
relationshipVal = 6
}
case "his_sh": // 历史股东
if relationshipVal < 5 {
relationshipVal = 5
}
case "lp": // 法人
if relationshipVal < 4 {
relationshipVal = 4
}
case "his_lp": // 历史法人
if relationshipVal < 3 {
relationshipVal = 3
}
case "tm": // 高管
if relationshipVal < 2 {
relationshipVal = 2
}
case "his_tm": // 历史高管
if relationshipVal < 1 {
relationshipVal = 1
}
}
}
}
companiesWithPriority = append(companiesWithPriority, CompanyWithPriority{
Index: i,
Data: companyJson,
RelationshipVal: relationshipVal,
RelationCount: relationCount,
AdminPenalty: adminPenalty,
Executed: executed,
Dishonest: dishonest,
})
}
// 按优先级排序
sort.Slice(companiesWithPriority, func(i, j int) bool {
// 首先根据是否有失信被执行人排序
if companiesWithPriority[i].Dishonest != companiesWithPriority[j].Dishonest {
return companiesWithPriority[i].Dishonest > companiesWithPriority[j].Dishonest
}
// 然后根据是否有被执行人排序
if companiesWithPriority[i].Executed != companiesWithPriority[j].Executed {
return companiesWithPriority[i].Executed > companiesWithPriority[j].Executed
}
// 然后根据是否有行政处罚排序
if companiesWithPriority[i].AdminPenalty != companiesWithPriority[j].AdminPenalty {
return companiesWithPriority[i].AdminPenalty > companiesWithPriority[j].AdminPenalty
}
// 然后按relationship类型排序
if companiesWithPriority[i].RelationshipVal != companiesWithPriority[j].RelationshipVal {
return companiesWithPriority[i].RelationshipVal > companiesWithPriority[j].RelationshipVal
}
// 最后按relationship数量排序
return companiesWithPriority[i].RelationCount > companiesWithPriority[j].RelationCount
})
// 限制处理的企业数量
processCount := len(companiesWithPriority)
if processCount > maxApiCalls {
processCount = maxApiCalls
}
// 只处理前N个优先级高的企业
prioritizedCompanies := companiesWithPriority[:processCount]
// 使用WaitGroup和chan处理并发
var wg sync.WaitGroup
results := make(chan struct {
index int
data []byte
err error
}, processCount)
// 对按优先级排序的前N个企业进行涉诉信息查询
for _, company := range prioritizedCompanies {
wg.Add(1)
go func(origIndex int, companyInfo gjson.Result) {
defer wg.Done()
logx.Infof("开始处理企业[%d]，企业名称: %s，统一社会信用代码: %s", origIndex, companyInfo.Get("basicInfo.name").String(), companyInfo.Get("basicInfo.creditCode").String())
// 提取企业名称和统一社会信用代码
orgName := companyInfo.Get("basicInfo.name")
creditCode := companyInfo.Get("basicInfo.creditCode")
if !orgName.Exists() || !creditCode.Exists() {
results <- struct {
index int
data []byte
err error
}{origIndex, nil, fmt.Errorf("企业名称或统一社会信用代码不存在")}
return
}
// 解析原始公司信息为map
var companyMap map[string]interface{}
if err := json.Unmarshal([]byte(companyInfo.Raw), &companyMap); err != nil {
results <- struct {
index int
data []byte
err error
}{origIndex, nil, fmt.Errorf("解析企业信息失败: %v", err)}
return
}
// 构造调用Q03SC01的参数
q03Params, err := json.Marshal(map[string]string{
"ent_name": orgName.String(),
"ent_code": creditCode.String(),
})
if err != nil {
// 参数构造失败，但不影响整体处理
logx.Errorf("构造企业[%s]涉诉查询参数失败: %v", orgName.String(), err)
companyMap["lawsuitInfo"] = map[string]interface{}{}
} else {
// 调用Q03SC01接口获取企业涉诉信息
lawsuitData, err := a.ProcessQ03SC01Request(q03Params)
// 无论是否有错误，都继续处理
if err != nil {
// 可能是正常没有涉诉数据，设置为空对象
logx.Infof("企业[%s]涉诉信息查询结果: %v", orgName.String(), err)
companyMap["lawsuitInfo"] = map[string]interface{}{}
} else if len(lawsuitData) == 0 || string(lawsuitData) == "{}" || string(lawsuitData) == "null" {
// 无涉诉数据
companyMap["lawsuitInfo"] = map[string]interface{}{}
} else {
// 解析涉诉信息
var lawsuitInfo interface{}
if err := json.Unmarshal(lawsuitData, &lawsuitInfo); err != nil {
logx.Errorf("解析企业[%s]涉诉信息失败: %v", orgName.String(), err)
companyMap["lawsuitInfo"] = map[string]interface{}{}
} else {
// 添加涉诉信息到企业信息中
companyMap["lawsuitInfo"] = lawsuitInfo
}
}
}
// 序列化更新后的企业信息
companyData, err := json.Marshal(companyMap)
if err != nil {
results <- struct {
index int
data []byte
err error
}{origIndex, nil, fmt.Errorf("序列化企业信息失败: %v", err)}
return
}
results <- struct {
index int
data []byte
err error
}{origIndex, companyData, nil}
}(company.Index, company.Data)
}
// 关闭结果通道
go func() {
wg.Wait()
close(results)
}()
// 解析原始数据为map
var dataMap map[string]interface{}
if err := json.Unmarshal([]byte(data.Raw), &dataMap); err != nil {
return nil, fmt.Errorf("解析data字段失败: %v", err)
}
// 获取原始企业列表
originalDatalist, ok := dataMap["datalist"].([]interface{})
if !ok {
return nil, fmt.Errorf("无法获取原始企业列表")
}
// 创建结果映射，用于保存已处理的企业
processedCompanies := make(map[int]interface{})
// 收集处理过的企业数据
for result := range results {
if result.err != nil {
logx.Errorf("处理企业失败: %v", result.err)
continue
}
if result.data != nil {
var companyMap interface{}
if err := json.Unmarshal(result.data, &companyMap); err == nil {
processedCompanies[result.index] = companyMap
}
}
}
// 更新企业列表
// 处理过的用新数据，未处理的保留原样
updatedDatalist := make([]interface{}, len(originalDatalist))
for i, company := range originalDatalist {
if processed, exists := processedCompanies[i]; exists {
// 已处理的企业，使用新数据
updatedDatalist[i] = processed
} else {
// 未处理的企业，保留原始数据并添加空的涉诉信息
companyMap, ok := company.(map[string]interface{})
if ok {
// 为未处理的企业添加空的涉诉信息
companyMap["lawsuitInfo"] = map[string]interface{}{}
updatedDatalist[i] = companyMap
} else {
updatedDatalist[i] = company
}
}
}
// 更新原始数据中的企业列表
dataMap["datalist"] = updatedDatalist
// 序列化最终结果
result, err := json.Marshal(dataMap)
if err != nil {
return nil, fmt.Errorf("序列化最终结果失败: %v", err)
}
return result, nil
}
// code不等于"0000"，返回错误
return nil, fmt.Errorf("响应code错误: %s", code.String())
}
func (a *ApiRequestService) ProcessBehaviorRiskScanRequest(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
mobile := gjson.GetBytes(params, "mobile")
if !name.Exists() || !idCard.Exists() || !mobile.Exists() {
return nil, errors.New("api请求, BehaviorRiskScan, 获取相关参数失败")
}
var wg sync.WaitGroup
type apiResult struct {
name string
data []byte
err error
}
results := make(chan apiResult, 5) // 5个风险检测项
// 并行调用五个不同的风险检测API
wg.Add(4)
// 黑灰产检测
go func() {
defer wg.Done()
data, err := a.ProcessG30BJ05Request(params)
results <- apiResult{name: "black_gray_level", data: data, err: err}
}()
// 电诈风险预警
go func() {
defer wg.Done()
data, err := a.ProcessG31BJ05Request(params)
results <- apiResult{name: "telefraud_level", data: data, err: err}
}()
// 团伙欺诈排查
go func() {
defer wg.Done()
data, err := a.ProcessG32BJ05Request(params)
results <- apiResult{name: "fraud_group", data: data, err: err}
}()
// // 反诈反赌核验
go func() {
defer wg.Done()
data, err := a.ProcessRIS031Request(params)
results <- apiResult{name: "anti_fraud_gaming", data: data, err: err}
}()
// 风险等级
go func() {
defer wg.Done()
data, err := a.ProcessG34BJ03Request(params)
results <- apiResult{name: "risk_level", data: data, err: err}
}()
// 关闭结果通道
go func() {
wg.Wait()
close(results)
}()
// 收集所有结果
resultMap := make(map[string]interface{})
var errors []string
for result := range results {
if result.err != nil {
// 记录错误但继续处理其他结果
errors = append(errors, fmt.Sprintf("%s: %v", result.name, result.err))
continue
}
// 解析JSON结果并添加到结果映射
var parsedData interface{}
if err := json.Unmarshal(result.data, &parsedData); err != nil {
errors = append(errors, fmt.Sprintf("解析%s数据失败: %v", result.name, err))
} else {
resultMap[result.name] = parsedData
}
}
// 添加错误信息到结果中(如果存在)
if len(errors) > 0 {
resultMap["errors"] = errors
}
// 序列化最终结果
finalResult, err := json.Marshal(resultMap)
if err != nil {
return nil, fmt.Errorf("序列化行为风险扫描结果失败: %v", err)
}
return finalResult, nil
}
// G30BJ05 黑灰产
func (a *ApiRequestService) ProcessG30BJ05Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
Mobile := gjson.GetBytes(params, "mobile")
if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
return nil, errors.New("api请求, G30BJ05, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"name": a.westDexService.Encrypt(name.String()),
"id": a.westDexService.Encrypt(idCard.String()),
"cell": a.westDexService.Encrypt(Mobile.String()),
},
}
resp, callApiErr := a.westDexService.CallAPI("G30BJ05", request)
if callApiErr != nil {
return nil, callApiErr
}
fmt.Println(resp)
flagBlackgraylevel := gjson.GetBytes(resp, "flag_blackgraylevel")
if !flagBlackgraylevel.Exists() || flagBlackgraylevel.String() != "1" {
return nil, fmt.Errorf("自然人黑灰产信息查询失败")
}
bglLevel := gjson.GetBytes(resp, "bgl_level")
if !bglLevel.Exists() {
return nil, fmt.Errorf("bgl_level 字段不存在")
}
return []byte(bglLevel.Raw), nil
}
// G31BJ05 电诈风险预警
func (a *ApiRequestService) ProcessG31BJ05Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
Mobile := gjson.GetBytes(params, "mobile")
if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
return nil, errors.New("api请求, G31BJ05, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"name": a.westDexService.Encrypt(name.String()),
"id": a.westDexService.Encrypt(idCard.String()),
"cell": a.westDexService.Encrypt(Mobile.String()),
},
}
resp, callApiErr := a.westDexService.CallAPI("G31BJ05", request)
if callApiErr != nil {
return nil, callApiErr
}
fmt.Println(resp)
flagTelefraudpredictstd := gjson.GetBytes(resp, "flag_telefraudpredictstd")
if !flagTelefraudpredictstd.Exists() || flagTelefraudpredictstd.String() != "1" {
return nil, fmt.Errorf("自然人电诈风险预警查询失败")
}
tfpsLevel := gjson.GetBytes(resp, "tfps_level")
if !tfpsLevel.Exists() {
return nil, fmt.Errorf("tfps_level 字段不存在")
}
return []byte(tfpsLevel.Raw), nil
}
// G32BJ05 团伙欺诈排查
func (a *ApiRequestService) ProcessG32BJ05Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
Mobile := gjson.GetBytes(params, "mobile")
if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
return nil, errors.New("api请求, G32BJ05, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"name": a.westDexService.Encrypt(name.String()),
"id": a.westDexService.Encrypt(idCard.String()),
"cell": a.westDexService.Encrypt(Mobile.String()),
},
}
resp, callApiErr := a.westDexService.CallAPI("G32BJ05", request)
if callApiErr != nil {
return nil, callApiErr
}
flagFraudrelation := gjson.GetBytes(resp, "flag_fraudrelation")
if !flagFraudrelation.Exists() || flagFraudrelation.String() != "1" {
return nil, fmt.Errorf("自然人团伙欺诈排查查询失败")
}
frgListLevel := gjson.GetBytes(resp, "frg_list_level")
if !frgListLevel.Exists() {
return nil, fmt.Errorf("frg_list_level 字段不存在")
}
frgGroupNum := gjson.GetBytes(resp, "frg_group_num")
if !frgGroupNum.Exists() {
return nil, fmt.Errorf("frg_group_num 字段不存在")
}
// 构建包含两个字段的JSON响应
result := map[string]interface{}{
"frg_list_level": frgListLevel.Value(),
"frg_group_num": frgGroupNum.Value(),
}
resultJSON, err := json.Marshal(result)
if err != nil {
return nil, fmt.Errorf("序列化结果失败: %v", err)
}
return resultJSON, nil
}
// RIS031 反诈反赌核验
func (a *ApiRequestService) ProcessRIS031Request(params []byte) ([]byte, error) {
name := gjson.GetBytes(params, "name")
idCard := gjson.GetBytes(params, "id_card")
Mobile := gjson.GetBytes(params, "mobile")
if !name.Exists() || !idCard.Exists() || !Mobile.Exists() {
return nil, errors.New("api请求, RIS031, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"name": a.westDexService.Encrypt(name.String()),
"id": a.westDexService.Encrypt(idCard.String()),
"cell": a.westDexService.Encrypt(Mobile.String()),
},
}
resp, callApiErr := a.yushanService.request("RIS031", request)
if callApiErr != nil {
return nil, callApiErr
}
Value := gjson.GetBytes(resp, "value")
if !Value.Exists() {
return nil, fmt.Errorf("自然人反诈反赌核验查询失败")
}
return []byte(Value.Raw), nil
}

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

@@ -40,6 +40,7 @@ type ServiceContext struct {
AgentPlatformDeductionModel model.AgentPlatformDeductionModel
AgentActiveStatModel model.AgentActiveStatModel
AgentWithdrawalModel model.AgentWithdrawalModel
ExampleModel model.ExampleModel
GlobalNotificationsModel model.GlobalNotificationsModel
AlipayService *service.AliPayService
WechatPayService *service.WechatPayService
@@ -101,6 +102,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
agentPlatformDeductionModel := model.NewAgentPlatformDeductionModel(db, c.CacheRedis)
agentActiveStatModel := model.NewAgentActiveStatModel(db, c.CacheRedis)
agentWithdrawalModel := model.NewAgentWithdrawalModel(db, c.CacheRedis)
exampleModel := model.NewExampleModel(db, c.CacheRedis)
alipayService := service.NewAliPayService(c)
wechatPayService := service.NewWechatPayService(c, userAuthModel)
@@ -150,6 +152,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
AgentPlatformDeductionModel: agentPlatformDeductionModel,
AgentActiveStatModel: agentActiveStatModel,
AgentWithdrawalModel: agentWithdrawalModel,
ExampleModel: exampleModel,
}
}

27
app/user/model/exampleModel.go Normal file
View File

@@ -0,0 +1,27 @@
package model
import (
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
var _ ExampleModel = (*customExampleModel)(nil)
type (
// ExampleModel is an interface to be customized, add more methods here,
// and implement the added methods in customExampleModel.
ExampleModel interface {
exampleModel
}
customExampleModel struct {
*defaultExampleModel
}
)
// NewExampleModel returns a model for the database table.
func NewExampleModel(conn sqlx.SqlConn, c cache.CacheConf) ExampleModel {
return &customExampleModel{
defaultExampleModel: newExampleModel(conn, c),
}
}

434
app/user/model/exampleModel_gen.go Normal file
View File

@@ -0,0 +1,434 @@
// Code generated by goctl. DO NOT EDIT!
package model
import (
"context"
"database/sql"
"fmt"
"strings"
"time"
"github.com/Masterminds/squirrel"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/stores/builder"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/sqlc"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/core/stringx"
"qnc-server/common/globalkey"
)
var (
exampleFieldNames = builder.RawFieldNames(&Example{})
exampleRows = strings.Join(exampleFieldNames, ",")
exampleRowsExpectAutoSet = strings.Join(stringx.Remove(exampleFieldNames, "`id`", "`create_time`", "`update_time`"), ",")
exampleRowsWithPlaceHolder = strings.Join(stringx.Remove(exampleFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
cacheQncExampleIdPrefix = "cache:qnc:example:id:"
cacheQncExampleApiIdPrefix = "cache:qnc:example:apiId:"
cacheQncExampleFeatureIdPrefix = "cache:qnc:example:featureId:"
)
type (
exampleModel interface {
Insert(ctx context.Context, session sqlx.Session, data *Example) (sql.Result, error)
FindOne(ctx context.Context, id int64) (*Example, error)
FindOneByApiId(ctx context.Context, apiId string) (*Example, error)
FindOneByFeatureId(ctx context.Context, featureId int64) (*Example, error)
Update(ctx context.Context, session sqlx.Session, data *Example) (sql.Result, error)
UpdateWithVersion(ctx context.Context, session sqlx.Session, data *Example) error
Trans(ctx context.Context, fn func(context context.Context, session sqlx.Session) error) error
SelectBuilder() squirrel.SelectBuilder
DeleteSoft(ctx context.Context, session sqlx.Session, data *Example) error
FindSum(ctx context.Context, sumBuilder squirrel.SelectBuilder, field string) (float64, error)
FindCount(ctx context.Context, countBuilder squirrel.SelectBuilder, field string) (int64, error)
FindAll(ctx context.Context, rowBuilder squirrel.SelectBuilder, orderBy string) ([]*Example, error)
FindPageListByPage(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*Example, error)
FindPageListByPageWithTotal(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*Example, int64, error)
FindPageListByIdDESC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*Example, error)
FindPageListByIdASC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*Example, error)
Delete(ctx context.Context, session sqlx.Session, id int64) error
}
defaultExampleModel struct {
sqlc.CachedConn
table string
}
Example struct {
Id int64 `db:"id"` // 主键ID
CreateTime time.Time `db:"create_time"` // 创建时间
UpdateTime time.Time `db:"update_time"` // 更新时间
DeleteTime sql.NullTime `db:"delete_time"` // 删除时间
DelState int64 `db:"del_state"` // 删除状态
Version int64 `db:"version"` // 版本号
ApiId string `db:"api_id"` // API标识
FeatureId int64 `db:"feature_id"` // 关联feature表的ID
Content string `db:"content"` // 内容
}
)
func newExampleModel(conn sqlx.SqlConn, c cache.CacheConf) *defaultExampleModel {
return &defaultExampleModel{
CachedConn: sqlc.NewConn(conn, c),
table: "`example`",
}
}
func (m *defaultExampleModel) Insert(ctx context.Context, session sqlx.Session, data *Example) (sql.Result, error) {
data.DelState = globalkey.DelStateNo
qncExampleApiIdKey := fmt.Sprintf("%s%v", cacheQncExampleApiIdPrefix, data.ApiId)
qncExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheQncExampleFeatureIdPrefix, data.FeatureId)
qncExampleIdKey := fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, data.Id)
return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?)", m.table, exampleRowsExpectAutoSet)
if session != nil {
return session.ExecCtx(ctx, query, data.DeleteTime, data.DelState, data.Version, data.ApiId, data.FeatureId, data.Content)
}
return conn.ExecCtx(ctx, query, data.DeleteTime, data.DelState, data.Version, data.ApiId, data.FeatureId, data.Content)
}, qncExampleApiIdKey, qncExampleFeatureIdKey, qncExampleIdKey)
}
func (m *defaultExampleModel) FindOne(ctx context.Context, id int64) (*Example, error) {
qncExampleIdKey := fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, id)
var resp Example
err := m.QueryRowCtx(ctx, &resp, qncExampleIdKey, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error {
query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", exampleRows, m.table)
return conn.QueryRowCtx(ctx, v, query, id, globalkey.DelStateNo)
})
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultExampleModel) FindOneByApiId(ctx context.Context, apiId string) (*Example, error) {
qncExampleApiIdKey := fmt.Sprintf("%s%v", cacheQncExampleApiIdPrefix, apiId)
var resp Example
err := m.QueryRowIndexCtx(ctx, &resp, qncExampleApiIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
query := fmt.Sprintf("select %s from %s where `api_id` = ? and del_state = ? limit 1", exampleRows, m.table)
if err := conn.QueryRowCtx(ctx, &resp, query, apiId, globalkey.DelStateNo); err != nil {
return nil, err
}
return resp.Id, nil
}, m.queryPrimary)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultExampleModel) FindOneByFeatureId(ctx context.Context, featureId int64) (*Example, error) {
qncExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheQncExampleFeatureIdPrefix, featureId)
var resp Example
err := m.QueryRowIndexCtx(ctx, &resp, qncExampleFeatureIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
query := fmt.Sprintf("select %s from %s where `feature_id` = ? and del_state = ? limit 1", exampleRows, m.table)
if err := conn.QueryRowCtx(ctx, &resp, query, featureId, globalkey.DelStateNo); err != nil {
return nil, err
}
return resp.Id, nil
}, m.queryPrimary)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultExampleModel) Update(ctx context.Context, session sqlx.Session, newData *Example) (sql.Result, error) {
data, err := m.FindOne(ctx, newData.Id)
if err != nil {
return nil, err
}
qncExampleApiIdKey := fmt.Sprintf("%s%v", cacheQncExampleApiIdPrefix, data.ApiId)
qncExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheQncExampleFeatureIdPrefix, data.FeatureId)
qncExampleIdKey := fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, data.Id)
return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, exampleRowsWithPlaceHolder)
if session != nil {
return session.ExecCtx(ctx, query, newData.DeleteTime, newData.DelState, newData.Version, newData.ApiId, newData.FeatureId, newData.Content, newData.Id)
}
return conn.ExecCtx(ctx, query, newData.DeleteTime, newData.DelState, newData.Version, newData.ApiId, newData.FeatureId, newData.Content, newData.Id)
}, qncExampleApiIdKey, qncExampleFeatureIdKey, qncExampleIdKey)
}
func (m *defaultExampleModel) UpdateWithVersion(ctx context.Context, session sqlx.Session, newData *Example) error {
oldVersion := newData.Version
newData.Version += 1
var sqlResult sql.Result
var err error
data, err := m.FindOne(ctx, newData.Id)
if err != nil {
return err
}
qncExampleApiIdKey := fmt.Sprintf("%s%v", cacheQncExampleApiIdPrefix, data.ApiId)
qncExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheQncExampleFeatureIdPrefix, data.FeatureId)
qncExampleIdKey := fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, data.Id)
sqlResult, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, exampleRowsWithPlaceHolder)
if session != nil {
return session.ExecCtx(ctx, query, newData.DeleteTime, newData.DelState, newData.Version, newData.ApiId, newData.FeatureId, newData.Content, newData.Id, oldVersion)
}
return conn.ExecCtx(ctx, query, newData.DeleteTime, newData.DelState, newData.Version, newData.ApiId, newData.FeatureId, newData.Content, newData.Id, oldVersion)
}, qncExampleApiIdKey, qncExampleFeatureIdKey, qncExampleIdKey)
if err != nil {
return err
}
updateCount, err := sqlResult.RowsAffected()
if err != nil {
return err
}
if updateCount == 0 {
return ErrNoRowsUpdate
}
return nil
}
func (m *defaultExampleModel) DeleteSoft(ctx context.Context, session sqlx.Session, data *Example) error {
data.DelState = globalkey.DelStateYes
data.DeleteTime = sql.NullTime{Time: time.Now(), Valid: true}
if err := m.UpdateWithVersion(ctx, session, data); err != nil {
return errors.Wrapf(errors.New("delete soft failed "), "ExampleModel delete err : %+v", err)
}
return nil
}
func (m *defaultExampleModel) FindSum(ctx context.Context, builder squirrel.SelectBuilder, field string) (float64, error) {
if len(field) == 0 {
return 0, errors.Wrapf(errors.New("FindSum Least One Field"), "FindSum Least One Field")
}
builder = builder.Columns("IFNULL(SUM(" + field + "),0)")
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql()
if err != nil {
return 0, err
}
var resp float64
err = m.QueryRowNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return 0, err
}
}
func (m *defaultExampleModel) FindCount(ctx context.Context, builder squirrel.SelectBuilder, field string) (int64, error) {
if len(field) == 0 {
return 0, errors.Wrapf(errors.New("FindCount Least One Field"), "FindCount Least One Field")
}
builder = builder.Columns("COUNT(" + field + ")")
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql()
if err != nil {
return 0, err
}
var resp int64
err = m.QueryRowNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return 0, err
}
}
func (m *defaultExampleModel) FindAll(ctx context.Context, builder squirrel.SelectBuilder, orderBy string) ([]*Example, error) {
builder = builder.Columns(exampleRows)
if orderBy == "" {
builder = builder.OrderBy("id DESC")
} else {
builder = builder.OrderBy(orderBy)
}
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql()
if err != nil {
return nil, err
}
var resp []*Example
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultExampleModel) FindPageListByPage(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*Example, error) {
builder = builder.Columns(exampleRows)
if orderBy == "" {
builder = builder.OrderBy("id DESC")
} else {
builder = builder.OrderBy(orderBy)
}
if page < 1 {
page = 1
}
offset := (page - 1) * pageSize
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).Offset(uint64(offset)).Limit(uint64(pageSize)).ToSql()
if err != nil {
return nil, err
}
var resp []*Example
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultExampleModel) FindPageListByPageWithTotal(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*Example, int64, error) {
total, err := m.FindCount(ctx, builder, "id")
if err != nil {
return nil, 0, err
}
builder = builder.Columns(exampleRows)
if orderBy == "" {
builder = builder.OrderBy("id DESC")
} else {
builder = builder.OrderBy(orderBy)
}
if page < 1 {
page = 1
}
offset := (page - 1) * pageSize
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).Offset(uint64(offset)).Limit(uint64(pageSize)).ToSql()
if err != nil {
return nil, total, err
}
var resp []*Example
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, total, nil
default:
return nil, total, err
}
}
func (m *defaultExampleModel) FindPageListByIdDESC(ctx context.Context, builder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*Example, error) {
builder = builder.Columns(exampleRows)
if preMinId > 0 {
builder = builder.Where(" id < ? ", preMinId)
}
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).OrderBy("id DESC").Limit(uint64(pageSize)).ToSql()
if err != nil {
return nil, err
}
var resp []*Example
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultExampleModel) FindPageListByIdASC(ctx context.Context, builder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*Example, error) {
builder = builder.Columns(exampleRows)
if preMaxId > 0 {
builder = builder.Where(" id > ? ", preMaxId)
}
query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).OrderBy("id ASC").Limit(uint64(pageSize)).ToSql()
if err != nil {
return nil, err
}
var resp []*Example
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultExampleModel) Trans(ctx context.Context, fn func(ctx context.Context, session sqlx.Session) error) error {
return m.TransactCtx(ctx, func(ctx context.Context, session sqlx.Session) error {
return fn(ctx, session)
})
}
func (m *defaultExampleModel) SelectBuilder() squirrel.SelectBuilder {
return squirrel.Select().From(m.table)
}
func (m *defaultExampleModel) Delete(ctx context.Context, session sqlx.Session, id int64) error {
data, err := m.FindOne(ctx, id)
if err != nil {
return err
}
qncExampleApiIdKey := fmt.Sprintf("%s%v", cacheQncExampleApiIdPrefix, data.ApiId)
qncExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheQncExampleFeatureIdPrefix, data.FeatureId)
qncExampleIdKey := fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, id)
_, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
if session != nil {
return session.ExecCtx(ctx, query, id)
}
return conn.ExecCtx(ctx, query, id)
}, qncExampleApiIdKey, qncExampleFeatureIdKey, qncExampleIdKey)
return err
}
func (m *defaultExampleModel) formatPrimary(primary interface{}) string {
return fmt.Sprintf("%s%v", cacheQncExampleIdPrefix, primary)
}
func (m *defaultExampleModel) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary interface{}) error {
query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", exampleRows, m.table)
return conn.QueryRowCtx(ctx, v, query, primary, globalkey.DelStateNo)
}
func (m *defaultExampleModel) tableName() string {
return m.table
}

3
deploy/script/gen_models.ps1
View File

@@ -15,7 +15,7 @@ $tables = @(
# "agent_commission_deduction",
# "agent_link",
# "agent_membership_config",
"agent_membership_recharge_order"
# "agent_membership_recharge_order"
# "agent_membership_user_config",
# "agent_order",
# "agent_platform_deduction",
@@ -31,6 +31,7 @@ $tables = @(
# "query",
# "user"
# "user_auth"
"example"
)
# 为每个表生成模型

3
go.mod
View File

@@ -83,6 +83,7 @@ require (
github.com/prometheus/procfs v0.15.1 // indirect
github.com/redis/go-redis/v9 v9.7.0 // indirect
github.com/robfig/cron/v3 v3.0.1 // indirect
github.com/samber/lo v1.49.1 // indirect
github.com/smartwalle/ncrypto v1.0.4 // indirect
github.com/smartwalle/ngx v1.0.9 // indirect
github.com/smartwalle/nsign v1.0.9 // indirect
@@ -116,7 +117,7 @@ require (
golang.org/x/oauth2 v0.22.0 // indirect
golang.org/x/sys v0.26.0 // indirect
golang.org/x/term v0.25.0 // indirect
golang.org/x/text v0.19.0 // indirect
golang.org/x/text v0.21.0 // indirect
golang.org/x/time v0.7.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect

5
go.sum
View File

@@ -261,6 +261,8 @@ github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/smartwalle/alipay/v3 v3.2.23 h1:i1VwJeu70EmwpsXXz6GZZnMAtRx5MTfn2dPoql/L3zE=
@@ -298,6 +300,7 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
@@ -459,6 +462,8 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/time v0.7.0 h1:ntUhktv3OPE6TgYxXWv9vKvUSJyIFJlyohwbkEwPrKQ=
golang.org/x/time v0.7.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

191
t.jsonc Normal file
View File

@@ -0,0 +1,191 @@
{
"total": 4,
"datalist": [
{
"orgName": "数字重庆信息技术服务有限公司",
"pName": "xxx",
"relationship": ["his_tm"],
"fsource": "",
"basicInfo": {
"regStatus": "存续(在营、开业、在册)",
"regCapital": "1000.000000万",
// 实收注册资本
"reccap": 0,
"city": "重庆市",
// 门类代码
"industry_code": "I",
// 门类名称
"industry": "软件和信息技术服务业",
// 企业类型
"type": "1",
// 国民经济行业分类代码
"nic_code": "I659",
"legalPersonName": "xxx",
"regNumber": "500905012717869",
// 统一社会信用代码
"creditCode": "91500000MA60TUMN6A",
"province": "重庆市",
"his_staffList": {
"result": [
{
"name": "xxx",
"type": "2",
"typeJoin": [""]
}
]
},
"regorg": "重庆两江新区市场监督管理局",
"companyOrgType": "有限责任公司(自然人投资或控股的法人独资)",
"revdate": "",
"estiblishTime": "2020-04-09",
"opscope": "许可项目：第一类增值电信业务；第二类增值电信业务。（依法须经批准的项目，经相关部门批准后方可开展经营活动，具体经营项目以相关部门批准文件或许可证件为准） 一般项目：数据处理和存储支持服务；信息技术咨询服务；技术服务、技术开发、技术咨询、技术交流、技术转让、技术推广；软件开发；信息系统集成服务；互联网数据服务；信息系统运行维护服务；大数据服务；信息安全设备销售；计算器设备销售；互联网设备销售；网络设备销售；物联网设备销售；互联网销售（除销售需要许可的商品）；人工智能硬件销售；计算机软硬件及辅助设备零售；计算机软硬件及辅助设备批发；云计算设备销售；云计算装备技术服务。（除依法须经批准的项目外，凭营业执照依法自主开展经营活动）",
"reccapcur": "人民币",
"regCapitalCurrency": "人民币",
"nic_name": "信息传输、软件和信息技术服务业-软件和信息技术服务业-其他信息技术服务业",
"candate": "",
"district": "渝北区",
"name": "数字重庆信息技术服务有限公司",
"base": "cq",
"apprdate": "2023-09-13"
}
},
{
"orgName": "西部数据交易有限公司",
"pName": "xxx",
"relationship": ["lp", "tm"],
"fsource": "1",
"basicInfo": {
"regStatus": "存续(在营、开业、在册)",
"regCapital": "4000.000000万",
"reccap": 1000,
"city": "重庆市",
"industry_code": "I",
"industry": "互联网和相关服务",
"type": "1",
"nic_code": "I6450",
"staffList": {
"result": [
{
"name": "xxx",
"type": "2",
"typeJoin": ["执行董事"]
}
]
},
"legalPersonName": "xxx",
"regNumber": "500105014994548",
"creditCode": "91500105MA7EPYXA38",
"province": "重庆市",
"regorg": "重庆市江北区市场监督管理局",
"companyOrgType": "有限责任公司（非自然人投资或控股的法人独资）",
"revdate": "",
"estiblishTime": "2021-12-06",
"opscope": "许可项目：互联网信息服务，第二类增值电信业务（依法须经批准的项目，经相关部门批准后方可开展经营活动，具体经营项目以相关部门批准文件或许可证件为准） 一般项目：互联网数据服务，大数据服务，信息系统集成服务，软件开发，人工智能应用软件开发，技术服务、技术开发、技术咨询、技术交流、技术转让、技术推广，数据处理服务，会议及展览服务，广告发布，信息咨询服务（不含许可类信息咨询服务），市场营销策划，科技中介服务，计算机系统服务，计算机软硬件及辅助设备零售，数据处理和存储支持服务，科普宣传服务，人工智能公共数据平台，业务培训（不含教育培训、职业技能培训等需取得许可的培训）（除依法须经批准的项目外，凭营业执照依法自主开展经营活动）",
"reccapcur": "人民币",
"regCapitalCurrency": "人民币",
"nic_name": "信息传输、软件和信息技术服务业-互联网和相关服务-互联网数据服务-互联网数据服务",
"candate": "",
"district": "江北区",
"name": "西部数据交易有限公司",
"base": "cq",
"apprdate": "2023-02-24"
}
},
{
"orgName": "重庆必特思维软件有限公司",
"pName": "xxx",
"stockHolderItem": {
"orgHolderType": "自然人",
"investDate": "2004-05-27",
"investRate": "5.0%",
"subscriptAmt": 5,
"orgHolderName": "xxx"
},
"relationship": ["sh", "tm"],
"fsource": "1",
"basicInfo": {
"regStatus": "注销",
"regCapital": "100万元人民币",
"reccap": 15,
"city": "重庆市",
"industry_code": "I",
"industry": "软件和信息技术服务业",
"type": "1",
"nic_code": "I6519",
"staffList": {
"result": [
{
"name": "xxx",
"type": "2",
"typeJoin": ["经理"]
}
]
},
"legalPersonName": "xxx",
"regNumber": "5001032108594",
"creditCode": "91500103MA61F98N46",
"province": "重庆市",
"regorg": "重庆市工商行政管理局渝中区分局",
"companyOrgType": "有限责任公司(自然人投资或控股)",
"revdate": "",
"estiblishTime": "2004-06-03",
"opscope": "计算机软、硬件技术开发及技术服务；销售计算机及配件、电子产品（不含电子出版物）、通信设备（不含无线电发射设备及地面卫星接收设施）、文化用品、五金、交电『以上范围法律，法规禁止经营的不得经营；法律、法规规定应经审批而未获审批前不得经营』。",
"reccapcur": "人民币",
"regCapitalCurrency": "人民币",
"nic_name": "信息传输、软件和信息技术服务业-软件和信息技术服务业-软件开发-其他软件开发",
"candate": "2006-12-25",
"district": "渝中区",
"name": "重庆必特思维软件有限公司",
"base": "cq",
"apprdate": "2006-12-25"
}
},
{
"orgName": "数字重庆大数据应用发展有限公司",
"pName": "xxx",
"relationship": ["lp", "tm"],
"fsource": "1",
"basicInfo": {
"regStatus": "存续(在营、开业、在册)",
"regCapital": "20000.000000万",
"reccap": 10000,
"city": "重庆市",
"industry_code": "I",
"industry": "软件和信息技术服务业",
"type": "1",
"nic_code": "I653",
"staffList": {
"result": [
{
"name": "xxx",
"type": "2",
"typeJoin": ["执行董事兼总经理"]
}
]
},
"legalPersonName": "xxx",
"regNumber": "500000011963485",
"creditCode": "91500000MA60G3R48R",
"province": "重庆市",
"regorg": "重庆市市场监督管理局",
"companyOrgType": "有限责任公司（非自然人投资或控股的法人独资）",
"revdate": "",
"estiblishTime": "2019-07-26",
"opscope": "许可项目：第一类增值电信业务；第二类增值电信业务；建设工程设计；建设工程施工；建筑智能化系统设计。（依法须经批准的项目，经相关部门批准后方可开展经营活动，具体经营项目以相关部门批准文件或许可证件为准） 一般项目：大数据服务；互联网数据服务；工业互联网数据服务；信息安全设备销售；计算器设备销售；互联网设备销售；网络设备销售；物联网设备销售；互联网销售（除销售需要许可的商品）；人工智能硬件销售；计算机软硬件及辅助设备零售；计算机软硬件及辅助设备批发；云计算设备销售；云计算装备技术服务；人工智能行业应用系统集成服务；物联网应用服务；物联网技术研发；智能车载设备制造；智能车载设备销售；开展数据采集、汇聚、存储及处理服务；数据开发、分析、应用及相关增值服务；信息技术开发、咨询及转让；软件研发及信息系统集成服务；数据服务平台、云计算平台建设及运营维护；组织大数据基础设施项目建设，并对相关项目进行运营、维护及技术服务；大数据企业孵化；智慧城市信息系统的建设、运营及技术服务。。（除依法须经批准的项目外，凭营业执照依法自主开展经营活动）",
"reccapcur": "人民币",
"regCapitalCurrency": "人民币",
"nic_name": "信息传输、软件和信息技术服务业-软件和信息技术服务业-信息系统集成和物联网技术服务",
"candate": "",
"district": "渝北区",
"name": "数字重庆大数据应用发展有限公司",
"base": "cq",
"apprdate": "2022-10-31"
}
}
],
"meta": {
"fieldDescriptions": {
"reccap": "实收注册资本"
}
}
}

4495
t2.jsonc Normal file
View File

File diff suppressed because it is too large Load Diff

5210
t3.jsonc Normal file
View File

File diff suppressed because it is too large Load Diff