new feature

app/user/cmd/api/internal/service/apirequestService.go

@@ -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
+}