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

new feature

Browse Source
This commit is contained in:
liangzai 2025-04-23 02:03:31 +08:00
parent 91db6239d9
commit b7739e264f
13 changed files with 1318 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/user/cmd/api/internal/logic/pay/paymentlogic.go
View File

@ -33,8 +33,6 @@ func NewPaymentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PaymentLo
}
func (l *PaymentLogic) Payment(req *types.PaymentReq) (resp *types.PaymentResp, err error) {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "")
userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
if getUidErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取用户信息失败, %+v", getUidErr)

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

@ -3,12 +3,13 @@ package query
import (
"context"
"encoding/hex"
"fmt"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
"tydata-server/app/user/cmd/api/internal/svc"
"tydata-server/app/user/cmd/api/internal/types"
"tydata-server/common/xerr"
"tydata-server/pkg/lzkit/crypto"
"github.com/bytedance/sonic"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/logx"
)
@ -28,124 +29,82 @@ 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 {
// 遍历 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
}

34
app/user/cmd/api/internal/logic/query/querylistlogic.go
View File

@ -2,14 +2,15 @@ package query
import (
"context"
"github.com/Masterminds/squirrel"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/logx"
"tydata-server/app/user/cmd/api/internal/svc"
"tydata-server/app/user/cmd/api/internal/types"
"tydata-server/common/ctxdata"
"tydata-server/common/xerr"
"github.com/Masterminds/squirrel"
"github.com/jinzhu/copier"
"github.com/pkg/errors"
"github.com/zeromicro/go-zero/core/logx"
)
type QueryListLogic struct {
@ -31,34 +32,31 @@ func (l *QueryListLogic) QueryList(req *types.QueryListReq) (resp *types.QueryLi
if getUidErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告列表查询, 获取用户信息失败, %+v", getUidErr)
}
build := l.svcCtx.OrderModel.SelectBuilder().Where(squirrel.Eq{
// 直接构建查询query表的条件
build := l.svcCtx.QueryModel.SelectBuilder().Where(squirrel.Eq{
"user_id": userID,
}).Where(squirrel.NotEq{
"status": []string{"pending", "closed"},
})
orderList, total, err := l.svcCtx.OrderModel.FindPageListByPageWithTotal(l.ctx, build, req.Page, req.PageSize, "create_time DESC")
// 直接从query表分页查询
queryList, total, err := l.svcCtx.QueryModel.FindPageListByPageWithTotal(l.ctx, build, req.Page, req.PageSize, "create_time DESC")
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告列表查询, 查找订单列表错误, %v", err)
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "报告列表查询, 查找报告列表错误, %+v", err)
}
var list []types.Query
if len(orderList) > 0 {
for _, orderModel := range orderList {
queryModel, findQueryErr := l.svcCtx.QueryModel.FindOneByOrderId(l.ctx, orderModel.Id)
if findQueryErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 查找报告错误, %+v", findQueryErr)
}
if len(queryList) > 0 {
for _, queryModel := range queryList {
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")
copyErr := copier.Copy(&query, queryModel)
if copyErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 报告结构体复制失败, %v", err)
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 报告结构体复制失败, %+v", err)
}
product, findProductErr := l.svcCtx.ProductModel.FindOne(l.ctx, queryModel.ProductId)
if findProductErr != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 获取商品信息失败, %v", err)
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "报告列表查询, 获取商品信息失败, %+v", err)
}
query.ProductName = product.ProductName
list = append(list, query)

10
app/user/cmd/api/internal/queue/paySuccessNotify.go
View File

@ -55,21 +55,21 @@ func (l *PaySuccessNotifyUserHandler) ProcessTask(ctx context.Context, t *asynq.
redisKey := fmt.Sprintf("%d:%s", order.UserId, order.OrderNo)
cache, cacheErr := l.svcCtx.Redis.GetCtx(ctx, redisKey)
if cacheErr != nil {
return fmt.Errorf("生成订单, 获取缓存内容失败: %+v", cacheErr)
return fmt.Errorf("获取缓存内容失败: %+v", cacheErr)
}
var data types.QueryCacheLoad
err = json.Unmarshal([]byte(cache), &data)
if err != nil {
return fmt.Errorf("生成订单, 解析缓存内容失败: %+v", err)
return fmt.Errorf("解析缓存内容失败: %+v", err)
}
secretKey := l.svcCtx.Config.Encrypt.SecretKey
key, decodeErr := hex.DecodeString(secretKey)
if decodeErr != nil {
return fmt.Errorf("生成订单, 获取AES密钥失败: %+v", decodeErr)
return fmt.Errorf("获取AES密钥失败: %+v", decodeErr)
}
decryptData, aesdecryptErr := crypto.AesDecrypt(data.Params, key)
if aesdecryptErr != nil {
return fmt.Errorf("生成订单, 解密参数失败: %+v", aesdecryptErr)
return fmt.Errorf("解密参数失败: %+v", aesdecryptErr)
}
// 敏感数据脱敏处理
@ -93,7 +93,7 @@ func (l *PaySuccessNotifyUserHandler) ProcessTask(ctx context.Context, t *asynq.
}
result, insertQueryErr := l.svcCtx.QueryModel.Insert(ctx, nil, query)
if insertQueryErr != nil {
return fmt.Errorf("生成订单, 保存查询失败: %+v", insertQueryErr)
return fmt.Errorf("保存查询失败: %+v", insertQueryErr)
}
// 获取插入后的ID

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

@ -8,6 +8,7 @@ import (
"io"
"net/http"
"net/url"
"sort"
"strings"
"sync"
"sync/atomic"
@ -197,6 +198,17 @@ 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,
"G09XM02": (*ApiRequestService).ProcessG09XM02Request,
"G10XM02": (*ApiRequestService).ProcessG10XM02Request,
"G11BJ06": (*ApiRequestService).ProcessG11BJ06Request,
}
// PreprocessRequestApi 调用指定的请求处理函数
@ -520,7 +532,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 +1120,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 +1277,647 @@ 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
}
func (a *ApiRequestService) ProcessG09XM02Request(params []byte) ([]byte, error) {
idCard := gjson.GetBytes(params, "id_card")
name := gjson.GetBytes(params, "name")
if !idCard.Exists() || !name.Exists() {
return nil, errors.New("api请求, G09XM02, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"idCard": a.westDexService.Encrypt(idCard.String()),
"name": a.westDexService.Encrypt(name.String()),
},
}
resp, err := a.westDexService.CallAPI("G09XM02", request)
if err != nil {
return nil, fmt.Errorf("婚姻状态查询失败: %v", err)
}
// gjson.GetBytes(resp, "maritalStatus")
return resp, nil
}
func (a *ApiRequestService) ProcessG10XM02Request(params []byte) ([]byte, error) {
// 提取男方和女方信息
nameMan := gjson.GetBytes(params, "nameMan")
idCardMan := gjson.GetBytes(params, "idCardMan")
nameWoman := gjson.GetBytes(params, "nameWoman")
idCardWoman := gjson.GetBytes(params, "idCardWoman")
// 校验是否存在必要参数
if !nameMan.Exists() || !idCardMan.Exists() || !nameWoman.Exists() || !idCardWoman.Exists() {
return nil, errors.New("请求参数缺失：需要提供男方和女方的姓名及身份证号")
}
// 构造请求数据
request := map[string]interface{}{
"data": map[string]interface{}{
"idCardMan": a.westDexService.Encrypt(idCardMan.String()),
"nameMan": a.westDexService.Encrypt(nameMan.String()),
"idCardWoman": a.westDexService.Encrypt(idCardWoman.String()),
"nameWoman": a.westDexService.Encrypt(nameWoman.String()),
},
}
// 调用 API
resp, callApiErr := a.westDexService.CallAPI("G10XM02", request)
if callApiErr != nil {
return nil, callApiErr
}
return resp, nil
}
func (a *ApiRequestService) ProcessG11BJ06Request(params []byte) ([]byte, error) {
idCard := gjson.GetBytes(params, "id_card")
name := gjson.GetBytes(params, "name")
if !idCard.Exists() || !name.Exists() {
return nil, errors.New("api请求, G11BJ06, 获取相关参数失败")
}
request := map[string]interface{}{
"data": map[string]interface{}{
"id_card_value": a.westDexService.Encrypt(idCard.String()),
"name_value": a.westDexService.Encrypt(name.String()),
},
}
resp, err := a.westDexService.CallAPI("G11BJ06", request)
if err != nil {
return nil, fmt.Errorf("教育经历核验查询失败: %v", err)
}
return resp, nil
}

4
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,7 +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)
applePayService := service.NewApplePayService(c)
@ -150,6 +151,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"
"tydata-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`"), "=?,") + "=?"
cacheTydataExampleIdPrefix = "cache:tydata:example:id:"
cacheTydataExampleApiIdPrefix = "cache:tydata:example:apiId:"
cacheTydataExampleFeatureIdPrefix = "cache:tydata: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
tydataExampleApiIdKey := fmt.Sprintf("%s%v", cacheTydataExampleApiIdPrefix, data.ApiId)
tydataExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheTydataExampleFeatureIdPrefix, data.FeatureId)
tydataExampleIdKey := fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, 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)
}, tydataExampleApiIdKey, tydataExampleFeatureIdKey, tydataExampleIdKey)
}
func (m *defaultExampleModel) FindOne(ctx context.Context, id int64) (*Example, error) {
tydataExampleIdKey := fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, id)
var resp Example
err := m.QueryRowCtx(ctx, &resp, tydataExampleIdKey, 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) {
tydataExampleApiIdKey := fmt.Sprintf("%s%v", cacheTydataExampleApiIdPrefix, apiId)
var resp Example
err := m.QueryRowIndexCtx(ctx, &resp, tydataExampleApiIdKey, 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) {
tydataExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheTydataExampleFeatureIdPrefix, featureId)
var resp Example
err := m.QueryRowIndexCtx(ctx, &resp, tydataExampleFeatureIdKey, 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
}
tydataExampleApiIdKey := fmt.Sprintf("%s%v", cacheTydataExampleApiIdPrefix, data.ApiId)
tydataExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheTydataExampleFeatureIdPrefix, data.FeatureId)
tydataExampleIdKey := fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, 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)
}, tydataExampleApiIdKey, tydataExampleFeatureIdKey, tydataExampleIdKey)
}
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
}
tydataExampleApiIdKey := fmt.Sprintf("%s%v", cacheTydataExampleApiIdPrefix, data.ApiId)
tydataExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheTydataExampleFeatureIdPrefix, data.FeatureId)
tydataExampleIdKey := fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, 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)
}, tydataExampleApiIdKey, tydataExampleFeatureIdKey, tydataExampleIdKey)
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
}
tydataExampleApiIdKey := fmt.Sprintf("%s%v", cacheTydataExampleApiIdPrefix, data.ApiId)
tydataExampleFeatureIdKey := fmt.Sprintf("%s%v", cacheTydataExampleFeatureIdPrefix, data.FeatureId)
tydataExampleIdKey := fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, 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)
}, tydataExampleApiIdKey, tydataExampleFeatureIdKey, tydataExampleIdKey)
return err
}
func (m *defaultExampleModel) formatPrimary(primary interface{}) string {
return fmt.Sprintf("%s%v", cacheTydataExampleIdPrefix, 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
}

1
common/xerr/errCode.go
View File

@ -15,6 +15,7 @@ const DB_UPDATE_AFFECTED_ZERO_ERROR uint32 = 100006
const PARAM_VERIFICATION_ERROR uint32 = 100007
const CUSTOM_ERROR uint32 = 100008
const USER_NOT_FOUND uint32 = 100009
const LOGIN_FAILED uint32 = 200001
const LOGIC_QUERY_WAIT uint32 = 200002
const LOGIC_QUERY_ERROR uint32 = 200003

40
deploy/script/gen_models.ps1 Normal file
View File

@ -0,0 +1,40 @@
# 设置输出编码为UTF-8
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
# 数据库连接信息 - 修改了URL格式
$DB_URL = "tydata:5vg67b3UNHu8@(127.0.0.1:21001)/tydata"
$OUTPUT_DIR = "./model"
$TEMPLATE_DIR = "../template"
# 表名列表
$tables = @(
# "agent",
# "agent_active_stat",
# "agent_audit",
# "agent_closure",
# "agent_commission",
# "agent_commission_deduction",
# "agent_link",
# "agent_membership_config",
# "agent_membership_recharge_order"
# "agent_membership_user_config",
# "agent_order",
# "agent_platform_deduction",
# "agent_product_config",
# "agent_rewards",
# "agent_wallet",
# "agent_withdrawal",
# "feature",
# "global_notifications",
# "order",
# "product",
# "product_feature",
# "query",
# "user"
# "user_auth"
"example"
)
# 为每个表生成模型
foreach ($table in $tables) {
goctl model mysql datasource -url="tydata:5vg67b3UNHu8@tcp(127.0.0.1:21001)/tydata" -table="$table" -dir="./model" --home="../template" -cache=true --style=goZero
}

27
deploy/script/model/agentActiveStatModel.go
View File

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

408
deploy/script/model/agentActiveStatModel_gen.go
View File

@ -1,408 +0,0 @@
// 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"
"tydata-server/common/globalkey"
)
var (
agentActiveStatFieldNames = builder.RawFieldNames(&AgentActiveStat{})
agentActiveStatRows = strings.Join(agentActiveStatFieldNames, ",")
agentActiveStatRowsExpectAutoSet = strings.Join(stringx.Remove(agentActiveStatFieldNames, "`id`", "`create_time`", "`update_time`"), ",")
agentActiveStatRowsWithPlaceHolder = strings.Join(stringx.Remove(agentActiveStatFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
cacheTydataAgentActiveStatIdPrefix = "cache:tydata:agentActiveStat:id:"
cacheTydataAgentActiveStatAgentIdStatDatePrefix = "cache:tydata:agentActiveStat:agentId:statDate:"
)
type (
agentActiveStatModel interface {
Insert(ctx context.Context, session sqlx.Session, data *AgentActiveStat) (sql.Result, error)
FindOne(ctx context.Context, id int64) (*AgentActiveStat, error)
FindOneByAgentIdStatDate(ctx context.Context, agentId int64, statDate time.Time) (*AgentActiveStat, error)
Update(ctx context.Context, session sqlx.Session, data *AgentActiveStat) (sql.Result, error)
UpdateWithVersion(ctx context.Context, session sqlx.Session, data *AgentActiveStat) 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 *AgentActiveStat) 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) ([]*AgentActiveStat, error)
FindPageListByPage(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*AgentActiveStat, error)
FindPageListByPageWithTotal(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*AgentActiveStat, int64, error)
FindPageListByIdDESC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*AgentActiveStat, error)
FindPageListByIdASC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*AgentActiveStat, error)
Delete(ctx context.Context, session sqlx.Session, id int64) error
}
defaultAgentActiveStatModel struct {
sqlc.CachedConn
table string
}
AgentActiveStat struct {
Id int64 `db:"id"` // 主键ID
AgentId int64 `db:"agent_id"` // 代理ID
StatDate time.Time `db:"stat_date"` // 统计日期
ActiveNumber int64 `db:"active_number"` // 下级活跃数
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"` // 版本号
}
)
func newAgentActiveStatModel(conn sqlx.SqlConn, c cache.CacheConf) *defaultAgentActiveStatModel {
return &defaultAgentActiveStatModel{
CachedConn: sqlc.NewConn(conn, c),
table: "`agent_active_stat`",
}
}
func (m *defaultAgentActiveStatModel) Insert(ctx context.Context, session sqlx.Session, data *AgentActiveStat) (sql.Result, error) {
data.DelState = globalkey.DelStateNo
tydataAgentActiveStatAgentIdStatDateKey := fmt.Sprintf("%s%v:%v", cacheTydataAgentActiveStatAgentIdStatDatePrefix, data.AgentId, data.StatDate)
tydataAgentActiveStatIdKey := fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, 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, agentActiveStatRowsExpectAutoSet)
if session != nil {
return session.ExecCtx(ctx, query, data.AgentId, data.StatDate, data.ActiveNumber, data.DeleteTime, data.DelState, data.Version)
}
return conn.ExecCtx(ctx, query, data.AgentId, data.StatDate, data.ActiveNumber, data.DeleteTime, data.DelState, data.Version)
}, tydataAgentActiveStatAgentIdStatDateKey, tydataAgentActiveStatIdKey)
}
func (m *defaultAgentActiveStatModel) FindOne(ctx context.Context, id int64) (*AgentActiveStat, error) {
tydataAgentActiveStatIdKey := fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, id)
var resp AgentActiveStat
err := m.QueryRowCtx(ctx, &resp, tydataAgentActiveStatIdKey, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error {
query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", agentActiveStatRows, 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 *defaultAgentActiveStatModel) FindOneByAgentIdStatDate(ctx context.Context, agentId int64, statDate time.Time) (*AgentActiveStat, error) {
tydataAgentActiveStatAgentIdStatDateKey := fmt.Sprintf("%s%v:%v", cacheTydataAgentActiveStatAgentIdStatDatePrefix, agentId, statDate)
var resp AgentActiveStat
err := m.QueryRowIndexCtx(ctx, &resp, tydataAgentActiveStatAgentIdStatDateKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) {
query := fmt.Sprintf("select %s from %s where `agent_id` = ? and `stat_date` = ? and del_state = ? limit 1", agentActiveStatRows, m.table)
if err := conn.QueryRowCtx(ctx, &resp, query, agentId, statDate, 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 *defaultAgentActiveStatModel) Update(ctx context.Context, session sqlx.Session, newData *AgentActiveStat) (sql.Result, error) {
data, err := m.FindOne(ctx, newData.Id)
if err != nil {
return nil, err
}
tydataAgentActiveStatAgentIdStatDateKey := fmt.Sprintf("%s%v:%v", cacheTydataAgentActiveStatAgentIdStatDatePrefix, data.AgentId, data.StatDate)
tydataAgentActiveStatIdKey := fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, 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, agentActiveStatRowsWithPlaceHolder)
if session != nil {
return session.ExecCtx(ctx, query, newData.AgentId, newData.StatDate, newData.ActiveNumber, newData.DeleteTime, newData.DelState, newData.Version, newData.Id)
}
return conn.ExecCtx(ctx, query, newData.AgentId, newData.StatDate, newData.ActiveNumber, newData.DeleteTime, newData.DelState, newData.Version, newData.Id)
}, tydataAgentActiveStatAgentIdStatDateKey, tydataAgentActiveStatIdKey)
}
func (m *defaultAgentActiveStatModel) UpdateWithVersion(ctx context.Context, session sqlx.Session, newData *AgentActiveStat) 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
}
tydataAgentActiveStatAgentIdStatDateKey := fmt.Sprintf("%s%v:%v", cacheTydataAgentActiveStatAgentIdStatDatePrefix, data.AgentId, data.StatDate)
tydataAgentActiveStatIdKey := fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, 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, agentActiveStatRowsWithPlaceHolder)
if session != nil {
return session.ExecCtx(ctx, query, newData.AgentId, newData.StatDate, newData.ActiveNumber, newData.DeleteTime, newData.DelState, newData.Version, newData.Id, oldVersion)
}
return conn.ExecCtx(ctx, query, newData.AgentId, newData.StatDate, newData.ActiveNumber, newData.DeleteTime, newData.DelState, newData.Version, newData.Id, oldVersion)
}, tydataAgentActiveStatAgentIdStatDateKey, tydataAgentActiveStatIdKey)
if err != nil {
return err
}
updateCount, err := sqlResult.RowsAffected()
if err != nil {
return err
}
if updateCount == 0 {
return ErrNoRowsUpdate
}
return nil
}
func (m *defaultAgentActiveStatModel) DeleteSoft(ctx context.Context, session sqlx.Session, data *AgentActiveStat) 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 "), "AgentActiveStatModel delete err : %v", err)
}
return nil
}
func (m *defaultAgentActiveStatModel) 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 *defaultAgentActiveStatModel) 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 *defaultAgentActiveStatModel) FindAll(ctx context.Context, builder squirrel.SelectBuilder, orderBy string) ([]*AgentActiveStat, error) {
builder = builder.Columns(agentActiveStatRows)
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 []*AgentActiveStat
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultAgentActiveStatModel) FindPageListByPage(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*AgentActiveStat, error) {
builder = builder.Columns(agentActiveStatRows)
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 []*AgentActiveStat
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultAgentActiveStatModel) FindPageListByPageWithTotal(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*AgentActiveStat, int64, error) {
total, err := m.FindCount(ctx, builder, "id")
if err != nil {
return nil, 0, err
}
builder = builder.Columns(agentActiveStatRows)
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 []*AgentActiveStat
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, total, nil
default:
return nil, total, err
}
}
func (m *defaultAgentActiveStatModel) FindPageListByIdDESC(ctx context.Context, builder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*AgentActiveStat, error) {
builder = builder.Columns(agentActiveStatRows)
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 []*AgentActiveStat
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultAgentActiveStatModel) FindPageListByIdASC(ctx context.Context, builder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*AgentActiveStat, error) {
builder = builder.Columns(agentActiveStatRows)
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 []*AgentActiveStat
err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...)
switch err {
case nil:
return resp, nil
default:
return nil, err
}
}
func (m *defaultAgentActiveStatModel) 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 *defaultAgentActiveStatModel) SelectBuilder() squirrel.SelectBuilder {
return squirrel.Select().From(m.table)
}
func (m *defaultAgentActiveStatModel) Delete(ctx context.Context, session sqlx.Session, id int64) error {
data, err := m.FindOne(ctx, id)
if err != nil {
return err
}
tydataAgentActiveStatAgentIdStatDateKey := fmt.Sprintf("%s%v:%v", cacheTydataAgentActiveStatAgentIdStatDatePrefix, data.AgentId, data.StatDate)
tydataAgentActiveStatIdKey := fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, 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)
}, tydataAgentActiveStatAgentIdStatDateKey, tydataAgentActiveStatIdKey)
return err
}
func (m *defaultAgentActiveStatModel) formatPrimary(primary interface{}) string {
return fmt.Sprintf("%s%v", cacheTydataAgentActiveStatIdPrefix, primary)
}
func (m *defaultAgentActiveStatModel) 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", agentActiveStatRows, m.table)
return conn.QueryRowCtx(ctx, v, query, primary, globalkey.DelStateNo)
}
func (m *defaultAgentActiveStatModel) tableName() string {
return m.table
}

4
deploy/script/model/vars.go
View File

@ -1,8 +1,8 @@
package model
import (
"errors"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"errors"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
var ErrNotFound = sqlx.ErrNotFound