qnc-server-old/service/singleQuery.go

package service

import (
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"qnc-server/config"
	"qnc-server/db"
	"qnc-server/model/model"
	"qnc-server/utils"
	"time"
)

type SingleQueryService struct {
}

func (s *SingleQueryService) EvaluateMarriageReqYuShan(data *model.EvaluateMarriagePayload) (plainText []byte, err error) {
	currentTime := time.Now()
	unixMilliseconds := currentTime.UnixNano() / int64(time.Millisecond)
	requestSN, _ := utils.GenerateRandomString()
	apiKey := config.ConfigData.Antifraud.ApiKey
	acctId := config.ConfigData.Antifraud.AcctId
	httpUrl := config.ConfigData.Antifraud.HttpUrl
	// 根据 ProdID 动态构建请求数据
	reqData := map[string]interface{}{
		"prod_id":    data.ProdID,
		"req_time":   unixMilliseconds,
		"request_sn": requestSN,
		"req_data":   map[string]interface{}{},
	}

	for _, param := range model.SingleQueryProdIDParams[data.ProdID] {
		switch param {
		case "cardNo":
			reqData["req_data"].(map[string]interface{})["cardNo"] = data.CardNo
		case "name":
			reqData["req_data"].(map[string]interface{})["name"] = data.Name
		case "pageNo":
			reqData["req_data"].(map[string]interface{})["pageNo"] = 1
		case "pageSize":
			reqData["req_data"].(map[string]interface{})["pageSize"] = 100
		}
	}
	messageBytes, err := json.Marshal(reqData)
	if err != nil {
		return
	}
	key, err := hex.DecodeString(apiKey)
	if err != nil {
		return
	}
	//加密
	cipherText := utils.AES_CBC_Encrypt(messageBytes, key)

	content := base64.StdEncoding.EncodeToString(cipherText)
	respStr, err := httpDo(httpUrl, content, acctId)
	if err != nil {
		return
	}
	//解密
	sDec, err := base64.StdEncoding.DecodeString(respStr)
	if err != nil {
		if utils.IsJSON(respStr) {
			return []byte(respStr), nil
		}
		return
	}
	plainText = utils.AES_CBC_Decrypt(sDec, key)
	return
}

// 对返回信息进行处理，返回一份完整的报告
func (a *SingleQueryService) DataAnalysis(respString string) (data map[string]interface{}, err error) {
	var resp model.YuShanResponse[map[string]interface{}]
	err = json.Unmarshal([]byte(respString), &resp)
	if err != nil {
		log.Printf("singleQuery Unmarshal error：%v", err)
		return nil, utils.ErrSystemError
	}
	if resp.Retcode == RetCodeSuccess {
		data = resp.Retdata
		return data, nil
	} else if resp.Retcode == RetCodeEmpty {
		log.Printf("singleQuery resp empty：%s", resp.Retmsg)
		return data, utils.ErrNoRecord
	} else {
		log.Printf("singleQuery resp error：%s", resp.Retmsg)
		return data, utils.ErrSystemError
	}
}

// 对返回信息进行处理，返回一份完整的报告
func (a *SingleQueryService) MarryDataAnalysis(respString string) (data []map[string]interface{}, err error) {
	var resp model.YuShanResponse[[]map[string]interface{}]
	err = json.Unmarshal([]byte(respString), &resp)
	if err != nil {
		log.Printf("singleQuery Unmarshal error：%v", err)
		return nil, utils.ErrSystemError
	}
	if resp.Retcode == RetCodeSuccess {
		data = resp.Retdata
		return data, nil
	} else if resp.Retcode == RetCodeEmpty {
		log.Printf("singleQuery resp empty：%s", resp.Retmsg)
		return data, utils.ErrNoRecord
	} else {
		log.Printf("singleQuery resp error：%s", resp.Retmsg)
		return data, utils.ErrSystemError
	}
}
func (a *SingleQueryService) MarryAnalysis(jsonStr string) (resp *model.MerryResponse, err error) {
	err = json.Unmarshal([]byte(jsonStr), &resp)
	if err != nil {
		fmt.Printf("【婚姻结果解析错误】JSON解析错误: %v\n", err)
		return
	}
	// 根据状态码分类处理
	switch resp.Code {
	case 201, 202, 203:
		return resp, nil
	case 300:
		return nil, utils.ErrNoRecord
	default:
		return nil, errors.New(resp.Msg)
	}
}
func (a *SingleQueryService) QueryEvaluateMarriageOrder(orderID uint) (m model.EvaluateMarriage, err error) {
	err = db.DB.Where("order_id = ?", orderID).First(&m).Error
	return
}

// 获取婚姻评估记录
func (a *SingleQueryService) QueryEvaluateMarriageRecord(id uint) (m model.EvaluateMarriage, err error) {
	err = db.DB.Where("id = ?", id).First(&m).Error
	return
}