281 lines
7.8 KiB
Go
281 lines
7.8 KiB
Go
package service
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"qnc-server/config"
|
|
"qnc-server/db"
|
|
"qnc-server/model/model"
|
|
"qnc-server/model/request"
|
|
"qnc-server/model/response"
|
|
"qnc-server/utils"
|
|
)
|
|
|
|
type LawsuitQueryService struct {
|
|
}
|
|
|
|
func (l *LawsuitQueryService) QueryList(reqData request.LawsuitQueryReq) (data []response.CaseDetail, err error) {
|
|
baseURL := config.ConfigData.LawsuitQuery.ListURL
|
|
appCode := config.ConfigData.LawsuitQuery.AppCode
|
|
// 创建查询参数
|
|
params := url.Values{}
|
|
params.Add("sign", utils.GenerateMD5())
|
|
params.Add("entityName", reqData.Name)
|
|
params.Add("entityId", reqData.CardNo)
|
|
params.Add("needBranch", "1")
|
|
params.Add("fl", "1")
|
|
|
|
// 构建完整的请求 URL
|
|
requestURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
|
|
|
|
// 创建请求
|
|
reqBody := bytes.NewBuffer([]byte{})
|
|
req, err := http.NewRequest("POST", requestURL, reqBody)
|
|
if err != nil {
|
|
log.Printf("failed 创建请求: %v", err)
|
|
return
|
|
}
|
|
// 设置请求头
|
|
req.Header.Set("Authorization", "APPCODE "+appCode)
|
|
// 发送请求
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
log.Printf("failed 发送请求: %v", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// 读取响应体
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
log.Printf("failed 读取响应体: %v", err)
|
|
return
|
|
}
|
|
var queryResp response.LawsuitQueryListResponse
|
|
err = json.Unmarshal(body, &queryResp)
|
|
if err != nil {
|
|
log.Printf("query list failed to unmarshal response: %v", err)
|
|
return
|
|
}
|
|
switch queryResp.Rc {
|
|
case "0000":
|
|
var respData response.LawsuitQueryListData
|
|
queryRespBytes, err := json.Marshal(queryResp.Data)
|
|
if err != nil {
|
|
log.Printf("queryResp Marshal Error: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
err = json.Unmarshal(queryRespBytes, &respData)
|
|
if err != nil {
|
|
log.Printf("sxr queryResp Unmarshal Error: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
return respData.List, nil
|
|
case "0001":
|
|
log.Printf("涉诉专业版查询成功无数据: %v", queryResp.Msg)
|
|
return data, nil
|
|
case "1000":
|
|
log.Printf("apikey校验失败: %v", err)
|
|
return data, fmt.Errorf("响应错误，请稍后再试")
|
|
default:
|
|
log.Printf("未知响应代码: %s", queryResp.Rc)
|
|
return data, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
}
|
|
|
|
func (l *LawsuitQueryService) QuerySxrList(reqData request.LawsuitQueryReq) (data []response.SxrDetail, err error) {
|
|
baseURL := config.ConfigData.LawsuitQuery.SxrURL
|
|
appCode := config.ConfigData.LawsuitQuery.AppCode
|
|
// 创建查询参数
|
|
params := url.Values{}
|
|
params.Add("sign", utils.GenerateMD5())
|
|
params.Add("entityName", reqData.Name)
|
|
params.Add("entityId", reqData.CardNo)
|
|
params.Add("btype", "1")
|
|
params.Add("related", "0")
|
|
|
|
// 构建完整的请求 URL
|
|
requestURL := fmt.Sprintf("%s?%s", baseURL, params.Encode())
|
|
|
|
// 创建请求
|
|
reqBody := bytes.NewBuffer([]byte{})
|
|
req, err := http.NewRequest("POST", requestURL, reqBody)
|
|
if err != nil {
|
|
log.Printf("failed 创建请求: %v", err)
|
|
return
|
|
}
|
|
// 设置请求头
|
|
req.Header.Set("Authorization", "APPCODE "+appCode)
|
|
// 发送请求
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
log.Printf("failed 发送请求: %v", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// 读取响应体
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
log.Printf("failed 读取响应体: %v", err)
|
|
return
|
|
}
|
|
var queryResp response.LawsuitQueryListResponse
|
|
err = json.Unmarshal(body, &queryResp)
|
|
if err != nil {
|
|
log.Printf("sxr failed to unmarshal response: %v", err)
|
|
return
|
|
}
|
|
switch queryResp.Rc {
|
|
case "0000":
|
|
var respData []response.SxrDetail
|
|
queryRespBytes, err := json.Marshal(queryResp.Data)
|
|
if err != nil {
|
|
log.Printf("queryResp Marshal Error: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
err = json.Unmarshal(queryRespBytes, &respData)
|
|
if err != nil {
|
|
log.Printf("sxr queryResp Unmarshal Error: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
return respData, nil
|
|
case "0001":
|
|
return data, nil
|
|
case "1000":
|
|
log.Printf("apikey校验失败: %v", err)
|
|
return data, fmt.Errorf("响应错误，请稍后再试")
|
|
default:
|
|
log.Printf("未知响应代码: %s", queryResp.Rc)
|
|
return data, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
}
|
|
|
|
func (l *LawsuitQueryService) QueryLimitHighList(reqData request.LawsuitQueryReq) (data []response.LimitHightDetail, err error) {
|
|
baseURL := config.ConfigData.LawsuitQuery.LimitHightURL
|
|
appCode := config.ConfigData.LawsuitQuery.AppCode
|
|
// 创建查询参数
|
|
params := url.Values{}
|
|
params.Add("name", reqData.Name)
|
|
params.Add("idcard_number", reqData.CardNo)
|
|
params.Add("mobile_number", reqData.Mobile)
|
|
|
|
// 创建请求
|
|
reqBody := bytes.NewBufferString(params.Encode())
|
|
req, err := http.NewRequest("POST", baseURL, reqBody)
|
|
if err != nil {
|
|
log.Printf("failed 创建请求: %v", err)
|
|
return
|
|
}
|
|
// 设置请求头
|
|
req.Header.Set("Authorization", "APPCODE "+appCode)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
|
|
// 发送请求
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
log.Printf("failed 发送请求: %v", err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// 读取响应体
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
log.Printf("failed 读取响应体: %v", err)
|
|
return
|
|
}
|
|
|
|
var queryResp response.LawsuitLimitHightQueryListResponse
|
|
err = json.Unmarshal(body, &queryResp)
|
|
if err != nil {
|
|
log.Printf("limit hight failed to unmarshal response: %v", err)
|
|
return
|
|
}
|
|
switch queryResp.Code {
|
|
case 200:
|
|
var respData response.LimitHightData
|
|
queryRespBytes, err := json.Marshal(queryResp.Data)
|
|
if err != nil {
|
|
log.Printf("limit hight Marshal Error: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
err = json.Unmarshal(queryRespBytes, &respData)
|
|
if err != nil {
|
|
log.Printf("limit hight failed to unmarshal data: %v", err)
|
|
return nil, fmt.Errorf("响应错误，请稍后再试")
|
|
}
|
|
return respData.CaseList, nil
|
|
case 400:
|
|
return data, nil
|
|
default:
|
|
log.Printf("%s响应错误: %s", params.Encode(), queryResp.Msg)
|
|
return data, fmt.Errorf("请求错误：%s", queryResp.Msg)
|
|
}
|
|
}
|
|
func (l *LawsuitQueryService) SaveLawsuit(userid uint, reqBody request.LawsuitQueryReq, orderID uint, combinedResponse response.CombinedResponse) (err error) {
|
|
ListRespMarshal, err := json.Marshal(combinedResponse.ListResp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
SxrRespMarshal, err := json.Marshal(combinedResponse.SxrResp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
LimitHightRespMarshal, err := json.Marshal(combinedResponse.LimitHightResp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = db.DB.Create(&model.Lawsuit{
|
|
UserID: userid,
|
|
CardNo: reqBody.CardNo,
|
|
Name: reqBody.Name,
|
|
Mobile: reqBody.Mobile,
|
|
ListResp: string(ListRespMarshal),
|
|
SxrResp: string(SxrRespMarshal),
|
|
LimitHightResp: string(LimitHightRespMarshal),
|
|
OrderID: orderID,
|
|
}).Error
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return
|
|
}
|
|
|
|
func (l *LawsuitQueryService) CheckPayment(userid uint) (payment bool, err error) {
|
|
var lawsuits []model.Lawsuit
|
|
err = db.DB.Where("userid = ?", userid).Order("id desc").Limit(2).Find(&lawsuits).Error
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if len(lawsuits) == 0 {
|
|
return true, nil
|
|
}
|
|
checkFields := func(lawsuit model.Lawsuit) bool {
|
|
return (lawsuit.ListResp == "" || lawsuit.ListResp == "null") &&
|
|
(lawsuit.SxrResp == "" || lawsuit.SxrResp == "null") &&
|
|
(lawsuit.LimitHightResp == "" || lawsuit.LimitHightResp == "null")
|
|
}
|
|
|
|
if len(lawsuits) == 1 {
|
|
if checkFields(lawsuits[0]) {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
if len(lawsuits) == 2 {
|
|
if checkFields(lawsuits[0]) && !checkFields(lawsuits[1]) {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
return true, nil
|
|
}
|