327 lines
9.0 KiB
Go
327 lines
9.0 KiB
Go
package controller
|
|
|
|
import (
|
|
"encoding/json"
|
|
"github.com/codinl/go-logger"
|
|
"github.com/gin-gonic/gin"
|
|
"mh-server/lib/auth"
|
|
"mh-server/lib/status"
|
|
"time"
|
|
|
|
"mh-server/model"
|
|
)
|
|
|
|
func ErpOrderList(c *gin.Context) {
|
|
req := &model.ErpOrderListReq{}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
|
|
resp, err := req.List()
|
|
if err != nil {
|
|
logger.Error("erp commodity list err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
RespOK(c, resp)
|
|
return
|
|
}
|
|
|
|
func ErpOrderCreate(c *gin.Context) {
|
|
req := struct {
|
|
//StoreId uint32 `json:"store_id"`
|
|
Cashiers []model.ErpCashier `json:"cashiers" binding:"required"`
|
|
Salesman1 uint32 `json:"salesman_1" binding:"required"`
|
|
Salesman2 uint32 `json:"salesman_2"`
|
|
RetailType string `json:"retail_type" binding:"required"`
|
|
Tel string `json:"tel" binding:"required"`
|
|
MemberType string `json:"member_type"` // 会员类型:
|
|
ErpOrderCommodities []model.ErpOrderCommodity `json:"erp_order_commodities"`
|
|
}{}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
|
|
if len(req.Cashiers) == 0 {
|
|
logger.Error("cashiers is nil")
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
if len(req.ErpOrderCommodities) == 0 {
|
|
logger.Error("commodities is nil")
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
jCashier, err := json.Marshal(req.Cashiers)
|
|
if err != nil {
|
|
logger.Error("cashiers marshal err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
logger.Error("uc is nil")
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
|
|
//uc = &auth.UserClaims{Uid: 8588420}
|
|
assistant := model.GetUserByUid(uc.Uid)
|
|
if assistant.UserType != 2 {
|
|
logger.Error("not assistant")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
store, err := model.GetStore(uint32(assistant.StoreId))
|
|
if err != nil {
|
|
logger.Error("assistant store err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
erpOrder := &model.ErpOrder{
|
|
BillSn: model.NewErpBillSn(),
|
|
RetailType: req.RetailType,
|
|
Tel: req.Tel,
|
|
StoreId: uint32(assistant.StoreId),
|
|
StoreName: store.Name,
|
|
MakerId: uint32(assistant.Uid),
|
|
MakerName: assistant.ShopAssistantName,
|
|
AuditTime: time.Now(),
|
|
AuditorId: assistant.Uid,
|
|
AuditorName: assistant.ShopAssistantName,
|
|
CashierList: string(jCashier),
|
|
Salesman1: req.Salesman1,
|
|
Salesman2: req.Salesman2,
|
|
MemberType: req.MemberType,
|
|
State: model.ErpOrderStateUnAudit,
|
|
}
|
|
|
|
commodityMap := make(map[uint32]model.ErpCommodity)
|
|
if req.RetailType == model.RetailTypeSale {
|
|
commodityIds := make([]uint32, 0, len(req.ErpOrderCommodities))
|
|
for i, _ := range req.ErpOrderCommodities {
|
|
commodityIds = append(commodityIds, req.ErpOrderCommodities[i].ErpCommodityId)
|
|
}
|
|
var commodities []model.ErpCommodity
|
|
err = model.DB.Table("erp_commodity").Where("id IN (?)", commodityIds).Find(&commodities).Error
|
|
if err != nil {
|
|
logger.Error("commodities err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
for i, _ := range commodities {
|
|
commodityMap[commodities[i].ID] = commodities[i]
|
|
}
|
|
|
|
model.SetUserInfo(req.Tel)
|
|
}
|
|
|
|
var orderCommodityMap map[uint32]model.ErpOrderCommodity
|
|
if req.RetailType == model.RetailTypeRejected {
|
|
ids := make([]uint32, 0, len(req.ErpOrderCommodities))
|
|
for i, _ := range req.ErpOrderCommodities {
|
|
ids = append(ids, req.ErpOrderCommodities[i].RejectedOrderCommodityId)
|
|
}
|
|
orderCommodityMap, err = model.GetErpOrderCommodityMap(ids)
|
|
if err != nil {
|
|
logger.Error("order commodity map err:", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
begin := model.DB.Begin()
|
|
err = begin.Create(erpOrder).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("create erp order err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
for i, _ := range req.ErpOrderCommodities {
|
|
req.ErpOrderCommodities[i].ErpOrderId = erpOrder.ID
|
|
|
|
if req.RetailType == model.RetailTypeRejected {
|
|
v, ok := orderCommodityMap[req.ErpOrderCommodities[i].RejectedOrderCommodityId]
|
|
if ok {
|
|
v.RejectedPrice = req.ErpOrderCommodities[i].RejectedPrice
|
|
v.RejectedCount = req.ErpOrderCommodities[i].RejectedCount
|
|
v.RejectedAmount = v.RejectedCount * v.RejectedPrice
|
|
} else {
|
|
logger.Error("rejected order commodity id is null")
|
|
return
|
|
}
|
|
v.ID = 0
|
|
req.ErpOrderCommodities[i] = v
|
|
// 添加库存 TODO
|
|
if req.ErpOrderCommodities[i].RejectedPrice > req.ErpOrderCommodities[i].RetailPrice {
|
|
logger.Error("rejected price gt retail price ")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
if req.ErpOrderCommodities[i].RejectedCount > req.ErpOrderCommodities[i].Count {
|
|
logger.Error("rejected count gt retail count ")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
} else if req.RetailType == model.RetailTypeSale {
|
|
|
|
v, ok := commodityMap[req.ErpOrderCommodities[i].ErpCommodityId]
|
|
if ok {
|
|
req.ErpOrderCommodities[i].ErpCommodityName = v.Name
|
|
req.ErpOrderCommodities[i].ErpCategoryId = v.ErpCategoryId
|
|
req.ErpOrderCommodities[i].ErpCategoryName = v.ErpCategoryName
|
|
req.ErpOrderCommodities[i].RetailPrice = v.RetailPrice
|
|
//req.ErpOrderCommodities[i].MemberPrice = v.MemberPrice
|
|
}
|
|
if req.ErpOrderCommodities[i].PresentType == 2 {
|
|
req.ErpOrderCommodities[i].RetailPrice = 0
|
|
}
|
|
|
|
// 减库存 TODO
|
|
if erpOrder.MemberType == model.ErpOrderMemberTypeMember {
|
|
req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].MemberPrice
|
|
} else {
|
|
req.ErpOrderCommodities[i].Amount = req.ErpOrderCommodities[i].Count * req.ErpOrderCommodities[i].RetailPrice
|
|
}
|
|
}
|
|
|
|
erpOrder.TotalAmount += req.ErpOrderCommodities[i].Amount
|
|
erpOrder.TotalCount += req.ErpOrderCommodities[i].Count
|
|
}
|
|
|
|
err = begin.Create(&req.ErpOrderCommodities).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("Create")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
erpOrder.Commodities = req.ErpOrderCommodities
|
|
erpOrder.Cashiers = req.Cashiers
|
|
|
|
RespOK(c, erpOrder)
|
|
return
|
|
}
|
|
|
|
func ErpOrderDetail(c *gin.Context) {
|
|
req := &struct {
|
|
ErpOrderId uint32 `json:"erp_order_id"`
|
|
}{}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
var order model.ErpOrder
|
|
err := model.DB.Table("erp_order").Where("id = ?", req.ErpOrderId).Find(&order).Error
|
|
if err != nil {
|
|
logger.Error("order err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
var orderCommodities []model.ErpOrderCommodity
|
|
err = model.DB.Table("erp_order_commodity").Where("erp_order_id=?", req.ErpOrderId).Find(&orderCommodities).Error
|
|
if err != nil {
|
|
logger.Error("order commodities err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
order.Commodities = orderCommodities
|
|
order.SetErpCashier()
|
|
|
|
RespOK(c, order)
|
|
return
|
|
}
|
|
|
|
func ErpOrderCommodityList(c *gin.Context) {
|
|
req := &struct {
|
|
Tel string `json:"tel"`
|
|
IMEI string `json:"imei"`
|
|
ErpCommodityName string `json:"erp_commodity_name"`
|
|
}{}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
|
|
var commodities []model.ErpOrderCommodity
|
|
qs := model.DB.Table("erp_order_commodity")
|
|
if req.Tel != "" {
|
|
qs = qs.Where("tel=?", req.Tel)
|
|
}
|
|
if req.IMEI != "" {
|
|
qs = qs.Where("imei=?", req.IMEI)
|
|
}
|
|
if req.ErpCommodityName != "" {
|
|
qs = qs.Where("erp_commodity_name=?", req.ErpCommodityName)
|
|
}
|
|
err := qs.Order("id DESC").Find(&commodities).Error
|
|
if err != nil {
|
|
logger.Error("erp commodity list err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
RespOK(c, commodities)
|
|
return
|
|
}
|
|
|
|
func ShopAssistantList(c *gin.Context) {
|
|
req := &struct {
|
|
StoreId uint32 `json:"store_id"`
|
|
}{}
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.BadRequest, nil)
|
|
return
|
|
}
|
|
|
|
uc := auth.GetCurrentUser(c)
|
|
if uc == nil {
|
|
logger.Error("uc is nil")
|
|
RespJson(c, status.Unauthorized, nil)
|
|
return
|
|
}
|
|
|
|
//uc = &auth.UserClaims{Uid: 8588420}
|
|
assistant := model.GetUserByUid(uc.Uid)
|
|
if assistant.UserType != 2 {
|
|
logger.Error("not assistant")
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
req.StoreId = uint32(assistant.StoreId)
|
|
var users []model.User
|
|
qs := model.DB.Table("user").Where("user_type=2")
|
|
if req.StoreId != 0 {
|
|
qs = qs.Where("store_id=?", req.StoreId)
|
|
}
|
|
|
|
err := qs.Order("id DESC").Find(&users).Error
|
|
if err != nil {
|
|
logger.Error("erp commodity list err:", err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
return
|
|
}
|
|
|
|
RespOK(c, users)
|
|
return
|
|
}
|