aps/outsourcing.git

package controllers
 
import (
    "github.com/gin-gonic/gin"
    "github.com/shopspring/decimal"
    "gorm.io/gorm"
    "outsourcing/constvar"
    "outsourcing/extend/code"
    "outsourcing/extend/util"
    "outsourcing/models"
    "outsourcing/pkg/logx"
    "outsourcing/pkg/structx"
    "outsourcing/request"
    "outsourcing/response"
    "outsourcing/service"
    "outsourcing/service/outsourcing"
    "outsourcing/utils/jwt"
)
 
type OrderController struct{}
 
// OutsourcingOrderList
// @Tags      订单管理
// @Summary   委外订单列表
// @Produce   application/json
// @Param     object  query    request.OutsourcingOrderList true  "查询参数"
// @Success   200   {object}  util.ResponseList{data=[]models.OutsourcingOrder}  "成功"
// @Router    /api-outsourcing/v1/order/list [get]
func (slf *OrderController) OutsourcingOrderList(c *gin.Context) {
    var params request.OutsourcingOrderList
    if err := c.BindQuery(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
 
    companyId := jwt.GetCompanyID(c)
    if companyId == 0 {
        util.ResponseFormat(c, code.InternalError, "内部错误")
        return
    }
 
    list, total, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(companyId).SetPage(params.Page, params.PageSize).SetKeyword(params.Keyword).SetOrder("id desc").Find()
    if err != nil {
        util.ResponseFormat(c, code.InternalError, "查询错误")
        return
    }
    util.ResponseFormatList(c, code.Success, list, int(total))
}
 
// OrderOverview
// @Tags      订单管理
// @Summary   订单统计
// @Produce   application/json
// @Success   200   {object}  util.ResponseList{data=request.OutsourcingOrderOverview}  "成功"
// @Router    /api-outsourcing/v1/order/overview [get]
func (slf *OrderController) OrderOverview(c *gin.Context) {
    result, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).CountGroupByStatus()
    if err != nil {
        util.ResponseFormat(c, code.InternalError, "查询错误")
        return
    }
    resp := &request.OutsourcingOrderOverview{}
    for _, v := range result {
        resp.Total += v.Total
        status := constvar.OutsourcingOrderStatus(v.Status)
        if status == constvar.OutsourcingOrderStatusCreate {
            resp.WaitAssigned += v.Total
        } else {
            resp.HasAssigned += v.Total
        }
    }
    util.ResponseFormat(c, code.Success, resp)
}
 
// OutsourcingOrderProductList
// @Tags      订单管理
// @Summary   委外订单产品列表
// @Produce   application/json
// @Param     object  query    request.OutsourcingOrderProductList true  "查询参数"
// @Success   200   {object}  util.ResponseList{data=[]models.OutsourcingOrderProduct}  "成功"
// @Router    /api-outsourcing/v1/order/productList [get]
func (slf *OrderController) OutsourcingOrderProductList(c *gin.Context) {
    var params request.OutsourcingOrderProductList
    if err := c.BindQuery(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
    if params.OutsourcingOrderId == 0 {
        util.ResponseFormat(c, code.RequestParamError, "参数缺失")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderId).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    list, total, err := models.NewOutsourcingOrderProductSearch().SetPage(params.Page, params.PageSize).SetOutsourcingOrderID(params.OutsourcingOrderId).SetOrder("id desc").Find()
    if err != nil {
        util.ResponseFormat(c, code.InternalError, "查询错误")
        return
    }
    util.ResponseFormatList(c, code.Success, list, int(total))
}
 
// SaveMaterialApply
// @Tags      订单管理
// @Summary   保存物料申请单
// @Produce   application/json
// @Param     object  body    request.SaveMaterialApply true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/saveMaterialApply [post]
func (slf *OrderController) SaveMaterialApply(c *gin.Context) {
    var params request.SaveMaterialApply
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
    if len(params.ApplyList) == 0 {
        util.ResponseFormat(c, code.RequestParamError, "物料申请不能为空")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.ApplyList[0].OutsourcingOrderNumber).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    var apply []*models.OutsourcingMaterialApply
    err = structx.AssignTo(params.ApplyList, &apply)
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "数据转换失败")
        return
    }
    err = models.WithTransaction(func(db *gorm.DB) error {
        err = models.NewOutsourcingMaterialApplySearch().SetOrm(db).CreateBatch(apply)
        if err != nil {
            return err
        }
        err = models.NewOutsourcingOrderSearch().SetOrm(db).SetNumber(params.ApplyList[0].OutsourcingOrderNumber).
            UpdateByMap(map[string]interface{}{"status": constvar.OutsourcingOrderStatusMaterialApplying})
        return err
    })
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "保存失败")
        return
    }
 
    util.ResponseFormat(c, code.Success, "保存成功")
}
 
// GetMaterialApplyList
// @Tags      订单管理
// @Summary   获取物料申请单
// @Produce   application/json
// @Param     object  body    request.GetMaterialApplyList true  "参数"
// @Success   200   {object}  util.ResponseList{[]models.OutsourcingMaterialApply}  "成功"
// @Router    /api-outsourcing/v1/order/getMaterialApplyList [post]
func (slf *OrderController) GetMaterialApplyList(c *gin.Context) {
    var params request.GetMaterialApplyList
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.Number).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    find, err := models.NewOutsourcingMaterialApplySearch().SetOutsourcingOrderNumber(params.Number).FindNotTotal()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "查询失败")
        return
    }
    util.ResponseFormat(c, code.Success, find)
}
 
// ChangeStatus
// @Tags      订单管理
// @Summary   修改状态
// @Produce   application/json
// @Param     object  body    request.ChangeStatus true  "参数"
// @Success   200   {object}  util.Response  "成功"
// @Router    /api-outsourcing/v1/order/changeStatus [post]
func (slf *OrderController) ChangeStatus(c *gin.Context) {
    var params request.ChangeStatus
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.OutsourcingOrderNumber).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    //限定状态参数
    if params.Status == constvar.OutsourcingOrderStatusCreate || //取消确认
        params.Status == constvar.OutsourcingOrderStatusWaitProduce || //确认接受
        params.Status == constvar.OutsourcingOrderStatusFinish || //生产完成
        params.Status == constvar.OutsourcingOrderStatusDeliveryFinish { //发货完成
        err = models.WithTransaction(func(db *gorm.DB) error {
            m := make(map[string]interface{})
            m["status"] = params.Status
            m["reason"] = params.Reason
            err := models.NewOutsourcingOrderSearch().SetNumber(params.OutsourcingOrderNumber).UpdateByMap(m)
            if err != nil {
                return err
            }
            if params.Status == constvar.OutsourcingOrderStatusCreate {
                return models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetNumber(params.OutsourcingOrderNumber).UpdateByMap(map[string]interface{}{
                    "enterprise_id": 0,
                })
            }
            return nil
        })
 
        if err != nil {
            util.ResponseFormat(c, code.RequestParamError, "状态更新失败")
            return
        }
        util.ResponseFormat(c, code.Success, "状态更新成功")
        return
    }
    util.ResponseFormat(c, code.RequestParamError, "状态参数不正确")
}
 
// DeliveryPrepare
// @Tags      订单管理
// @Summary   发货准备
// @Produce   application/json
// @Param     object  query    request.DeliveryPrepare true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/deliveryPrepare [get]
func (slf *OrderController) DeliveryPrepare(c *gin.Context) {
    var params request.DeliveryPrepare
    if err := c.BindQuery(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
    if params.OutsourcingOrderID == 0 {
        util.ResponseFormat(c, code.RequestParamError, "参数缺失")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    orderProducts, err := models.NewOutsourcingOrderProductSearch().SetOutsourcingOrderID(params.OutsourcingOrderID).FindNotTotal()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "查询订单产品列表失败")
        return
    }
    deliveryDetails, err := models.NewOutsourcingOrderDeliveryDetailsSearch().SetOutsourcingOrderID(params.OutsourcingOrderID).FindNotTotal()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "查询订单产品发货明细失败")
        return
    }
    deliveryMap := make(map[uint]decimal.Decimal)
    for _, item := range deliveryDetails {
        deliveryMap[item.OutsourcingOrderProductID] = deliveryMap[item.OutsourcingOrderProductID].Add(item.SendAmount)
    }
    for _, v := range orderProducts {
        v.SendAmount = deliveryMap[v.ID]
    }
    util.ResponseFormat(c, code.Success, orderProducts)
}
 
// SaveDelivery
// @Tags      订单管理
// @Summary   保存发货信息
// @Produce   application/json
// @Param     object  body    request.SaveDelivery true  "参数"
// @Success   200   {object}  util.Response{}  "成功"
// @Router    /api-outsourcing/v1/order/saveDelivery [post]
func (slf *OrderController) SaveDelivery(c *gin.Context) {
    var params request.SaveDelivery
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
    if params.OutsourcingOrderID == 0 || params.Number == "" {
        util.ResponseFormat(c, code.RequestParamError, "参数缺失")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    if len(params.DeliveryList) == 0 {
        util.ResponseFormat(c, code.RequestParamError, "发货列表不能为空")
        return
    }
 
    delivery := &models.OutsourcingOrderDelivery{
        OutsourcingOrderID: params.OutsourcingOrderID,
        Number:             params.Number,
        Carrier:            params.Carrier,
        WaybillNumber:      params.WaybillNumber,
    }
 
    err = models.WithTransaction(func(db *gorm.DB) error {
        err = models.NewOutsourcingOrderDeliverySearch().SetOrm(db).Create(delivery)
        if err != nil {
            return err
        }
        items := make([]*models.OutsourcingOrderDeliveryDetails, 0, len(params.DeliveryList))
        for _, v := range params.DeliveryList {
            items = append(items, &models.OutsourcingOrderDeliveryDetails{
                OutsourcingOrderID:         params.OutsourcingOrderID,
                OutsourcingOrderDeliveryID: delivery.ID,
                OutsourcingOrderProductID:  v.OutsourcingOrderProductID,
                SendAmount:                 v.SendAmount,
                IsReceived:                 2,
            })
        }
        return models.NewOutsourcingOrderDeliveryDetailsSearch().SetOrm(db).CreateBatch(items)
    })
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "保存失败")
        return
    }
 
    util.ResponseFormat(c, code.Success, "保存成功")
}
 
// GetDeliveryList
// @Tags      订单管理
// @Summary   获取发货列表
// @Produce   application/json
// @Param     object  body    request.GetDeliveryList true  "参数"
// @Success   200   {object}  util.ResponseList{[]models.OutsourcingOrderDeliveryDetails}  "成功"
// @Router    /api-outsourcing/v1/order/deliveryList [post]
func (slf *OrderController) GetDeliveryList(c *gin.Context) {
    var params request.GetDeliveryList
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
 
    _, err := models.NewOutsourcingOrderSearch().SetEnterpriseID(jwt.GetCompanyID(c)).SetID(params.OutsourcingOrderID).First()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "订单不存在")
        return
    }
 
    list, err := models.NewOutsourcingOrderDeliveryDetailsSearch().
        SetOutsourcingOrderID(params.OutsourcingOrderID).
        SetPreload(true).
        SetOrder("id desc").
        FindNotTotal()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "查询失败")
        return
    }
    util.ResponseFormat(c, code.Success, list)
}
 
// MaterialSearch
// @Tags      订单管理
// @Summary   物料搜索
// @Produce   application/json
// @Param     object  body    request.MaterialSearch true  "参数"
// @Success   200   {object}  util.ResponseList{[]response.Material}  "成功"
// @Router    /api-outsourcing/v1/order/materialSearch [post]
func (slf *OrderController) MaterialSearch(c *gin.Context) {
    var params request.MaterialSearch
    if err := c.BindJSON(&params); err != nil {
        util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
        return
    }
    client := outsourcing.NewOutsourcingServiceClient(service.ApsServiceConn)
    resp, err := client.GetMaterialList(c, &outsourcing.GetMaterialListRequest{
        Page:     int32(params.Page),
        PageSize: int32(params.PageSize),
        Keyword:  params.Keyword,
    })
 
    if err != nil {
        logx.Errorf("grpc outsourcing GetProductList err:%v", err)
        util.ResponseFormat(c, code.RequestParamError, "查询失败")
        return
    }
 
    data := make([]*response.Material, 0, len(resp.List))
    for _, item := range resp.List {
        data = append(data, &response.Material{
            Number: item.ID,
            Name:   item.Name,
            Unit:   item.Unit,
            Specs:  item.Specs,
            Type:   item.Type,
        })
    }
 
    util.ResponseFormat(c, code.Success, data)
}