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

更新处理器

Browse Source
This commit is contained in:
liangzai
2026-06-10 20:32:24 +08:00
parent a29265f901
commit 45ae6cf36e
293 changed files with 2028 additions and 23462 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
internal/domains/api/services/processors/comb/comb86pm_processor.go
View File

@@ -1,36 +0,0 @@
package comb
import (
"context"
"encoding/json"
"errors"
"hyapi-server/internal/domains/api/dto"
"hyapi-server/internal/domains/api/services/processors"
)
// ProcessCOMB86PMRequest COMB86PM API处理方法
func ProcessCOMB86PMRequest(ctx context.Context, params []byte, deps *processors.ProcessorDependencies) ([]byte, error) {
var paramsDto dto.COMB86PMReq
if err := json.Unmarshal(params, &paramsDto); err != nil {
return nil, errors.Join(processors.ErrSystem, err)
}
if err := deps.Validator.ValidateStruct(paramsDto); err != nil {
return nil, errors.Join(processors.ErrInvalidParam, err)
}
// 调用组合包服务处理请求
// Options会自动传递给所有子处理器
combinedResult, err := deps.CombService.ProcessCombRequest(ctx, params, deps, "COMB86PM")
if err != nil {
return nil, err
}
// 如果有ApiCode为FLXG54F5的子产品，改名为FLXG54F6
for _, resp := range combinedResult.Responses {
if resp.ApiCode == "FLXGBC21" {
resp.ApiCode = "FLXG54F5"
}
}
return json.Marshal(combinedResult)
}

148
internal/domains/api/services/processors/comb/combhzy2_processor.go
View File

@@ -1,148 +0,0 @@
package comb
import (
"context"
"encoding/json"
"errors"
"hyapi-server/internal/domains/api/dto"
"hyapi-server/internal/domains/api/services/processors"
"hyapi-server/internal/shared/logger"
"go.uber.org/zap"
)
// ProcessCOMBHZY2Request 处理 COMBHZY2 组合包请求
func ProcessCOMBHZY2Request(ctx context.Context, params []byte, deps *processors.ProcessorDependencies) ([]byte, error) {
log := logger.GetGlobalLogger()
var req dto.COMBHZY2Req
if err := json.Unmarshal(params, &req); err != nil {
log.Error("COMBHZY2请求参数反序列化失败",
zap.Error(err),
zap.String("params", string(params)),
zap.String("api_code", "COMBHZY2"),
)
return nil, errors.Join(processors.ErrSystem, err)
}
if err := deps.Validator.ValidateStruct(req); err != nil {
log.Error("COMBHZY2请求参数验证失败",
zap.Error(err),
zap.String("api_code", "COMBHZY2"),
)
return nil, errors.Join(processors.ErrInvalidParam, err)
}
combinedResult, err := deps.CombService.ProcessCombRequest(ctx, params, deps, "COMBHZY2")
if err != nil {
log.Error("COMBHZY2组合包服务调用失败",
zap.Error(err),
zap.String("api_code", "COMBHZY2"),
)
return nil, err
}
if combinedResult == nil {
log.Error("COMBHZY2组合包响应为空",
zap.String("api_code", "COMBHZY2"),
)
return nil, errors.New("组合包响应为空")
}
log.Info("COMBHZY2组合包服务调用成功",
zap.Int("子产品数量", len(combinedResult.Responses)),
zap.String("api_code", "COMBHZY2"),
)
sourceCtx, err := buildSourceContextFromCombined(ctx, combinedResult)
if err != nil {
log.Error("COMBHZY2构建源数据上下文失败",
zap.Error(err),
zap.String("api_code", "COMBHZY2"),
)
return nil, err
}
report := buildTargetReport(ctx, sourceCtx)
reportBytes, err := json.Marshal(report)
if err != nil {
log.Error("COMBHZY2报告序列化失败",
zap.Error(err),
zap.String("api_code", "COMBHZY2"),
)
return nil, errors.Join(processors.ErrSystem, err)
}
return reportBytes, nil
}
func buildSourceContextFromCombined(ctx context.Context, result *processors.CombinedResult) (*sourceContext, error) {
log := logger.GetGlobalLogger()
if result == nil {
log.Error("组合包响应为空", zap.String("api_code", "COMBHZY2"))
return nil, errors.New("组合包响应为空")
}
src := sourceFile{Responses: make([]sourceResponse, 0, len(result.Responses))}
successCount := 0
failedCount := 0
for _, resp := range result.Responses {
if !resp.Success {
log.Warn("子产品调用失败，跳过",
zap.String("api_code", resp.ApiCode),
zap.String("error", resp.Error),
zap.String("parent_api_code", "COMBHZY2"),
)
failedCount++
continue
}
if resp.Data == nil {
log.Warn("子产品数据为空，跳过",
zap.String("api_code", resp.ApiCode),
zap.String("parent_api_code", "COMBHZY2"),
)
failedCount++
continue
}
raw, err := json.Marshal(resp.Data)
if err != nil {
log.Error("序列化子产品数据失败",
zap.Error(err),
zap.String("api_code", resp.ApiCode),
zap.String("parent_api_code", "COMBHZY2"),
)
failedCount++
continue
}
src.Responses = append(src.Responses, sourceResponse{
ApiCode: resp.ApiCode,
Data: raw,
Success: resp.Success,
})
successCount++
}
log.Info("组合包子产品处理完成",
zap.Int("成功数量", successCount),
zap.Int("失败数量", failedCount),
zap.Int("总数量", len(result.Responses)),
zap.String("api_code", "COMBHZY2"),
)
if len(src.Responses) == 0 {
log.Error("组合包子产品全部调用失败",
zap.Int("总数量", len(result.Responses)),
zap.String("api_code", "COMBHZY2"),
)
return nil, errors.New("组合包子产品全部调用失败")
}
return buildSourceContext(ctx, src)
}

2053
internal/domains/api/services/processors/comb/combhzy2_transform.go
View File

File diff suppressed because it is too large Load Diff

91
internal/domains/api/services/processors/comb/combwd01_processor.go
View File

@@ -1,91 +0,0 @@
package comb
import (
"context"
"encoding/json"
"errors"
"hyapi-server/internal/domains/api/services/processors"
"hyapi-server/internal/shared/logger"
"go.uber.org/zap"
)
// ProcessCOMBWD01Request 处理 COMBWD01 组合包请求
// 将返回结构从数组改为以 api_code 为 key 的对象结构
func ProcessCOMBWD01Request(ctx context.Context, params []byte, deps *processors.ProcessorDependencies) ([]byte, error) {
log := logger.GetGlobalLogger()
// 调用组合包服务处理请求
combinedResult, err := deps.CombService.ProcessCombRequest(ctx, params, deps, "COMBWD01")
if err != nil {
log.Error("COMBWD01组合包服务调用失败",
zap.Error(err),
zap.String("api_code", "COMBWD01"),
)
return nil, err
}
if combinedResult == nil {
log.Error("COMBWD01组合包响应为空",
zap.String("api_code", "COMBWD01"),
)
return nil, errors.New("组合包响应为空")
}
log.Info("COMBWD01组合包服务调用成功",
zap.Int("子产品数量", len(combinedResult.Responses)),
zap.String("api_code", "COMBWD01"),
)
// 将数组结构转换为对象结构
responsesMap := make(map[string]*ResponseItem)
for _, resp := range combinedResult.Responses {
item := &ResponseItem{
ApiCode: resp.ApiCode,
Success: resp.Success,
}
// 根据成功/失败状态设置 data 和 error 字段
if resp.Success {
// 成功时：data 有值（可能为 nil），error 为 null
item.Data = resp.Data
item.Error = nil
} else {
// 失败时：data 为 null，error 有值
item.Data = nil
if resp.Error != "" {
item.Error = resp.Error
} else {
item.Error = "未知错误"
}
}
responsesMap[resp.ApiCode] = item
}
// 构建新的响应结构
result := map[string]interface{}{
"responses": responsesMap,
}
// 序列化并返回
resultBytes, err := json.Marshal(result)
if err != nil {
log.Error("COMBWD01响应序列化失败",
zap.Error(err),
zap.String("api_code", "COMBWD01"),
)
return nil, errors.Join(processors.ErrSystem, err)
}
return resultBytes, nil
}
// ResponseItem 响应项结构
type ResponseItem struct {
ApiCode string `json:"api_code"`
Success bool `json:"success"`
Data interface{} `json:"data"`
Error interface{} `json:"error"`
}