package purchase_wms
|
|
import (
|
"context"
|
"errors"
|
"fmt"
|
"github.com/shopspring/decimal"
|
"gorm.io/gorm"
|
"srm/global"
|
"srm/model/purchase"
|
"srm/model/test"
|
"time"
|
)
|
|
type Server struct {
|
UnimplementedPurchaseServiceServer
|
}
|
|
func (s *Server) UpdatePurchaseStatus(ctx context.Context, req *UpdatePurchaseStatusRequest) (*UpdatePurchaseStatusResponse, error) {
|
if req.Number == "" {
|
return nil, errors.New("采购编号不能为空")
|
}
|
m := make(map[string]interface{})
|
m["status"] = purchase.OrderStatusStored
|
if req.Status > 0 {
|
m["status"] = req.Status
|
}
|
err := global.GVA_DB.Model(&purchase.Purchase{}).Where("number = ?", req.Number).Updates(m).Error
|
return new(UpdatePurchaseStatusResponse), err
|
}
|
|
func (s *Server) GetSupplierListByProductId(ctx context.Context, req *GetSupplierListByProductIdRequest) (*GetSupplierListByProductIdResponse, error) {
|
if req.ProductId == "" {
|
return nil, errors.New("产品编号不能为空")
|
}
|
var products []test.SupplierMaterial
|
err := global.GVA_DB.Model(&test.SupplierMaterial{}).Where("number = ?", req.ProductId).Preload("Supplier").Find(&products).Error
|
if err != nil {
|
return nil, err
|
}
|
list := make([]*SupplierList, 0)
|
for _, product := range products {
|
if product.Supplier.Status != 1 {
|
continue
|
}
|
var sl SupplierList
|
sl.SupplierId = int64(product.SupplierId)
|
sl.SupplierName = product.Supplier.Name
|
sl.PurchasePrice = float32(product.PurchasePrice)
|
list = append(list, &sl)
|
}
|
resp := new(GetSupplierListByProductIdResponse)
|
resp.List = list
|
return resp, nil
|
}
|
|
func (s *Server) CreatePurchaseByWms(ctx context.Context, req *CreatePurchaseByWmsRequest) (*CreatePurchaseByWmsResponse, error) {
|
if req.ProductId == "" {
|
return nil, errors.New("产品id为空")
|
}
|
var product test.SupplierMaterial
|
err := global.GVA_DB.Model(&test.SupplierMaterial{}).Where("number = ?", req.ProductId).Order("id desc").First(&product).Error
|
if err != nil {
|
if err == gorm.ErrRecordNotFound {
|
var material test.Material
|
err = global.GVA_DB.Model(&test.Material{}).Where("id = ?", req.ProductId).First(&material).Error
|
if err != nil {
|
return nil, err
|
}
|
product.Name = material.Name
|
product.Number = material.ID
|
product.Unit = material.Unit
|
product.PurchasePrice = material.PurchasePrice.InexactFloat64()
|
product.Specifications = material.Specs
|
product.ModelNumber = material.Type
|
err = global.GVA_DB.Create(&product).Error
|
if err != nil {
|
return nil, err
|
}
|
} else {
|
return nil, err
|
}
|
}
|
|
//采购单
|
var purchaseRecord purchase.Purchase
|
|
//purchaseRecord.SupplierId = int(req.SupplierId)
|
if req.Source == "WMS" {
|
purchaseRecord.OrderSource = "WMS推送"
|
purchaseRecord.Name = "WMS补货"
|
} else if req.Source == "APS" {
|
purchaseRecord.OrderSource = "APS推送"
|
purchaseRecord.Name = "APS采购"
|
}
|
|
purchaseRecord.ID = 0
|
purchaseRecord.Status = purchase.OrderStatusConfirmed
|
purchaseRecord.HandledBy = "admin"
|
purchaseRecord.Creator = "admin"
|
purchaseRecord.Number = fmt.Sprintf("CG%v", time.Now().Unix())
|
purchaseRecord.Principal = "admin"
|
purchaseRecord.OrderType = "采购订单"
|
purchaseRecord.Quantity = decimal.NewFromInt(req.Amount)
|
purchaseRecord.TotalPrice = purchaseRecord.Quantity.Mul(decimal.NewFromFloat(product.PurchasePrice))
|
purchaseRecord.UnInvoiceAmount = purchaseRecord.TotalPrice
|
purchaseRecord.ShouldPayAmount = purchaseRecord.TotalPrice
|
|
//产品
|
var pp purchase.PurchaseProducts
|
pp.ProductId = int(product.ID)
|
pp.Amount = purchaseRecord.Quantity
|
pp.Price = decimal.NewFromFloat(product.PurchasePrice)
|
pp.Total = purchaseRecord.TotalPrice
|
if req.Source == "WMS" {
|
pp.Remark = "WMS补货"
|
} else if req.Source == "APS" {
|
pp.Remark = "APS采购"
|
}
|
|
err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
|
err = tx.Create(&purchaseRecord).Error
|
if err != nil {
|
return err
|
}
|
pp.PurchaseId = int(purchaseRecord.ID)
|
return tx.Create(&pp).Error
|
})
|
if err != nil {
|
return nil, err
|
}
|
resp := new(CreatePurchaseByWmsResponse)
|
resp.PurchaseNumber = purchaseRecord.Number
|
return resp, nil
|
}
|
|
func (s *Server) GetPurchaseInfo(ctx context.Context, req *GetPurchaseInfoRequest) (*GetPurchaseInfoResponse, error) {
|
if len(req.PurchaseNumbers) == 0 {
|
return nil, errors.New("采购单编码不能为空")
|
}
|
var ps []purchase.Purchase
|
err := global.GVA_DB.Model(&purchase.Purchase{}).Where("number in (?)", req.PurchaseNumbers).Preload("Supplier").Find(&ps).Error
|
if err != nil {
|
return nil, err
|
}
|
purchaseIds := make([]uint, 0)
|
for _, p := range ps {
|
purchaseIds = append(purchaseIds, p.ID)
|
}
|
if len(purchaseIds) == 0 {
|
return nil, errors.New("没有查到采购单")
|
}
|
pps := make([]*purchase.PurchaseProducts, 0)
|
err = global.GVA_DB.Model(&purchase.PurchaseProducts{}).Where("purchase_id in (?)", purchaseIds).Preload("Product").Find(&pps).Error
|
if err != nil {
|
return nil, err
|
}
|
infos := make([]*PurchaseInfo, 0)
|
for _, p := range ps {
|
var info PurchaseInfo
|
info.PurchaseNumber = p.Number
|
info.PurchaseName = p.Name
|
info.SupplierName = p.Supplier.Name
|
info.Status = int64(p.Status)
|
if p.Status == purchase.OrderStatusStored || p.Status == purchase.OrderStatusCompleted {
|
info.FinishAmount = info.Amount
|
}
|
for _, pp := range pps {
|
if int(p.ID) == pp.PurchaseId {
|
ni := info
|
ni.ProductId = pp.Product.Number
|
ni.ProductName = pp.Product.Name
|
ni.Specs = pp.Product.Specifications
|
ni.Unit = pp.Product.Unit
|
ni.Amount = pp.Amount.IntPart()
|
infos = append(infos, &ni)
|
}
|
}
|
}
|
resp := new(GetPurchaseInfoResponse)
|
resp.Infos = infos
|
return resp, nil
|
}
|
|
func (s *Server) ExistSupplier(ctx context.Context, req *ExistSupplierRequest) (*ExistSupplierResponse, error) {
|
resp := new(ExistSupplierResponse)
|
if len(req.ProductId) == 0 {
|
resp.Exist = false
|
return resp, nil
|
}
|
var products []test.SupplierMaterial
|
err := global.GVA_DB.Model(&test.SupplierMaterial{}).Where("number in (?)", req.ProductId).Find(&products).Error
|
if err != nil {
|
return nil, err
|
}
|
for _, number := range req.ProductId {
|
exit := false
|
for _, product := range products {
|
if number == product.Number && product.SupplierId > 0 {
|
exit = true
|
break
|
}
|
}
|
if !exit {
|
resp.Exist = exit
|
return resp, nil
|
}
|
}
|
resp.Exist = true
|
return resp, nil
|
}
|
|
func (s *Server) CreatePurchaseByAps(ctx context.Context, req *CreatePurchaseByApsRequest) (*CreatePurchaseByWmsResponse, error) {
|
if len(req.Req) == 0 {
|
return nil, errors.New("产品id为空")
|
}
|
productIds := make([]string, 0)
|
amount := int64(0)
|
numMap := make(map[string]int64)
|
for _, request := range req.Req {
|
productIds = append(productIds, request.ProductId)
|
numMap[request.ProductId] = request.Amount
|
amount += request.Amount
|
}
|
var products []test.SupplierMaterial
|
var newProducts []test.SupplierMaterial
|
err := global.GVA_DB.Model(&test.SupplierMaterial{}).Where("number in (?)", productIds).Order("id desc").Find(&products).Error
|
if err != nil {
|
return nil, err
|
}
|
for _, id := range productIds {
|
flag := false
|
for _, product := range products {
|
if id == product.Number {
|
newProducts = append(newProducts, product)
|
flag = true
|
break
|
}
|
}
|
if !flag {
|
var material test.Material
|
var product test.SupplierMaterial
|
err = global.GVA_DB.Model(&test.Material{}).Where("id = ?", id).First(&material).Error
|
if err != nil {
|
return nil, err
|
}
|
product.Name = material.Name
|
product.Number = material.ID
|
product.Unit = material.Unit
|
product.PurchasePrice = material.PurchasePrice.InexactFloat64()
|
product.Specifications = material.Specs
|
product.ModelNumber = material.Type
|
err = global.GVA_DB.Create(&product).Error
|
if err != nil {
|
return nil, err
|
}
|
newProducts = append(newProducts, product)
|
}
|
}
|
|
//采购单
|
var purchaseRecord purchase.Purchase
|
purchaseRecord.OrderSource = "APS推送"
|
purchaseRecord.Name = "APS采购"
|
purchaseRecord.ID = 0
|
purchaseRecord.Status = purchase.OrderStatusConfirmed
|
purchaseRecord.HandledBy = "admin"
|
purchaseRecord.Creator = "admin"
|
purchaseRecord.Number = fmt.Sprintf("CG%v", time.Now().Unix())
|
purchaseRecord.Principal = "admin"
|
purchaseRecord.OrderType = "采购订单"
|
purchaseRecord.Quantity = decimal.NewFromInt(amount)
|
purchaseRecord.SourceOrder = req.SourceOrder
|
|
price := float64(0)
|
var pps []purchase.PurchaseProducts
|
for _, product := range newProducts {
|
//产品
|
var pp purchase.PurchaseProducts
|
pp.ProductId = int(product.ID)
|
pp.Amount = decimal.NewFromInt(numMap[product.Number])
|
pp.Price = decimal.NewFromFloat(product.PurchasePrice)
|
price += product.PurchasePrice
|
pp.Total = pp.Amount.Mul(pp.Price)
|
pp.Remark = "APS采购"
|
pps = append(pps, pp)
|
}
|
purchaseRecord.TotalPrice = purchaseRecord.Quantity.Mul(decimal.NewFromFloat(price))
|
purchaseRecord.UnInvoiceAmount = purchaseRecord.TotalPrice
|
purchaseRecord.ShouldPayAmount = purchaseRecord.TotalPrice
|
|
err = global.GVA_DB.Transaction(func(tx *gorm.DB) error {
|
err = tx.Create(&purchaseRecord).Error
|
if err != nil {
|
return err
|
}
|
for i := 0; i < len(pps); i++ {
|
pps[i].PurchaseId = int(purchaseRecord.ID)
|
}
|
return tx.Create(&pps).Error
|
})
|
if err != nil {
|
return nil, err
|
}
|
resp := new(CreatePurchaseByWmsResponse)
|
resp.PurchaseNumber = purchaseRecord.Number
|
return resp, nil
|
}
|
