lone-services/services/express/internal/logic/expressJdBackLogic.go

package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/rpc/express/pb"
	"lone-services/services/express/internal/dao"
	"lone-services/services/express/internal/model"
	"lone-services/services/express/internal/svc"
	"lone-services/services/express/internal/transit"
	"strconv"

	jsoniter "github.com/json-iterator/go"
	"github.com/zeromicro/go-zero/core/logx"
)

type ExpressJdBackLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
	BaseLogic
}

func NewExpressJdBackLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ExpressJdBackLogic {
	return &ExpressJdBackLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *ExpressJdBackLogic) ExpressJdBack(in *express.JdRequest) (*express.SfResponse, error) {
	body := utils.GetBody(l.ctx)
	ret := express.SfResponse{
		ReturnCode: "1001",
		ReturnMsg:  "body获取失败",
	}
	if body == utils.StringEmpty {
		return &ret, nil
	}
	l.Logger.Info("JD back data:", body)

	ret.ReturnCode = "1002"
	ret.ReturnMsg = "系统异常"
	ok := l.JdBack(body)
	if ok {
		ret.ReturnCode = "000"
		ret.ReturnMsg = "成功"
	}

	return &ret, nil
}

func (l *ExpressJdBackLogic) JdBack(body string) bool {
	var bodyData map[string]interface{}
	err := jsoniter.Unmarshal([]byte(body), &bodyData)
	if err != nil {
		l.Logger.Error("back body strInt error ", err)
		return false
	}
	result, ok := bodyData["Body"].(map[string]interface{})
	if !ok {
		l.Logger.Error("back Body interface error ")
		return false
	}

	l.Logger.Error("back body strInt result ", result)
	waybillNo := utils.GetStringByMap(result, "waybillNo")
	if waybillNo == utils.StringEmpty {
		l.Logger.Error("back body no id error ")
		return false
	}

	w := modelbase.Params{Eq: map[string]string{
		"status":       strconv.Itoa(dao.SendStatusOk),
		"transit_type": strconv.Itoa(dao.ExpressCompanyJd),
		"transit_sn":   waybillNo}}
	var info dao.DeliveryOrderUpTransit
	modelObj := model.DeliveryOrderModel{}.Init()
	err = modelObj.GetOne(w, &info)
	if err != nil || info.Id < utils.NumberOne {
		l.Logger.Error("没有找到快递数据", err)
		return true
	}
	var items []dao.ExpressQueryItems
	if len(info.TransitQuery) > utils.NumberTen {
		ok := utils.JsonStringToStruct(info.TransitQuery, &items)
		if ok != true {
			l.Logger.Error("back json error ", err)
			return false
		}
	}

	tmp := dao.ExpressQueryItems{
		Remark:       result["remark"].(string),
		AcceptTime:   result["operationTime"].(string),
		OperatorName: result["operatorName"].(string),
		OpCode:       result["operationCode"].(string),
		AllInfo:      body,
	}
	tmp.LastMd5 = utils.MD5Encrypt(tmp.Remark + tmp.AcceptTime +
		tmp.OperatorName)
	if len(items) > utils.NumberZero {
		if items[len(items)-utils.NumberOne].LastMd5 == tmp.LastMd5 {
			return true
		}
	}

	items = append(items, tmp)
	info.TransitQuery = utils.StructToJson(items)
	modelObj.Begin()
	if ok := transit.JdSingedCodeMap[tmp.OpCode]; ok {
		w = modelbase.Params{Eq: map[string]string{"deliver_goods_id": strconv.Itoa(info.Id)}}
		expEdit := dao.DeliveryExpStatus{
			Status: utils.StatusOk,
		}
		_, err = model.DeliveryOrderExpModel{}.Init().Edit(w, &expEdit)
		if err != nil {
			l.Logger.Error("back set deliver exp error ", err)
			modelObj.Rollback()
			return false
		}
		info.Status = dao.SendStatusOver
		info.ChangeEstimatedTime = utils.StatusFail
		info.SignTime = utils.Now()

		s := svc.UpOrderDeliverStatus(l.svcCtx.OrderSvcName, info.ObjId, int(info.Type), int32(info.Status))
		if s != utils.Ok {
			modelObj.Rollback()
			return false
		}
	}

	_, err = modelObj.Edit(w, &info)
	if err != nil {
		modelObj.Rollback()
		l.Logger.Error("back edit error ", err)
		return false
	}
	modelObj.Commit()
	return true
}