service/app/mix/service/hvyogoservice.go

package service

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"service/api/message/request"
	"service/api/message/response"
	"service/bizcommon/util"
	"service/library/configcenter"
	"service/library/logger"
	"service/library/mycrypto"
	"strings"
	"time"

	hvyogoproto "service/api/proto/hvyogo/proto"
)

var DefaultHvyogoService *HvyogoService

type HvyogoService struct {
	CooperatorId string
	PositionId   string
}

func NewHvyogoService(cfg *configcenter.HvyogoConfig) *HvyogoService {
	return &HvyogoService{
		CooperatorId: cfg.CooperatorId,
		PositionId:   cfg.PositionId,
	}
}

func (s *HvyogoService) WorkerAgreeState(req *request.HYG10000001Req) (vo *hvyogoproto.WorkerAgreeStateVO, err error) {
	// 写参
	req.HYGBaseReq.CooperatorId = s.CooperatorId
	req.Timestamp = fmt.Sprint(time.Now().UnixMilli())

	// 加签
	msg, err := DefaultService.utilSignHvyogoMessage(req)
	if err != nil {
		logger.Error("utilSignHvyogoMessage fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 发送消息
	resp, err := DefaultEsbService.SendMsg("HYG10000001", msg)
	if err != nil {
		logger.Error("SendMsg fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 处理返回数据
	vo = &hvyogoproto.WorkerAgreeStateVO{}
	err = afterReceiving(resp, vo)
	if err != nil {
		logger.Error("afterReceiving fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}
	return
}

func (s *HvyogoService) WorkerFindDetail(req *request.HYG10000002Req) (vo *hvyogoproto.WorkerFindDetailsVO, err error) {
	// 写参
	req.HYGBaseReq.CooperatorId = s.CooperatorId
	req.Timestamp = fmt.Sprint(time.Now().UnixMilli())

	// 加签
	msg, err := DefaultService.utilSignHvyogoMessage(req)
	if err != nil {
		logger.Error("utilSignHvyogoMessage fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 发送消息
	resp, err := DefaultEsbService.SendMsg("HYG10000002", msg)
	if err != nil {
		logger.Error("SendMsg fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 处理返回数据
	vo = &hvyogoproto.WorkerFindDetailsVO{}
	err = afterReceiving(resp, vo)
	if err != nil {
		logger.Error("afterReceiving fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}
	return
}

func (s *HvyogoService) SingleDistribute(req *request.HYG10010001Req) (vo *hvyogoproto.SingleDistributeVO, err error) {
	// 写参
	req.HYGBaseReq.CooperatorId = s.CooperatorId
	req.Timestamp = fmt.Sprint(time.Now().UnixMilli())
	req.PositionId = s.PositionId

	// 加签
	msg, err := DefaultService.utilSignHvyogoMessage(req)
	if err != nil {
		logger.Error("utilSignHvyogoMessage fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 发送消息
	resp, err := DefaultEsbService.SendMsg("HYG10010001", msg)
	if err != nil {
		logger.Error("SendMsg fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 处理返回数据
	vo = &hvyogoproto.SingleDistributeVO{}
	err = afterReceiving(resp, vo)
	if err != nil {
		logger.Error("afterReceiving fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}
	return
}

func (s *HvyogoService) WorkerUpdate(req *request.HYG10010002Req) (vo *hvyogoproto.WorkerUpdateVO, err error) {
	// 写参
	req.HYGBaseReq.CooperatorId = s.CooperatorId
	req.Timestamp = fmt.Sprint(time.Now().UnixMilli())

	// 加签
	msg, err := DefaultService.utilSignHvyogoMessage(req)
	if err != nil {
		logger.Error("utilSignHvyogoMessage fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 发送消息
	resp, err := DefaultEsbService.SendMsg("HYG10010002", msg)
	if err != nil {
		logger.Error("SendMsg fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}

	// 处理返回数据
	vo = &hvyogoproto.WorkerUpdateVO{}
	err = afterReceiving(resp, vo)
	if err != nil {
		logger.Error("afterReceiving fail, req: %v, err: %v", util.ToJson(req), err)
		return
	}
	return
}

func afterReceiving(resp []byte, vo any) (err error) {
	baseResponse := &response.HygBaseResponse{}

	// 先将返回码和返回信息解码至vo
	err = json.Unmarshal(resp, vo)
	if err != nil {
		logger.Error("json Unmarshal fail, err: %v", err)
		return
	}

	// 解码response，若不成功则直接返回
	err = json.Unmarshal(resp, baseResponse)
	if err != nil {
		logger.Error("json Unmarshal fail, err: %v", err)
		return
	}
	if baseResponse.StatusCode != response.StatusCodeSuccess {
		return
	}

	// 获取aes加密串
	aesEncryptedStr, ok := baseResponse.Data.(string)
	if !ok {
		err = fmt.Errorf("type assertion fail")
		logger.Error("Type assertion fail, err: %v", err)
		return
	}

	// 十六进制解码
	encryptedStr, err := hex.DecodeString(strings.ToLower(aesEncryptedStr))
	if err != nil {
		logger.Error("Decryption fail, err: %v", err)
		return
	}

	// aes解码
	bytes, err := mycrypto.CryptoServiceInstance().HygAES.Decrypt([]byte(encryptedStr))
	if err != nil {
		logger.Error("Decryption fail, err: %v", err)
		return
	}

	// 解析至VO
	err = json.Unmarshal(bytes, vo)
	if err != nil {
		logger.Error("json Unmarshal fail, err: %v", err)
		return
	}

	return
}