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

package logic

import (
	"context"
	"errors"
	"io"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/services/express/internal/dao"
	"lone-services/services/express/internal/model"
	"lone-services/services/express/internal/transit"
	"lone-services/services/express/validator"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	"lone-services/rpc/express/pb"
	"lone-services/services/express/internal/svc"

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

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

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

func (l *PrintExpressPrintLogic) PrintExpressPrint(in *express.PrintExpressPrintRequest) (*express.Response, error) {
	var v validator.PrintOrderUseValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}
	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return l.fail(utils.ErrorNoLoginInfo)
	}

	var itemsEdit []dao.DeliveryOrderPrintEdit
	w := modelbase.Params{
		Eq: map[string]string{"id": strconv.FormatInt(in.Id, utils.NumberTen)}}
	modelObj := model.DeliveryOrderModel{}.Init()
	err := modelObj.Items(w, &itemsEdit)
	if err != nil {
		l.Logger.Error(err)
		return l.fail(utils.Fail)
	}

	if len(itemsEdit) < utils.NumberOne {
		return l.fail(utils.ErrorNotFund)
	}

	if itemsEdit[utils.NumberZero].Status == dao.SendStatusOk ||
		itemsEdit[utils.NumberZero].Status == dao.SendStatusOver {
		return l.fail(utils.SetError(utils.ErrorNotFund, "该订单已完结"))
	}

	if in.TransitId < utils.NumberOne {
		in.TransitId = int64(utils.GetConfigInt("transit.send_id"))
	}
	tw := modelbase.Params{Eq: map[string]string{"id": strconv.FormatInt(in.TransitId, utils.NumberTen)}}
	var transitInfo dao.ExpressSend
	err = model.ExpressModel{}.Init().GetOne(tw, &transitInfo)
	if err != nil {
		l.Logger.Error("发货地址信息没有找到", in.TransitId, err)
		return l.fail(utils.SetError(utils.ErrorNotFund, "没有查询到发货信息"))
	}
	if transitInfo.Id < utils.NumberOne {
		return l.fail(utils.SetError(utils.ErrorNotFund, "没有查询到发货信息"))
	}

	var items []dao.DeliveryOrderPrint
	items = append(items, dao.DeliveryOrderPrint{
		DeliveryOrderPrintEdit: itemsEdit[utils.NumberZero],
	})
	svc.Print{}.GetOrderInfo(l.svcCtx.ProductSvcName, &items)
	info := itemsEdit[utils.NumberZero]
	//更新使用的快递类型
	info.TransitType = transitInfo.TransitId

	info.OrderSn = svc.Print{}.GetOrderSn(info.TransitType, int(adminInfo.ID))
	items[utils.NumberZero].OrderSn = info.OrderSn
	client, res, cErr := l.createTransit(items[utils.NumberZero], transitInfo)
	if cErr != utils.Ok {
		return l.fail(cErr)
	}
	info.TransitInfo = res.PostInfo
	info.TransitContent = res.RequestInfo
	info.TransitSn = strings.Join(res.WaybillNo, utils.DecollatorComma)

	items[utils.NumberZero].AdminName = adminInfo.Name
	res2, gErr := l.getDown(client, res.WaybillNo, items[utils.NumberZero])
	if gErr != nil {
		retStatus := svc.Cancel(client, w, info, dao.SendStatusCancel, l.svcCtx.OrderSvcName)
		if retStatus != utils.Ok {
			return l.fail(retStatus)
		}
		l.Logger.Error(res2, gErr)
		return l.fail(utils.SetError(utils.ErrorNotFund, "下载发货单出错"))
	}

	info.Express = utils.StructToJson(res2.Files)
	info.PrintStatus = utils.StatusOk
	info.AdminId = int(adminInfo.ID)
	info.AdminName = adminInfo.Name
	info.TransitId = int(in.TransitId)
	info.TransitName = transitInfo.Name
	info.Status = dao.SendStatusOk
	info.SendTime = utils.Now()

	items[utils.NumberZero].PrintStatus = info.PrintStatus
	items[utils.NumberZero].AdminId = info.AdminId
	items[utils.NumberZero].AdminName = info.AdminName
	items[utils.NumberZero].TransitId = info.TransitId
	items[utils.NumberZero].TransitInfo = info.TransitInfo
	items[utils.NumberZero].TransitContent = info.TransitContent
	items[utils.NumberZero].TransitSn = info.TransitSn
	items[utils.NumberZero].TransitName = info.TransitName
	items[utils.NumberZero].Status = info.Status
	items[utils.NumberZero].Express = info.Express

	var history dao.DeliveryHistoryCreate
	history.DeliverId = info.Id
	history.TransitName = dao.DeliverySendType[info.TransitType]
	history.TransitInfo = info.TransitInfo
	history.TransitContent = info.TransitContent
	history.TransitType = info.TransitType
	history.OrderSn = info.OrderSn

	var exps []dao.DeliveryExpCreate
	for i := 0; i < len(res.WaybillNo); i++ {
		exps = append(exps, dao.DeliveryExpCreate{
			DeliveryOrderId: info.Id,
			TransitType:     info.TransitType,
			ExpSn:           res.WaybillNo[i],
			OrderSn:         info.OrderSn,
		})
	}

	sErr := l.saveDelever(w, &info, &history, &exps)
	if sErr != utils.Ok {
		retStatus := svc.Cancel(client, w, info, dao.SendStatusCancel, l.svcCtx.OrderSvcName)
		if retStatus != utils.Ok {
			return l.fail(retStatus)
		}
		l.Logger.Error(res2, sErr)
		return l.fail(sErr)
	}

	return l.ok(items[utils.NumberZero])
}

func (l *PrintExpressPrintLogic) createTransit(info dao.DeliveryOrderPrint, transitInfo dao.ExpressSend) (transit.Transit, transit.TransitResult, utils.Status) {
	var client transit.Transit
	switch transitInfo.TransitId {
	case dao.ExpressCompanySf:
		client = transit.NewSfClient(transitInfo)
	case dao.ExpressCompanyJd:
		client = transit.NewJdClient(transitInfo)
	default:
		return client, transit.TransitResult{}, utils.SetError(utils.Fail, "不支持的快递公司")
	}
	res, err := client.Create(info)
	if err != nil || res.ErrorCode != utils.StringStatusOk {
		l.Logger.Error("create transit err", err, res)
		return client, res, utils.SetError(utils.Fail, res.ApiErrorMsg)
	}

	return client, res, utils.Ok
}

func (l *PrintExpressPrintLogic) getDown(client transit.Transit, orders []string, info dao.DeliveryOrderPrint) (transit.TransitResult, error) {
	ret, err := client.DownSheet(orders, info)
	if err != nil || len(ret.Files) < utils.NumberOne {
		l.Logger.Error("get down err ", orders, err, ret)
		if len(ret.Files) < utils.NumberOne {
			err = errors.New("files is empty")
		}
		return ret, err
	}
	path := utils.GetConfigString("transit.path") + "/"
	var tmpFiles []transit.TransitFiles
	for i := 0; i < len(ret.Files); i++ {
		tName := ret.Files[i].WaybillNo + ".pdf"
		err := l.downloadSfPDF(ret.Files[i], path+tName)
		if err != nil {
			l.Logger.Error("get down err ", orders, err, ret)
			return ret, err
		}

		tmpFiles = append(tmpFiles, transit.TransitFiles{
			File:      tName,
			WaybillNo: ret.Files[i].WaybillNo,
		})
	}

	ret.Files = tmpFiles

	return ret, nil
}

func (l *PrintExpressPrintLogic) downloadSfPDF(file transit.TransitFiles, path string) error {
	req, err := http.NewRequest("GET", file.Url, nil)
	if err != nil {
		return err
	}

	// 2. 必须加这个请求头（顺丰强制）
	req.Header.Add("X-Auth-token", file.Token)
	// 3. 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer func(Body io.ReadCloser) {
		err := Body.Close()
		if err != nil {
			utils.Logger.Error(err)
		}
	}(resp.Body)
	// 4. 创建目录
	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
		return err
	}
	// 5. 创建文件并保存
	outFile, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func(outFile *os.File) {
		err = outFile.Close()
		if err != nil {
			utils.Logger.Error(err)
		}
	}(outFile)
	// 6. 拷贝数据
	_, err = io.Copy(outFile, resp.Body)
	return err
}

func (l *PrintExpressPrintLogic) saveDelever(w modelbase.Params, info *dao.DeliveryOrderPrintEdit, history *dao.DeliveryHistoryCreate, exps *[]dao.DeliveryExpCreate) utils.Status {
	modelObj := model.DeliveryOrderModel{}.Init()
	modelObj.Begin()
	edit, err := modelObj.Edit(w, info)
	if err != nil || edit < utils.NumberOne {
		modelObj.Rollback()
		l.Logger.Error("save deliver goods err ", err)
		return utils.SetError(utils.Fail, "生成快递单失败")
	}

	err = model.DeliveryOrderExpModel{}.Init().CreateMulti(exps)
	if err != nil {
		modelObj.Rollback()
		l.Logger.Error("save exp err ", err)
		return utils.SetError(utils.Fail, "生成EXP失败")
	}

	err = model.DeliveryHistoryModel{}.Init().Create(history)
	if err != nil {
		modelObj.Rollback()
		l.Logger.Error("save history err ", err)
		return utils.SetError(utils.Fail, "生成订单历史失败")
	}
	s := svc.UpOrderDeliverStatus(l.svcCtx.OrderSvcName, info.ObjId, int(info.Type), int32(info.Status))
	if s != utils.Ok {
		modelObj.Rollback()
		l.Logger.Error("save update order err ", err)
		return s
	}

	modelObj.Commit()
	return utils.Ok
}