527 lines
16 KiB
Go
527 lines
16 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/Masterminds/squirrel"
|
|
"github.com/tidwall/gjson"
|
|
"github.com/zeromicro/go-zero/core/logx"
|
|
"qnc-server/app/user/cmd/api/internal/config"
|
|
"qnc-server/app/user/model"
|
|
"qnc-server/pkg/lzkit/crypto"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
type ApiRequestService struct {
|
|
config config.Config
|
|
westDexService *WestDexService
|
|
featureModel model.FeatureModel
|
|
productFeatureModel model.ProductFeatureModel
|
|
}
|
|
|
|
// NewApiRequestService 是一个构造函数，用于初始化 ApiRequestService
|
|
func NewApiRequestService(c config.Config, westDexService *WestDexService, featureModel model.FeatureModel, productFeatureModel model.ProductFeatureModel) *ApiRequestService {
|
|
return &ApiRequestService{
|
|
config: c,
|
|
featureModel: featureModel,
|
|
productFeatureModel: productFeatureModel,
|
|
westDexService: westDexService,
|
|
}
|
|
}
|
|
|
|
type APIResponseData struct {
|
|
ApiID string `json:"apiID"`
|
|
Data json.RawMessage `json:"data"` // 这里用 RawMessage 来存储原始的 data
|
|
Success bool `json:"success"`
|
|
Timestamp string `json:"timestamp"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// ProcessRequests 处理请求
|
|
func (a *ApiRequestService) ProcessRequests(params []byte, productID int64) ([]byte, error) {
|
|
var ctx, cancel = context.WithCancel(context.Background())
|
|
defer cancel()
|
|
build := a.productFeatureModel.SelectBuilder().Where(squirrel.Eq{
|
|
"product_id": productID,
|
|
})
|
|
productFeatureList, findProductFeatureErr := a.productFeatureModel.FindAll(ctx, build, "")
|
|
if findProductFeatureErr != nil {
|
|
return nil, findProductFeatureErr
|
|
}
|
|
var featureIDs []int64
|
|
for _, pf := range productFeatureList {
|
|
featureIDs = append(featureIDs, pf.FeatureId)
|
|
}
|
|
if len(featureIDs) == 0 {
|
|
return nil, errors.New("featureIDs 是空的")
|
|
}
|
|
builder := a.featureModel.SelectBuilder().Where(squirrel.Eq{"id": featureIDs})
|
|
featureList, findFeatureErr := a.featureModel.FindAll(ctx, builder, "")
|
|
if findFeatureErr != nil {
|
|
return nil, findFeatureErr
|
|
}
|
|
if len(featureList) == 0 {
|
|
return nil, errors.New("处理请求错误，产品无对应接口功能")
|
|
}
|
|
var (
|
|
wg sync.WaitGroup
|
|
resultsCh = make(chan APIResponseData, len(featureList))
|
|
errorsCh = make(chan error, len(featureList))
|
|
errorCount int32
|
|
errorLimit = len(featureList)
|
|
)
|
|
|
|
for i, feature := range featureList {
|
|
wg.Add(1)
|
|
go func(i int, feature *model.Feature) {
|
|
defer wg.Done()
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
default:
|
|
}
|
|
result := APIResponseData{
|
|
ApiID: feature.ApiId,
|
|
Success: false,
|
|
}
|
|
// 请求参数预处理
|
|
resp, preprocessErr := a.PreprocessRequestApi(params, feature.ApiId)
|
|
timestamp := time.Now().Format("2006-01-02 15:04:05")
|
|
if preprocessErr != nil {
|
|
result.Timestamp = timestamp
|
|
result.Error = preprocessErr.Error()
|
|
result.Data = resp
|
|
resultsCh <- result
|
|
errorsCh <- fmt.Errorf("请求预处理失败: %v", preprocessErr)
|
|
atomic.AddInt32(&errorCount, 1)
|
|
if atomic.LoadInt32(&errorCount) >= int32(errorLimit) {
|
|
cancel()
|
|
}
|
|
return
|
|
}
|
|
|
|
result.Data = resp
|
|
result.Success = true
|
|
result.Timestamp = timestamp
|
|
resultsCh <- result
|
|
}(i, feature)
|
|
}
|
|
|
|
go func() {
|
|
wg.Wait()
|
|
close(resultsCh)
|
|
close(errorsCh)
|
|
}()
|
|
// 收集所有结果并合并
|
|
var responseData []APIResponseData
|
|
for result := range resultsCh {
|
|
responseData = append(responseData, result)
|
|
}
|
|
if atomic.LoadInt32(&errorCount) >= int32(errorLimit) {
|
|
var allErrors []error
|
|
for err := range errorsCh {
|
|
allErrors = append(allErrors, err)
|
|
}
|
|
return nil, fmt.Errorf("请求失败次数超过 %d 次: %v", errorLimit, allErrors)
|
|
}
|
|
|
|
combinedResponse, err := json.Marshal(responseData)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("响应数据转 JSON 失败: %+v", err)
|
|
}
|
|
|
|
return combinedResponse, nil
|
|
}
|
|
|
|
// ------------------------------------请求处理器--------------------------
|
|
var requestProcessors = map[string]func(*ApiRequestService, []byte) ([]byte, error){
|
|
"G09SC02": (*ApiRequestService).ProcessG09SC02Request,
|
|
"G27BJ05": (*ApiRequestService).ProcessG27BJ05Request,
|
|
"G26BJ05": (*ApiRequestService).ProcessG26BJ05Request,
|
|
"G34BJ03": (*ApiRequestService).ProcessG34BJ03Request,
|
|
"G35SC01": (*ApiRequestService).ProcessG35SC01Request,
|
|
"G28BJ05": (*ApiRequestService).ProcessG28BJ05Request,
|
|
"G05HZ01": (*ApiRequestService).ProcessG05HZ01Request,
|
|
"Q23SC01": (*ApiRequestService).ProcessQ23SC01Request,
|
|
}
|
|
|
|
// PreprocessRequestApi 调用指定的请求处理函数
|
|
func (a *ApiRequestService) PreprocessRequestApi(params []byte, apiID string) ([]byte, error) {
|
|
if processor, exists := requestProcessors[apiID]; exists {
|
|
return processor(a, params) // 调用 ApiRequestService 方法
|
|
}
|
|
|
|
return nil, errors.New("api请求, 未找到相应的处理程序")
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG09SC02Request(params []byte) ([]byte, error) {
|
|
name := gjson.GetBytes(params, "name")
|
|
idCard := gjson.GetBytes(params, "id_card")
|
|
|
|
if !name.Exists() || !idCard.Exists() {
|
|
return nil, errors.New("api请求, G09SC02, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"certNumMan": a.westDexService.Encrypt(idCard.String()),
|
|
"nameMan": a.westDexService.Encrypt(name.String()),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G09SC02", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
result := gjson.GetBytes(resp, "data.0.maritalStatus")
|
|
|
|
if result.Exists() {
|
|
responseMap := map[string]string{"status": result.String()}
|
|
jsonResponse, err := json.Marshal(responseMap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return jsonResponse, nil
|
|
} else {
|
|
return nil, errors.New("查询为空")
|
|
}
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG27BJ05Request(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请求, G27BJ05, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"id": a.westDexService.Encrypt(idCard.String()),
|
|
"name": a.westDexService.Encrypt(name.String()),
|
|
"cell": a.westDexService.Encrypt(mobile.String()),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G27BJ05", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
// 获取 code 字段
|
|
codeResult := gjson.GetBytes(resp, "code")
|
|
if !codeResult.Exists() {
|
|
return nil, fmt.Errorf("code 字段不存在")
|
|
}
|
|
if codeResult.String() != "00" {
|
|
return nil, fmt.Errorf("未匹配到相关结果")
|
|
}
|
|
|
|
// 获取 data 字段
|
|
dataResult := gjson.GetBytes(resp, "data")
|
|
if !dataResult.Exists() {
|
|
return nil, fmt.Errorf("data 字段不存在")
|
|
}
|
|
|
|
// 将 data 字段解析为 map
|
|
var dataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
|
|
return nil, fmt.Errorf("解析 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 删除指定字段
|
|
delete(dataMap, "swift_number")
|
|
delete(dataMap, "DataStrategy")
|
|
|
|
// 重新编码为 JSON
|
|
modifiedData, err := json.Marshal(dataMap)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
|
|
}
|
|
return modifiedData, nil
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG26BJ05Request(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请求, G26BJ05, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"id": a.westDexService.Encrypt(idCard.String()),
|
|
"name": a.westDexService.Encrypt(name.String()),
|
|
"cell": a.westDexService.Encrypt(mobile.String()),
|
|
"time_range": 5,
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G26BJ05", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
codeResult := gjson.GetBytes(resp, "code")
|
|
if !codeResult.Exists() {
|
|
return nil, fmt.Errorf("code 字段不存在")
|
|
}
|
|
if codeResult.String() != "00" {
|
|
return nil, fmt.Errorf("未匹配到相关结果")
|
|
}
|
|
|
|
// 获取 data 字段
|
|
dataResult := gjson.GetBytes(resp, "data")
|
|
if !dataResult.Exists() {
|
|
return nil, fmt.Errorf("data 字段不存在")
|
|
}
|
|
|
|
// 将 data 字段解析为 map
|
|
var dataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
|
|
return nil, fmt.Errorf("解析 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 删除指定字段
|
|
delete(dataMap, "swift_number")
|
|
delete(dataMap, "DataStrategy")
|
|
|
|
// 重新编码为 JSON
|
|
modifiedData, err := json.Marshal(dataMap)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
|
|
}
|
|
return modifiedData, nil
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG34BJ03Request(params []byte) ([]byte, error) {
|
|
name := gjson.GetBytes(params, "name")
|
|
idCard := gjson.GetBytes(params, "id_card")
|
|
|
|
if !name.Exists() || !idCard.Exists() {
|
|
return nil, errors.New("api请求, G34BJ03, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"id_card": a.westDexService.Encrypt(idCard.String()),
|
|
"name": a.westDexService.Encrypt(name.String()),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G34BJ03", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
dataResult := gjson.GetBytes(resp, "negative_info.data.risk_level")
|
|
if dataResult.Exists() {
|
|
// 如果字段存在，构造包含 "status" 的 JSON 响应
|
|
responseMap := map[string]string{"risk_level": dataResult.String()}
|
|
jsonResponse, err := json.Marshal(responseMap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return jsonResponse, nil
|
|
} else {
|
|
return nil, errors.New("查询为空")
|
|
}
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG35SC01Request(params []byte) ([]byte, error) {
|
|
name := gjson.GetBytes(params, "name")
|
|
idCard := gjson.GetBytes(params, "id_card")
|
|
|
|
if !name.Exists() || !idCard.Exists() {
|
|
return nil, errors.New("api请求, G35SC01, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"idcard": a.westDexService.Encrypt(idCard.String()),
|
|
"name": a.westDexService.Encrypt(name.String()),
|
|
"inquired_auth": a.westDexService.GetDateRange(),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G35SC01", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
// 第一步：提取外层的 data 字段
|
|
dataResult := gjson.GetBytes(resp, "data")
|
|
if !dataResult.Exists() {
|
|
return nil, fmt.Errorf("外层 data 字段不存在")
|
|
}
|
|
|
|
// 第二步：解析外层 data 的 JSON 字符串
|
|
var outerDataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(dataResult.String()), &outerDataMap); err != nil {
|
|
return nil, fmt.Errorf("解析外层 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 第三步：提取内层的 data 字段
|
|
innerData, ok := outerDataMap["data"].(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("内层 data 字段不存在或类型错误")
|
|
}
|
|
|
|
// 第四步：解析内层 data 的 JSON 字符串
|
|
var finalDataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(innerData), &finalDataMap); err != nil {
|
|
return nil, fmt.Errorf("解析内层 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 将最终的 JSON 对象编码为字节数组返回
|
|
finalDataBytes, err := json.Marshal(finalDataMap)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("编码最终的 JSON 对象失败: %v", err)
|
|
}
|
|
|
|
return finalDataBytes, nil
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG28BJ05Request(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请求, G28BJ05, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"id": a.westDexService.Encrypt(idCard.String()),
|
|
"name": a.westDexService.Encrypt(name.String()),
|
|
"cell": a.westDexService.Encrypt(mobile.String()),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("G28BJ05", request)
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
// 获取 code 字段
|
|
codeResult := gjson.GetBytes(resp, "code")
|
|
if !codeResult.Exists() {
|
|
return nil, fmt.Errorf("code 字段不存在")
|
|
}
|
|
if codeResult.String() != "00" {
|
|
return nil, fmt.Errorf("未匹配到相关结果")
|
|
}
|
|
|
|
// 获取 data 字段
|
|
dataResult := gjson.GetBytes(resp, "data")
|
|
if !dataResult.Exists() {
|
|
return nil, fmt.Errorf("data 字段不存在")
|
|
}
|
|
|
|
// 将 data 字段解析为 map
|
|
var dataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(dataResult.Raw), &dataMap); err != nil {
|
|
return nil, fmt.Errorf("解析 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 删除指定字段
|
|
delete(dataMap, "swift_number")
|
|
delete(dataMap, "DataStrategy")
|
|
|
|
// 重新编码为 JSON
|
|
modifiedData, err := json.Marshal(dataMap)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("编码修改后的 data 失败: %v", err)
|
|
}
|
|
return modifiedData, nil
|
|
}
|
|
|
|
func (a *ApiRequestService) ProcessG05HZ01Request(params []byte) ([]byte, error) {
|
|
idCard := gjson.GetBytes(params, "id_card")
|
|
|
|
if !idCard.Exists() {
|
|
return nil, errors.New("api请求, G05HZ01, 获取相关参数失败")
|
|
}
|
|
|
|
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 字段")
|
|
}
|
|
// 返回 data 字段的内容
|
|
return []byte(data.Raw), nil
|
|
}
|
|
|
|
// 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")
|
|
|
|
if !entName.Exists() || !entCode.Exists() {
|
|
return nil, errors.New("api请求, Q23SC01, 获取相关参数失败")
|
|
}
|
|
|
|
request := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"uscc": a.westDexService.Encrypt(entCode.String()),
|
|
"org_name": a.westDexService.Encrypt(entName.String()),
|
|
"inquired_auth": a.westDexService.GetDateRange(),
|
|
},
|
|
}
|
|
resp, callApiErr := a.westDexService.CallAPI("Q23SC01", request)
|
|
logx.Infof("企业涉诉返回%+v", string(resp))
|
|
if callApiErr != nil {
|
|
return nil, callApiErr
|
|
}
|
|
// 第一步：提取外层的 data 字段
|
|
dataResult := gjson.GetBytes(resp, "data")
|
|
if !dataResult.Exists() {
|
|
return nil, fmt.Errorf("外层 data 字段不存在")
|
|
}
|
|
|
|
// 第二步：解析外层 data 的 JSON 字符串
|
|
var outerDataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(dataResult.String()), &outerDataMap); err != nil {
|
|
return nil, fmt.Errorf("解析外层 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 第三步：提取内层的 data 字段
|
|
innerData, ok := outerDataMap["data"].(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("内层 data 字段不存在或类型错误")
|
|
}
|
|
|
|
// 第四步：解析内层 data 的 JSON 字符串
|
|
var finalDataMap map[string]interface{}
|
|
if err := json.Unmarshal([]byte(innerData), &finalDataMap); err != nil {
|
|
return nil, fmt.Errorf("解析内层 data 字段失败: %v", err)
|
|
}
|
|
|
|
// 将最终的 JSON 对象编码为字节数组返回
|
|
finalDataBytes, err := json.Marshal(finalDataMap)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("编码最终的 JSON 对象失败: %v", err)
|
|
}
|
|
|
|
statusResult := gjson.GetBytes(finalDataBytes, "status.status")
|
|
if statusResult.Exists() || statusResult.Int() == -1 {
|
|
return nil, fmt.Errorf("企业涉诉为空: %+v", finalDataBytes)
|
|
}
|
|
return finalDataBytes, nil
|
|
}
|