发货grpc接口

zhangqian

2024-03-18 576039f5ee85910edd332aa4459a132b713e80bd

 proto/product_inventory/server.go

@@ -3,12 +3,14 @@
import (
   "context"
   "errors"
   "fmt"
   "github.com/shopspring/decimal"
   "strconv"
   "strings"
   "time"
   "wms/constvar"
   "wms/models"
   "wms/pkg/logx"
   "wms/pkg/timex"
   "wms/service"
)
@@ -295,11 +297,15 @@
      if detail.BaseOperationType == constvar.BaseOperationTypeIncoming && detail.Status == constvar.OperationStatus_Finish {
         if locationHouseMap[detail.ToLocationId] != nil {
            info.Warehouse = locationHouseMap[detail.ToLocationId].Name //入库仓库名
            info.LocationID = int64(detail.ToLocationId)
            info.WareHouseID = int64(locationHouseMap[detail.ToLocationId].Id)
         }
         inputList = append(inputList, &info)
      } else if detail.BaseOperationType == constvar.BaseOperationTypeOutgoing {
         if locationHouseMap[detail.FromLocationId] != nil {
            info.Warehouse = locationHouseMap[detail.FromLocationId].Name //发货仓库名
            info.LocationID = int64(detail.FromLocationId)
            info.WareHouseID = int64(locationHouseMap[detail.FromLocationId].Id)
         }
         outputList = append(outputList, &info)
      }
@@ -309,3 +315,145 @@

   return resp, nil
}

type StoreInfo struct {
   Name            string          `json:"name"`            //产品名称
   Number          string          `json:"number"`          //产品编号
   StoreAmount     decimal.Decimal `json:"storeAmount"`     //订单入库数量
   AvailableAmount decimal.Decimal `json:"availableAmount"` //剩余可用数量
}

type OutputSimpleInfo struct {
   Number string          `json:"number"` //产品编号
   Amount decimal.Decimal `json:"amount"` //在库数量
   Status int             `json:"status"` //0就绪 1完成
}

func (s *Server) OrderProductOutput(ctx context.Context, req *OrderProductOutputRequest) (resp *OrderProductOutputResponse, err error) {
   if req.OrderNumber == "" || len(req.Products) == 0 {
      return nil, errors.New("参数缺失")
   }
   orderInputAndOutputInfoResponse, err := s.GetOrderInputAndOutputInfo(ctx, &GetOrderInputAndOutputInfoRequest{
      Number: req.OrderNumber,
   })
   if err != nil {
      logx.Errorf("OrderProductOutput GetOrderInputAndOutputInfo err:%v, req:%v", err, req)
      return nil, errors.New("获取出入库信息失败")
   }

   outputList := orderInputAndOutputInfoResponse.OutputList
   inputList := orderInputAndOutputInfoResponse.InputList
   inputProductMap := make(map[string]*StoreInfo)
   outputProductMap := make(map[string]*OutputSimpleInfo)
   inputLocationAmountMap := make(map[int64]map[string]decimal.Decimal)
   outputLocationAmountMap := make(map[int64]map[string]decimal.Decimal)
   for _, v := range outputList {
      if outputProductMap[v.Number] == nil {
         simpleInfo := &OutputSimpleInfo{
            Number: v.Number,
         }
         amount, _ := decimal.NewFromString(v.Amount)
         simpleInfo.Amount = amount
         outputProductMap[v.Number] = simpleInfo
      } else {
         amount, _ := decimal.NewFromString(v.Amount)
         outputProductMap[v.Number].Amount = outputProductMap[v.Number].Amount.Add(amount)
      }
   }
   for _, v := range inputList {
      if inputProductMap[v.Number] == nil {
         storeInfo := &StoreInfo{
            Number: v.Number,
            Name:   v.Name,
         }
         storeAmount, _ := decimal.NewFromString(v.Amount)
         storeInfo.StoreAmount = storeAmount
         storeInfo.AvailableAmount = storeAmount
         inputProductMap[v.Number] = storeInfo
      } else {
         storeAmount, _ := decimal.NewFromString(v.Amount)
         inputProductMap[v.Number].StoreAmount = inputProductMap[v.Number].StoreAmount.Add(storeAmount)
         inputProductMap[v.Number].AvailableAmount = inputProductMap[v.Number].StoreAmount
      }
   }

   for number, inputInfo := range inputProductMap {
      outputInfo := outputProductMap[inputInfo.Number]
      if outputInfo != nil {
         inputProductMap[number].AvailableAmount = inputProductMap[number].AvailableAmount.Sub(outputInfo.Amount) //可用数量 = 入库完成数量 - 已发货数量
      }
   }

   //校验可用数量是否足够
   productNeedSendAmount := make(map[string]decimal.Decimal)
   for _, product := range req.Products {
      sendAmount, _ := decimal.NewFromString(product.Amount)
      productNeedSendAmount[product.Number] = sendAmount
      if inputProductMap[product.Number] == nil {
         return nil, fmt.Errorf("获取入库信息失败，产品编号：%v", product.Number)
      }
      if sendAmount.GreaterThan(inputProductMap[product.Number].AvailableAmount) {
         return nil, fmt.Errorf("产品可用数量不足以发货，产品编号：%v", product.Number)
      }
   }

   LocationIDWarehouseIDMap := make(map[int64]int64)
   for _, output := range outputList {
      if outputLocationAmountMap[output.LocationID] == nil {
         outputLocationAmountMap[output.LocationID] = make(map[string]decimal.Decimal)
      }
      outputAmount, _ := decimal.NewFromString(output.Amount)
      outputLocationAmountMap[output.LocationID][output.Number] = outputAmount
   }
   for _, input := range inputList {
      LocationIDWarehouseIDMap[input.LocationID] = input.WareHouseID

      if inputLocationAmountMap[input.LocationID] == nil {
         inputLocationAmountMap[input.LocationID] = make(map[string]decimal.Decimal)
      }
      storeAmount, _ := decimal.NewFromString(input.Amount)
      if outputLocationAmountMap[input.LocationID] != nil {
         storeAmount = storeAmount.Sub(outputLocationAmountMap[input.LocationID][input.Number])
      }
      inputLocationAmountMap[input.LocationID][input.Number] = storeAmount
   }

   productHasSendAmount := make(map[string]decimal.Decimal) //本次已发货数量

   //find location ID
   outputInfoList := make([]*service.OutputInfo, 0)
   for locationID, locationProductAmounts := range inputLocationAmountMap {
      productInfoList := make([]*service.ProductInfo, 0)
      for productNumber, productAmount := range locationProductAmounts {
         remainAmount := productNeedSendAmount[productNumber].Sub(productHasSendAmount[productNumber])
         var locationSendAmount decimal.Decimal
         if productAmount.GreaterThanOrEqual(remainAmount) {
            locationSendAmount = remainAmount
         } else {
            locationSendAmount = productAmount
         }
         productInfoList = append(productInfoList, &service.ProductInfo{
            ProductID: productNumber,
            Amount:    locationSendAmount,
         })
         productHasSendAmount[productNumber] = productHasSendAmount[productNumber].Add(locationSendAmount)
      }
      outputInfoList = append(outputInfoList, &service.OutputInfo{
         LocationID:   int(locationID),
         WarehouseID:  int(LocationIDWarehouseIDMap[locationID]),
         Products:     productInfoList,
         OperationID:  0,
         SourceNumber: req.OrderNumber,
      })
   }

   err = service.AddOutputOperations(outputInfoList)

   if err != nil {
      return nil, err
   }

   resp.Code = 1
   resp.Msg = "success"
   return nil, nil
}