lone-services/services/order/internal/logic/supplyStatusLogic.go

package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	chore "lone-services/rpc/chore/pb"
	express "lone-services/rpc/express/pb"
	"lone-services/rpc/order/pb"
	product "lone-services/rpc/product/pb"
	"lone-services/services/order/internal/dao"
	"lone-services/services/order/internal/model"
	"lone-services/services/order/internal/svc"
	"strconv"
	"strings"

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

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

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

func (l *SupplyStatusLogic) SupplyStatus(in *order.StatusRequest) (*order.Response, error) {
	var v validate.StatusValidator //status 2为拒绝 4为二审，1为通过
	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)
	}

	w := modelbase.Params{Eq: map[string]string{
		"id": strconv.FormatInt(in.Id, utils.NumberTen),
	},
	}

	var info dao.SupplyVerifyUpdate
	modelObj := model.SupplyModel{}.Init()
	err := modelObj.GetOne(w, &info)
	if err != nil {
		return l.fail(utils.Fail)
	}
	if info.Id < utils.NumberOne {
		return l.fail(utils.ErrorNotFund)
	}
	switch info.Status {
	case int32(dao.SupplyStatusSecondReview):
		info.Status = int32(dao.SupplyStatusReject)
		if in.Status == int32(dao.SupplyStatusOk) {
			info.Status = int32(dao.SupplyStatusOk)
		}
		info.AdminSecondId = adminInfo.ID
		info.AdminSecondName = adminInfo.Name
	case int32(dao.SupplyStatusFirstReview):
		info.Status = int32(dao.SupplyStatusReject)
		if in.Status == int32(dao.SupplyStatusOk) {
			info.Status = int32(dao.SupplyStatusSecondReview)
		}
		info.AdminId = adminInfo.ID
		info.AdminName = adminInfo.Name

	default:
		return l.fail(utils.ErrorNotFund)
	}

	info.VerifyReason = in.Reason

	modelObj.Begin()
	_, err = modelObj.Edit(w, &info)
	if err != nil {
		modelObj.Rollback()
		l.Logger.Error(err)
		return l.fail(utils.Fail)
	}

	deliverGoods, status := l.getDeliveryInfo(info)
	if status != utils.Ok {
		modelObj.Rollback()
		return l.fail(status)
	}

	sErr := l.createDelivery(deliverGoods)
	if sErr != utils.Ok {
		modelObj.Rollback()
		return l.fail(sErr)
	}

	modelObj.Commit()

	return l.ok(utils.NumberOne)
}

func (l *SupplyStatusLogic) createDelivery(data express.DeliveryOrderCreateRequest) utils.Status {
	cli, err := svc.GetRpcClient(l.svcCtx.ExpressSvcName)
	if err != nil {
		return utils.ErrorInternalServer
	}

	client := express.NewExpressClient(cli.Conn())
	_, err = client.DeliveryOrderCreate(l.ctx, &data)
	if err != nil {
		logx.Errorf("set products err: %v", err)
		return utils.ErrorInternalServer
	}
	return utils.Ok
}

func (l *SupplyStatusLogic) getDeliveryInfo(info dao.SupplyVerifyUpdate) (express.DeliveryOrderCreateRequest, utils.Status) {
	var orderInfo dao.OrderInfo
	w := modelbase.Params{Eq: map[string]string{"order_sn": info.OrderSn}}
	err := model.OrderModel{}.Init().GetOne(w, &orderInfo)
	if err != nil {
		logx.Errorf("get order err: %v", err)
		return express.DeliveryOrderCreateRequest{}, utils.Fail
	}
	if orderInfo.Id < utils.NumberOne {
		return express.DeliveryOrderCreateRequest{}, utils.ErrorNotFund
	}

	deliverGoods := express.DeliveryOrderCreateRequest{
		ObjId:     strconv.FormatInt(info.Id, utils.NumberTen),
		Mobile:    orderInfo.Mobile,
		Address:   orderInfo.Address,
		Addressee: orderInfo.Addressee,
		ObjSn:     info.OrderSn,
		Type:      dao.DeliverTypeSupply,
		Status:    dao.SendStatusWait,
	}

	w = modelbase.Params{Eq: map[string]string{"order_sn": info.OrderSn}}
	var orderProducts []dao.OrderProductInfo
	err = model.OrderProductModel{}.Init().Items(w, &orderProducts)
	if err != nil || len(orderProducts) < utils.NumberOne {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorNotFund
	}
	var productIds []int64
	idsNumber := make(map[int64]int)
	for _, item := range orderProducts {
		productIds = append(productIds, item.ProductId)
		idsNumber[item.ProductId] = item.Number
	}

	cli, err := svc.GetRpcClient(l.svcCtx.ProductSvcName)
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	productClient := product.NewProductClient(cli.Conn())
	productItems, err := productClient.ItemsByIds(l.ctx, &product.ItemsByIdsReq{Ids: productIds})
	if err != nil {
		logx.Errorf("get products err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	for _, item := range productItems.Items {
		number := utils.NumberZero
		if _, ok := idsNumber[item.Id]; ok {
			number = idsNumber[item.Id]
		}
		deliverGoods.ProductInfo = append(deliverGoods.ProductInfo, &express.DeliverOrderProductInfo{
			ProductId:   item.Id,
			Number:      int32(number),
			Type:        int32(item.Type),
			ProductName: item.Name,
			Price:       item.Price,
		})
	}

	clic, err := svc.GetRpcClient(l.svcCtx.ChoreSvcName)
	if err != nil {
		logx.Errorf("get region err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	var regionIds []int64
	for _, item := range strings.Split(orderInfo.DistrictIds, utils.DecollatorComma) {
		id, _ := strconv.Atoi(item)
		regionIds = append(regionIds, int64(id))
	}

	clicClient := chore.NewChoreClient(clic.Conn())
	regionItems, err := clicClient.RegionsByIds(l.ctx, &chore.RegionsByIdsReq{Ids: regionIds})
	if err != nil {
		logx.Errorf("get region err: %v", err)
		return deliverGoods, utils.ErrorInternalServer
	}

	switch len(regionItems.Items) {
	case utils.NumberOne:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
	case utils.NumberTwo:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
		deliverGoods.City = regionItems.Items[utils.NumberOne].Name
	case utils.NumberThree:
		deliverGoods.Province = regionItems.Items[utils.NumberZero].Name
		deliverGoods.City = regionItems.Items[utils.NumberOne].Name
		deliverGoods.County = regionItems.Items[utils.NumberTwo].Name
	}

	return deliverGoods, utils.Ok
}