Files
yunzerwebsiteallinone/go/controllers/backend_erp_base.go
T
2026-11-16 17:22:50 +08:00

224 lines
5.8 KiB
Go

package controllers
import (
"encoding/json"
"fmt"
"io"
"strconv"
"strings"
"server/models"
"server/pkg/identity"
"server/pkg/jwtutil"
"github.com/beego/beego/v2/client/orm"
beego "github.com/beego/beego/v2/server/web"
)
type BackendErpBaseController struct {
beego.Controller
}
func (c *BackendErpBaseController) claims() (*jwtutil.Claims, error) {
return identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndBackend)
}
func (c *BackendErpBaseController) tid(cl *jwtutil.Claims) string {
return fmt.Sprintf("%d", cl.TenantId)
}
func (c *BackendErpBaseController) ok(data interface{}) {
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
_ = c.ServeJSON()
}
func (c *BackendErpBaseController) listOK(list interface{}, total int64, page, pageSize int) {
c.ok(map[string]interface{}{"list": list, "total": total, "page": page, "pageSize": pageSize})
}
func (c *BackendErpBaseController) fail(httpStatus, bizCode int, msg string) {
c.Ctx.Output.SetStatus(httpStatus)
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
_ = c.ServeJSON()
}
func (c *BackendErpBaseController) denied(err error) bool {
if err != nil {
code := identity.Status(err)
c.fail(code, code, err.Error())
return true
}
return false
}
func (c *BackendErpBaseController) pathID() uint64 {
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
return id
}
func (c *BackendErpBaseController) pageArgs() (int, int) {
page, _ := c.GetInt("page", 1)
pageSize, _ := c.GetInt("pageSize", 20)
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 100 {
pageSize = 20
}
return page, pageSize
}
func (c *BackendErpBaseController) bindJSON(v interface{}) bool {
raw, err := io.ReadAll(c.Ctx.Request.Body)
if err != nil {
c.fail(400, 400, "参数错误")
return false
}
if len(strings.TrimSpace(string(raw))) == 0 {
c.fail(400, 400, "请求体为空")
return false
}
if err := json.Unmarshal(raw, v); err != nil {
c.fail(400, 400, "参数错误: "+err.Error())
return false
}
return true
}
func erpUintParam(v string) uint64 {
n, _ := strconv.ParseUint(strings.TrimSpace(v), 10, 64)
return n
}
func erpUserOrgID(tid, uid uint64) uint64 {
var tu models.SystemTenantUser
if err := models.Orm.QueryTable(new(models.SystemTenantUser)).
Filter("uid", uid).Filter("tid", tid).
Filter("delete_time__isnull", true).One(&tu); err != nil {
return 0
}
return tu.OrgID
}
var erpDocTypes = map[string]bool{
models.ErpDocPurchaseOrder: true,
models.ErpDocPurchaseIn: true,
models.ErpDocPurchaseReturn: true,
models.ErpDocSalesOrder: true,
models.ErpDocSalesOut: true,
models.ErpDocSalesReturn: true,
models.ErpDocOtherIn: true,
models.ErpDocOtherOut: true,
models.ErpDocTransfer: true,
models.ErpDocStockTake: true,
}
func erpPartnerLabel(partnerType string) string {
if partnerType == "supplier" {
return "供应商"
}
return "客户"
}
func erpLoadDoc(docID uint64, tenantID string) (*models.ErpDocument, error) {
var doc models.ErpDocument
if err := models.Orm.QueryTable(new(models.ErpDocument)).
Filter("id", docID).Filter("tenant_id", tenantID).
Filter("delete_time__isnull", true).One(&doc); err != nil {
return nil, err
}
return &doc, nil
}
func erpDocItems(o orm.QueryExecutor, docID uint64) []models.ErpDocumentItem {
var items []models.ErpDocumentItem
_, _ = o.QueryTable(new(models.ErpDocumentItem)).
Filter("doc_id", docID).OrderBy("sort_order", "id").All(&items)
return items
}
func erpFillItemStock(tenantID string, items []models.ErpDocumentItem, fallbackWh uint64) {
if len(items) == 0 {
return
}
ids := make([]uint64, 0, len(items))
for _, it := range items {
if it.ProductID > 0 {
ids = append(ids, it.ProductID)
}
}
var products []models.ErpProduct
_, _ = models.Orm.QueryTable(new(models.ErpProduct)).
Filter("id__in", ids).
All(&products, "id", "product_code", "base_unit", "spec")
pmap := make(map[uint64]models.ErpProduct, len(products))
for _, p := range products {
pmap[p.ID] = p
}
var stocks []models.ErpStock
_, _ = models.Orm.QueryTable(new(models.ErpStock)).
Filter("tenant_id", tenantID).Filter("product_id__in", ids).
All(&stocks, "product_id", "warehouse_id", "quantity")
type whKey struct{ productID, warehouseID uint64 }
qmap := map[whKey]float64{}
for _, s := range stocks {
qmap[whKey{s.ProductID, s.WarehouseID}] += s.Quantity
}
for i := range items {
if p, hit := pmap[items[i].ProductID]; hit {
items[i].ProductCode = p.ProductCode
if items[i].BaseUnit == "" {
items[i].BaseUnit = p.BaseUnit
}
}
wh := items[i].WarehouseID
if wh == 0 {
wh = fallbackWh
}
items[i].StockQty = qmap[whKey{items[i].ProductID, wh}]
}
}
func erpFillDocNames(docs []models.ErpDocument) {
if len(docs) == 0 {
return
}
whIDs := make([]uint64, 0, len(docs)*2)
srcIDs := make([]uint64, 0, len(docs))
for _, d := range docs {
if d.WarehouseID > 0 {
whIDs = append(whIDs, d.WarehouseID)
}
if d.ToWarehouseID > 0 {
whIDs = append(whIDs, d.ToWarehouseID)
}
if d.SourceDocID > 0 {
srcIDs = append(srcIDs, d.SourceDocID)
}
}
names := map[uint64]string{}
if len(whIDs) > 0 {
var whs []models.ErpWarehouse
_, _ = models.Orm.QueryTable(new(models.ErpWarehouse)).
Filter("id__in", whIDs).All(&whs, "id", "warehouse_name")
for _, w := range whs {
names[w.ID] = w.WarehouseName
}
}
srcNos := map[uint64]string{}
if len(srcIDs) > 0 {
var srcs []models.ErpDocument
_, _ = models.Orm.QueryTable(new(models.ErpDocument)).
Filter("id__in", srcIDs).All(&srcs, "id", "doc_no")
for _, s := range srcs {
srcNos[s.ID] = s.DocNo
}
}
for i := range docs {
docs[i].WarehouseName = names[docs[i].WarehouseID]
docs[i].ToWarehouseName = names[docs[i].ToWarehouseID]
docs[i].SourceDocNo = srcNos[docs[i].SourceDocID]
docs[i].DocTypeLabel = models.ErpDocTypeLabel[docs[i].DocType]
}
}