300 lines
9.2 KiB
Go
300 lines
9.2 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/redis/go-redis/v9"
|
|
"gorm.io/gorm"
|
|
"log"
|
|
"net/http"
|
|
"qnc-server/config"
|
|
"qnc-server/db"
|
|
"qnc-server/model/model"
|
|
"qnc-server/model/request"
|
|
"qnc-server/model/response"
|
|
"qnc-server/model/types"
|
|
"qnc-server/service"
|
|
"qnc-server/utils"
|
|
)
|
|
|
|
type LawsuitQuery struct {
|
|
}
|
|
|
|
// 注册路由
|
|
func InitLawsuitQuery(group *gin.RouterGroup) {
|
|
var l LawsuitQuery
|
|
lawsuitQueryPrivateGroup := group.Group("lawsuitQuery")
|
|
lawsuitQueryPrivateGroup.Use(JWTAuth())
|
|
lawsuitQueryPrivateGroup.POST("query_v2", l.queryListV2)
|
|
lawsuitQueryPrivateGroup.GET("get_record", l.GetRecord)
|
|
}
|
|
|
|
var lawsuitQueryService service.LawsuitQueryService
|
|
var orderService service.OrderService
|
|
|
|
func (l *LawsuitQuery) queryListV2(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
var reqBody request.LawsuitQueryV2Req
|
|
if err := c.ShouldBindJSON(&reqBody); err != nil {
|
|
response.FailWithMessage("Failed to read request body", c)
|
|
return
|
|
}
|
|
if *reqBody.Type == types.Individual {
|
|
if config.ConfigData.Verify.Three {
|
|
// 三要素校验
|
|
westName, err := utils.WestDexEncrypt(reqBody.Name, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("西部加密错误：%v", err)
|
|
response.FailWithMessage("系统错误，请稍后再试", c)
|
|
return
|
|
}
|
|
westIDCard, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("西部加密错误：%v", err)
|
|
response.FailWithMessage("系统错误，请稍后再试", c)
|
|
return
|
|
}
|
|
westPhone, err := utils.WestDexEncrypt(reqBody.Mobile, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("西部加密错误：%v", err)
|
|
response.FailWithMessage("系统错误，请稍后再试", c)
|
|
return
|
|
}
|
|
threeElementsReq := map[string]interface{}{
|
|
"name": westName,
|
|
"idNo": westIDCard,
|
|
"phone": westPhone,
|
|
}
|
|
|
|
threeElements, err := requestService.WestDexRequest("G15BJ02", threeElementsReq)
|
|
var data response.Wrapper[response.ThreeElementsResponse]
|
|
err = json.Unmarshal([]byte(threeElements), &data)
|
|
if err != nil {
|
|
log.Printf("响应解析失败：%v", err)
|
|
response.FailWithMessage("系统错误，请稍后再试", c)
|
|
return
|
|
}
|
|
|
|
switch data.Data.Code {
|
|
case 1000:
|
|
case 1001:
|
|
response.FailWithMessage("姓名、证件号、手机号信息不一致", c)
|
|
return
|
|
case 1003:
|
|
response.FailWithMessage("姓名、证件号、手机号信息不一致", c)
|
|
return
|
|
case 1004:
|
|
response.FailWithMessage("姓名不正确", c)
|
|
return
|
|
case 1005:
|
|
response.FailWithMessage("证件号码不正确", c)
|
|
return
|
|
default:
|
|
log.Printf("三要素检测错误%v", data.Data.Msg)
|
|
response.FailWithMessage("服务器错误请稍后再试", c)
|
|
return
|
|
}
|
|
} else {
|
|
// 二要素核验
|
|
twoElementsParams := map[string]any{
|
|
"name": reqBody.Name,
|
|
"idcard": reqBody.CardNo,
|
|
}
|
|
twoElementsRespStr, err := requestService.AliYunRequest(http.MethodPost, "https://kzidcardv1.market.alicloudapi.com/api-mall/api/id_card/check", nil, twoElementsParams)
|
|
var twoElementsResp response.TwoElementsResp
|
|
err = json.Unmarshal([]byte(twoElementsRespStr), &twoElementsResp)
|
|
if err != nil {
|
|
log.Printf("【二要素】解析错误：%v", err)
|
|
response.FailWithMessage("系统错误，请稍后再试", c)
|
|
return
|
|
}
|
|
|
|
if twoElementsResp.Success == false {
|
|
fmt.Printf("【二要素】身份证无效")
|
|
response.FailWithMessage("请输入有效的身份证号码", c)
|
|
return
|
|
}
|
|
if twoElementsResp.Code != 200 {
|
|
response.FailWithMessage(twoElementsResp.Msg, c)
|
|
return
|
|
}
|
|
if twoElementsResp.Data.Result == 1 {
|
|
fmt.Printf("【二要素】姓名与身份证不一致")
|
|
response.FailWithMessage("姓名与身份证不一致", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// 校验企业社会统一信用代码
|
|
isCreditCode := utils.ValidateUnifiedSocialCreditCode(reqBody.CardNo)
|
|
if isCreditCode == false {
|
|
response.FailWithMessage("请输入企业社会统一信用代码", c)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 校验验证码
|
|
isRight, err := utils.VerifyCode(reqBody.Mobile, reqBody.VerifyCode)
|
|
if err != nil {
|
|
response.FailWithMessage(err.Error(), c)
|
|
return
|
|
} else if !isRight {
|
|
response.FailWithMessage("验证码错误", c)
|
|
return
|
|
}
|
|
|
|
userid := utils.GetUserID(c)
|
|
// 查找是否有 未消费 已付费 的订单
|
|
order, err := orderService.QueryConsumedOrder(userid, "justiceLawsuit")
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
// 为空就没有消费资格
|
|
response.OkNeedPay(c)
|
|
return
|
|
} else {
|
|
log.Printf("QueryConsumedOrder err:%s", err.Error())
|
|
response.FailWithMessage("服务器错误请稍后再试", c)
|
|
return
|
|
}
|
|
}
|
|
var lawsuitReq map[string]interface{}
|
|
var reqCode string
|
|
if *reqBody.Type == types.Individual {
|
|
encodeName, err := utils.WestDexEncrypt(reqBody.Name, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("【司法涉诉】加密错误：%v", err)
|
|
response.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
encodeID, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("【司法涉诉】加密错误：%v", err)
|
|
response.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
lawsuitReq = map[string]interface{}{
|
|
"name": encodeName,
|
|
"id_card": encodeID,
|
|
}
|
|
reqCode = "G22BJ03"
|
|
} else {
|
|
encodeID, err := utils.WestDexEncrypt(reqBody.CardNo, "121a1e41fc1690dd6b90afbcacd80cf4")
|
|
if err != nil {
|
|
log.Printf("【司法涉诉】加密错误：%v", err)
|
|
response.FailWithMessage(err.Error(), c)
|
|
return
|
|
}
|
|
lawsuitReq = map[string]interface{}{
|
|
"ent_name": encodeID,
|
|
}
|
|
reqCode = "Q03BJ03"
|
|
}
|
|
|
|
// 发起请求并处理响应
|
|
plainText, err := requestService.WestDexRequest(reqCode, lawsuitReq)
|
|
if err != nil {
|
|
handleErrorAndRefund(order, userid, "接口系统错误，将自动退款", c)
|
|
return
|
|
}
|
|
|
|
var resp model.LawsuitResponse
|
|
err = json.Unmarshal([]byte(plainText), &resp)
|
|
if err != nil {
|
|
handleErrorAndRefund(order, userid, "司法诉讼记录解析错误", c)
|
|
return
|
|
}
|
|
|
|
if resp.Data.ErrCode != "200" {
|
|
handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼响应错误：%s", resp.Data.ErrMsg), c)
|
|
return
|
|
}
|
|
|
|
// 根据类型判断是个人信息还是公司信息
|
|
|
|
var respData json.RawMessage
|
|
|
|
if *reqBody.Type == types.Individual {
|
|
if resp.Data.Data.PersonInfo == nil || resp.Data.Data.PersonInfo.Code == "-1000" {
|
|
handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼查询失败：%s", resp.Data.Data.PersonInfo.Msg), c)
|
|
return
|
|
}
|
|
respData = resp.Data.Data.PersonInfo.Data
|
|
} else {
|
|
if resp.Data.Data.CompanyInfo == nil || resp.Data.Data.CompanyInfo.Code == "-1000" {
|
|
handleErrorAndRefund(order, userid, fmt.Sprintf("司法诉讼查询失败：%s", resp.Data.Data.CompanyInfo.Msg), c)
|
|
return
|
|
}
|
|
respData = resp.Data.Data.CompanyInfo.Data
|
|
}
|
|
|
|
var query model.Query
|
|
query.OrderID = order.ID
|
|
query.Code, _ = utils.EncryptCode(reqBody.Mobile, "776d538f1265a814437d2e12ac10b45b85045bc208a1eb129ef301f4157aa82f")
|
|
query.Userid = userid
|
|
query.ProductID = order.ProductID
|
|
db.DB.Create(&query)
|
|
uniqueID := utils.SetCacheData(ctx, respData)
|
|
// 更新订单状态并返回成功响应
|
|
orderService.OrderConsumed(order)
|
|
response.OkWithData(gin.H{
|
|
"record_id": uniqueID,
|
|
}, c)
|
|
}
|
|
|
|
// 错误处理和退款函数
|
|
func handleErrorAndRefund(order model.PayOrder, userid uint, msg string, c *gin.Context) {
|
|
log.Printf("【司法诉讼】%s", msg)
|
|
notifyService.SendNotification(msg, "司法诉讼", userid, order.ID)
|
|
if order.PaymentMethod == model.PaymentMethod_ALIPAY {
|
|
err := orderService.AliRefund(ctx, order)
|
|
if err != nil {
|
|
notifyService.SendNotification("【支付宝】"+msg+"，自动退款失败", "司法诉讼", userid, order.ID)
|
|
} else {
|
|
notifyService.SendNotification("【支付宝】自动退款成功", order.Product.ProductName, order.Userid, order.ID)
|
|
}
|
|
} else {
|
|
err := orderService.WeChatRefund(order)
|
|
if err != nil {
|
|
notifyService.SendNotification(msg+"，自动退款失败", "司法诉讼", userid, order.ID)
|
|
}
|
|
}
|
|
response.FailRefund(c)
|
|
}
|
|
func (l *LawsuitQuery) GetRecord(c *gin.Context) {
|
|
var req request.GetLawsuitRecordReq
|
|
if err := c.ShouldBindQuery(&req); err != nil {
|
|
response.FailWithMessage("Failed to read request", c)
|
|
return
|
|
}
|
|
|
|
//userid := utils.GetUserID(c)
|
|
//record, err := lawsuitQueryService.QueryLawsuitByOrder(req.ID, userid)
|
|
//if err != nil {
|
|
// log.Printf("【司法涉诉】获取司法涉诉记录错误：%v", err)
|
|
// notifyService.SendNotification("系统错误，获取司法涉诉记录错误，请及时处理", "司法涉诉", userid, record.OrderID)
|
|
// response.FailRefund(c)
|
|
// return
|
|
//}
|
|
//var resp any
|
|
//err = json.Unmarshal([]byte(record.Resp), &resp)
|
|
//if err != nil {
|
|
// log.Printf("【司法涉诉】获取司法涉诉解析错误：%v", err)
|
|
// notifyService.SendNotification("系统错误，获取司法涉诉解析错误，请及时处理", "司法涉诉", userid, record.OrderID)
|
|
// return
|
|
//}
|
|
data, err := utils.GetCacheData(ctx, req.ID)
|
|
if err != nil {
|
|
if errors.Is(err, redis.Nil) {
|
|
response.Ok(c)
|
|
return
|
|
} else {
|
|
response.FailWithMessage("系统错误", c)
|
|
return
|
|
}
|
|
}
|
|
response.OkWithData(data, c)
|
|
}
|