653 lines
22 KiB
Go
653 lines
22 KiB
Go
package controllers
|
||
|
||
import (
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
"server/models"
|
||
"server/pkg/jwtutil"
|
||
approvalEngine "server/services/approval"
|
||
erp "server/services/erp"
|
||
|
||
"github.com/beego/beego/v2/client/orm"
|
||
)
|
||
|
||
// ERP 单据核心逻辑（两端共用）。
|
||
//
|
||
// 按项目的接口隔离约定，/backend/erp/document* 与 /api/erp/document* 必须各有独立的
|
||
// handler 与路由，但单据的校验、明细装配、落库事务与审批提交口径只能有一份实现：
|
||
// 这里就是那一份。两端 handler 只负责「解析自己的令牌 → 组装 erpActor → 调核心 →
|
||
// 按各自的响应信封输出」，业务规则不在两端各写一遍，避免移动端口径慢慢跑偏。
|
||
//
|
||
// 返回约定沿用 reimburse*Core：最后一个 string 为空即成功，非空时给出处置状态码与文案，
|
||
// 由调用方原样透出，保证抽取前后接口行为完全一致。
|
||
|
||
// erpActor ERP 操作人：由各自端的 JWT 解析而来，核心层只认这个结构，不认 beego 上下文
|
||
type erpActor struct {
|
||
Tid string // 租户ID字符串口径（ERP 表的 tenant_id 是 VARCHAR）
|
||
TidNum uint64
|
||
UID uint64
|
||
Name string
|
||
}
|
||
|
||
func erpNewActor(claims *jwtutil.Claims) erpActor {
|
||
return erpActor{
|
||
Tid: fmt.Sprintf("%d", claims.TenantId),
|
||
TidNum: uint64(claims.TenantId),
|
||
UID: uint64(claims.UserID),
|
||
Name: resolveUserName(claims),
|
||
}
|
||
}
|
||
|
||
// erpDocFilter 单据列表筛选条件（与 Web 端查询参数一一对应）
|
||
type erpDocFilter struct {
|
||
DocType string
|
||
DocTypes string // 逗号分隔的多类型
|
||
Status string
|
||
Keyword string
|
||
PartnerID uint64
|
||
WarehouseID uint64
|
||
SourceDocID uint64
|
||
DateFrom string
|
||
DateTo string
|
||
}
|
||
|
||
// erpDocListCore 单据分页查询
|
||
func erpDocListCore(a erpActor, f erpDocFilter, page, pageSize int) ([]models.ErpDocument, int64, int, string) {
|
||
if f.DocType != "" && !erpDocTypes[f.DocType] {
|
||
return nil, 0, 400, "未知的单据类型"
|
||
}
|
||
qs := models.Orm.QueryTable(new(models.ErpDocument)).
|
||
Filter("tenant_id", a.Tid).Filter("delete_time__isnull", true)
|
||
if f.DocType != "" {
|
||
qs = qs.Filter("doc_type", f.DocType)
|
||
}
|
||
if types := strings.TrimSpace(f.DocTypes); types != "" {
|
||
list := make([]string, 0, 4)
|
||
for _, t := range strings.Split(types, ",") {
|
||
if erpDocTypes[strings.TrimSpace(t)] {
|
||
list = append(list, strings.TrimSpace(t))
|
||
}
|
||
}
|
||
if len(list) > 0 {
|
||
qs = qs.Filter("doc_type__in", list)
|
||
}
|
||
}
|
||
if st := strings.TrimSpace(f.Status); st != "" {
|
||
qs = qs.Filter("status", st)
|
||
}
|
||
if kw := strings.TrimSpace(f.Keyword); kw != "" {
|
||
cond := orm.NewCondition().
|
||
Or("doc_no__contains", kw).
|
||
Or("partner_name__contains", kw).
|
||
Or("remark__contains", kw)
|
||
qs = qs.SetCond(qs.GetCond().AndCond(cond))
|
||
}
|
||
if f.PartnerID > 0 {
|
||
qs = qs.Filter("partner_id", f.PartnerID)
|
||
}
|
||
if f.WarehouseID > 0 {
|
||
qs = qs.Filter("warehouse_id", f.WarehouseID)
|
||
}
|
||
if f.SourceDocID > 0 {
|
||
qs = qs.Filter("source_doc_id", f.SourceDocID)
|
||
}
|
||
for _, d := range []struct {
|
||
raw string
|
||
cond string
|
||
}{{f.DateFrom, "biz_date__gte"}, {f.DateTo, "biz_date__lte"}} {
|
||
if strings.TrimSpace(d.raw) == "" {
|
||
continue
|
||
}
|
||
if t, e := time.ParseInLocation("2006-01-02", strings.TrimSpace(d.raw), time.Local); e == nil {
|
||
qs = qs.Filter(d.cond, t)
|
||
}
|
||
}
|
||
|
||
total, _ := qs.Count()
|
||
var list []models.ErpDocument
|
||
if _, err := qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&list); err != nil {
|
||
return nil, 0, 500, "查询失败: " + err.Error()
|
||
}
|
||
erpFillDocNames(list)
|
||
for i := range list {
|
||
list[i].StatusLabel = models.ErpDocStatusLabel(list[i].Status)
|
||
}
|
||
return list, total, 200, ""
|
||
}
|
||
|
||
// erpDocDetailCore 单据详情（含明细、库存快照与审批实例摘要）
|
||
func erpDocDetailCore(a erpActor, id uint64) (*models.ErpDocument, int, string) {
|
||
if id == 0 {
|
||
return nil, 400, "无效的ID"
|
||
}
|
||
doc, err := erpLoadDoc(id, a.Tid)
|
||
if err != nil {
|
||
return nil, 404, "单据未找到"
|
||
}
|
||
doc.Items = erpDocItems(models.Orm, id)
|
||
erpFillItemStock(a.Tid, doc.Items, doc.WarehouseID)
|
||
single := []models.ErpDocument{*doc}
|
||
erpFillDocNames(single)
|
||
single[0].StatusLabel = models.ErpDocStatusLabel(single[0].Status)
|
||
if doc.InstanceID > 0 {
|
||
single[0].Instance = approvalEngine.InstanceBrief(doc.InstanceID)
|
||
}
|
||
return &single[0], 200, ""
|
||
}
|
||
|
||
// erpValidateDocHead 校验表头：仓库归属、往来单位匹配、调拨/盘点的仓库约束
|
||
func erpValidateDocHead(tid string, p *erpDocPayload) string {
|
||
needWh := models.ErpDocAffectsStock(p.DocType)
|
||
if needWh && p.WarehouseID == 0 && p.DocType != models.ErpDocStockTake {
|
||
return "请选择仓库"
|
||
}
|
||
if p.WarehouseID > 0 && !erpWarehouseOwned(tid, p.WarehouseID) {
|
||
return "仓库不存在或不属于当前租户"
|
||
}
|
||
if p.DocType == models.ErpDocTransfer {
|
||
if p.ToWarehouseID == 0 {
|
||
return "请选择调入仓库"
|
||
}
|
||
if p.ToWarehouseID == p.WarehouseID {
|
||
return "调入仓库不能与调出仓库相同"
|
||
}
|
||
if !erpWarehouseOwned(tid, p.ToWarehouseID) {
|
||
return "调入仓库不存在或不属于当前租户"
|
||
}
|
||
}
|
||
if pt := docTypePartner(p.DocType); pt != "" {
|
||
if p.PartnerID == 0 {
|
||
return "请选择" + erpPartnerLabel(pt)
|
||
}
|
||
}
|
||
if p.SourceDocID > 0 {
|
||
src, e := erpLoadDoc(p.SourceDocID, tid)
|
||
if e != nil {
|
||
return "来源单据不存在"
|
||
}
|
||
wants := docTypeSources(p.DocType)
|
||
if len(wants) > 0 {
|
||
allowed := false
|
||
labels := make([]string, 0, len(wants))
|
||
for _, w := range wants {
|
||
labels = append(labels, docTypeLabelOf(w))
|
||
if src.DocType == w {
|
||
allowed = true
|
||
}
|
||
}
|
||
if !allowed {
|
||
return "来源单据类型应为" + strings.Join(labels, "或")
|
||
}
|
||
if src.Status != models.ErpDocStatusApproved {
|
||
return "来源单据「" + src.DocNo + "」尚未生效，不能引用"
|
||
}
|
||
}
|
||
}
|
||
if p.DiscountAmount < 0 {
|
||
return "优惠金额不能为负"
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// refItemIDs 收集明细行引用的来源单据行ID
|
||
func refItemIDs(raw []erpDocItemPayload) []uint64 {
|
||
out := make([]uint64, 0, len(raw))
|
||
for _, r := range raw {
|
||
if r.RefItemID > 0 {
|
||
out = append(out, r.RefItemID)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
// erpBuildItems 明细行规范化：补商品快照/单价（价格体系）、算金额、校验限价与批次
|
||
func erpBuildItems(tid string, doc *models.ErpDocument, raw []erpDocItemPayload) ([]models.ErpDocumentItem, string) {
|
||
ids := make([]uint64, 0, len(raw))
|
||
for _, r := range raw {
|
||
if r.ProductID > 0 {
|
||
ids = append(ids, r.ProductID)
|
||
}
|
||
}
|
||
pmap := erpProductMap(tid, ids)
|
||
// 来源订单明细行归属：草稿覆盖保存会重建明细（行 ID 变化），前端若仍拿着旧行 ID，
|
||
// 不在开单时就拦下，脏引用要拖到审核生效才报错，移动端更难定位。
|
||
refOwner := map[uint64]uint64{}
|
||
if refIDs := refItemIDs(raw); len(refIDs) > 0 {
|
||
var refs []models.ErpDocumentItem
|
||
_, _ = models.Orm.QueryTable(new(models.ErpDocumentItem)).
|
||
Filter("id__in", refIDs).Filter("tenant_id", tid).All(&refs, "id", "doc_id")
|
||
for _, r := range refs {
|
||
refOwner[r.ID] = r.DocID
|
||
}
|
||
}
|
||
settings := erp.GetSettings(tid)
|
||
out := make([]models.ErpDocumentItem, 0, len(raw))
|
||
for i, r := range raw {
|
||
p, okm := pmap[r.ProductID]
|
||
if !okm {
|
||
return nil, fmt.Sprintf("第%d行商品不存在", i+1)
|
||
}
|
||
if p.IsDraft == 1 || p.Status != 1 {
|
||
return nil, fmt.Sprintf("商品「%s」未启用，不能开单", p.ProductName)
|
||
}
|
||
if r.Quantity <= 0 {
|
||
return nil, fmt.Sprintf("商品「%s」数量必须大于0", p.ProductName)
|
||
}
|
||
unitPrice := r.UnitPrice
|
||
if unitPrice <= 0 {
|
||
unitPrice = erpPickPrice(p, doc.DocType, settings.SalesPriceType)
|
||
}
|
||
// 限价控制：低于最低售价直接拦截（除管理员放行的场景，这里不做例外）
|
||
if strings.HasPrefix(doc.DocType, "sales") && p.MinPrice > 0 && unitPrice < p.MinPrice-0.005 {
|
||
return nil, fmt.Sprintf("商品「%s」售价 %.2f 低于最低售价 %.2f", p.ProductName, unitPrice, p.MinPrice)
|
||
}
|
||
if doc.DocType == models.ErpDocPurchaseOrder || doc.DocType == models.ErpDocPurchaseIn {
|
||
if p.EnableBatch == 1 && strings.TrimSpace(r.BatchNo) == "" && doc.DocType == models.ErpDocPurchaseIn {
|
||
return nil, fmt.Sprintf("商品「%s」启用批次管理，请填写批次号", p.ProductName)
|
||
}
|
||
}
|
||
unit := strings.TrimSpace(r.Unit)
|
||
if unit == "" {
|
||
unit = p.BaseUnit
|
||
}
|
||
amount := r.Amount
|
||
if amount <= 0 {
|
||
amount = round2f(r.Quantity * unitPrice)
|
||
}
|
||
wh := r.WarehouseID
|
||
if wh > 0 && !erpWarehouseOwned(tid, wh) {
|
||
return nil, fmt.Sprintf("第%d行仓库无效", i+1)
|
||
}
|
||
if r.RefItemID > 0 && refOwner[r.RefItemID] != doc.SourceDocID {
|
||
return nil, fmt.Sprintf("第%d行关联的来源单据明细已失效，请重新选择来源单据", i+1)
|
||
}
|
||
it := models.ErpDocumentItem{
|
||
ProductID: p.ID, ProductName: p.ProductName, Spec: p.Spec, Unit: unit,
|
||
WarehouseID: wh, BatchNo: strings.TrimSpace(r.BatchNo),
|
||
Quantity: round4f(r.Quantity), BookQty: round4f(r.BookQty),
|
||
RefItemID: r.RefItemID, UnitPrice: unitPrice, Amount: round2f(amount),
|
||
Remark: r.Remark, SortOrder: r.SortOrder,
|
||
}
|
||
if it.SortOrder == 0 {
|
||
it.SortOrder = i + 1
|
||
}
|
||
if r.ProductionDate != "" {
|
||
if t, e := time.ParseInLocation("2006-01-02", r.ProductionDate, time.Local); e == nil {
|
||
it.ProductionDate = &t
|
||
if p.ShelfLifeDays > 0 {
|
||
ed := t.AddDate(0, 0, p.ShelfLifeDays)
|
||
it.ExpireDate = &ed
|
||
}
|
||
}
|
||
}
|
||
if r.ExpireDate != "" {
|
||
if t, e := time.ParseInLocation("2006-01-02", r.ExpireDate, time.Local); e == nil {
|
||
it.ExpireDate = &t
|
||
}
|
||
}
|
||
// 盘点行未带账面数时按当前结存补齐
|
||
if doc.DocType == models.ErpDocStockTake && it.BookQty == 0 && it.WarehouseID == 0 {
|
||
it.BookQty = erpStockQty(tid, p.ID, doc.WarehouseID, it.BatchNo)
|
||
if it.UnitPrice == 0 {
|
||
it.UnitPrice = erpStockCost(tid, p.ID, doc.WarehouseID, it.BatchNo)
|
||
}
|
||
}
|
||
if msg := erpLinePreCheck(tid, doc, settings, &it); msg != "" {
|
||
return nil, msg
|
||
}
|
||
out = append(out, it)
|
||
}
|
||
return out, ""
|
||
}
|
||
|
||
// erpDocSaveCore 新建或覆盖保存草稿（payload 带 id 即为编辑）。已生效/审批中的单据不允许改动。
|
||
func erpDocSaveCore(a erpActor, p erpDocPayload) (uint64, string, int, string) {
|
||
tid := a.Tid
|
||
if !erpDocTypes[p.DocType] {
|
||
return 0, "", 400, "未知的单据类型"
|
||
}
|
||
if len(p.Items) == 0 {
|
||
return 0, "", 400, "请至少添加一行明细"
|
||
}
|
||
if errMsg := erpValidateDocHead(tid, &p); errMsg != "" {
|
||
return 0, "", 400, errMsg
|
||
}
|
||
|
||
doc := &models.ErpDocument{TenantID: tid}
|
||
if p.ID > 0 {
|
||
exist, e := erpLoadDoc(p.ID, tid)
|
||
if e != nil {
|
||
return 0, "", 404, "单据未找到"
|
||
}
|
||
if exist.Status == models.ErpDocStatusApproved || exist.Status == models.ErpDocStatusPending {
|
||
return 0, "", 400, "审批中或已生效的单据不可编辑，请先撤回或作废"
|
||
}
|
||
if exist.Status == models.ErpDocStatusCancelled {
|
||
return 0, "", 400, "已作废单据不可编辑"
|
||
}
|
||
doc = exist
|
||
}
|
||
if doc.DocNo == "" {
|
||
no, e := erp.GenerateDocNo(nil, tid, p.DocType)
|
||
if e != nil {
|
||
return 0, "", 500, e.Error()
|
||
}
|
||
doc.DocNo = no
|
||
}
|
||
bizDate := time.Now()
|
||
if p.BizDate != "" {
|
||
if t, e := time.ParseInLocation("2006-01-02", p.BizDate, time.Local); e == nil {
|
||
bizDate = t
|
||
}
|
||
}
|
||
doc.DocType = p.DocType
|
||
doc.BizDate = bizDate
|
||
doc.WarehouseID = p.WarehouseID
|
||
doc.ToWarehouseID = p.ToWarehouseID
|
||
doc.SourceDocID = p.SourceDocID
|
||
doc.DiscountAmount = p.DiscountAmount
|
||
doc.Remark = p.Remark
|
||
doc.Status = models.ErpDocStatusDraft
|
||
if pt := docTypePartner(p.DocType); pt != "" {
|
||
doc.PartnerType = pt
|
||
doc.PartnerID = p.PartnerID
|
||
doc.PartnerName = erpPartnerName(pt, p.PartnerID)
|
||
if doc.PartnerName == "" {
|
||
return 0, "", 400, erpPartnerLabel(pt) + "未选择或不存在"
|
||
}
|
||
} else {
|
||
doc.PartnerType, doc.PartnerID, doc.PartnerName = "", 0, ""
|
||
}
|
||
if doc.CreateUserID == "" {
|
||
doc.CreateUserID = fmt.Sprintf("%d", a.UID)
|
||
doc.CreateUserName = a.Name
|
||
}
|
||
|
||
items, errMsg := erpBuildItems(tid, doc, p.Items)
|
||
if errMsg != "" {
|
||
return 0, "", 400, errMsg
|
||
}
|
||
doc.TotalQty = 0
|
||
doc.TotalAmount = 0
|
||
for _, it := range items {
|
||
doc.TotalQty += it.Quantity
|
||
doc.TotalAmount += it.Amount
|
||
}
|
||
doc.TotalQty = round4f(doc.TotalQty)
|
||
doc.TotalAmount = round2f(doc.TotalAmount)
|
||
doc.ActualAmount = round2f(doc.TotalAmount - doc.DiscountAmount)
|
||
if doc.ActualAmount < 0 {
|
||
return 0, "", 400, "优惠金额不能大于单据金额"
|
||
}
|
||
|
||
o := models.Orm
|
||
tx, err := o.Begin()
|
||
if err != nil {
|
||
return 0, "", 500, "保存失败"
|
||
}
|
||
rollback := true
|
||
defer func() { if rollback { _ = tx.Rollback() } }()
|
||
|
||
now := time.Now()
|
||
doc.UpdateTime = now
|
||
if doc.ID == 0 {
|
||
doc.CreateTime = now
|
||
id, e := tx.Insert(doc)
|
||
if e != nil {
|
||
return 0, "", 500, "保存失败: " + e.Error()
|
||
}
|
||
doc.ID = uint64(id)
|
||
} else {
|
||
if _, e := tx.QueryTable(new(models.ErpDocument)).Filter("id", doc.ID).
|
||
Update(orm.Params{
|
||
"doc_type": doc.DocType, "biz_date": doc.BizDate, "warehouse_id": doc.WarehouseID,
|
||
"to_warehouse_id": doc.ToWarehouseID, "partner_type": doc.PartnerType,
|
||
"partner_id": doc.PartnerID, "partner_name": doc.PartnerName,
|
||
"source_doc_id": doc.SourceDocID, "total_qty": doc.TotalQty,
|
||
"total_amount": doc.TotalAmount, "discount_amount": doc.DiscountAmount,
|
||
"actual_amount": doc.ActualAmount, "status": models.ErpDocStatusDraft,
|
||
"instance_id": 0, "remark": doc.Remark, "update_time": now,
|
||
}); e != nil {
|
||
return 0, "", 500, "保存失败: " + e.Error()
|
||
}
|
||
if _, e := tx.QueryTable(new(models.ErpDocumentItem)).Filter("doc_id", doc.ID).Delete(); e != nil {
|
||
return 0, "", 500, "保存失败: " + e.Error()
|
||
}
|
||
}
|
||
for i := range items {
|
||
items[i].DocID = doc.ID
|
||
items[i].TenantID = tid
|
||
items[i].ID = 0
|
||
if _, e := tx.Insert(&items[i]); e != nil {
|
||
return 0, "", 500, "保存明细失败: " + e.Error()
|
||
}
|
||
}
|
||
if err := tx.Commit(); err != nil {
|
||
return 0, "", 500, "保存失败: " + err.Error()
|
||
}
|
||
rollback = false
|
||
return doc.ID, doc.DocNo, 200, ""
|
||
}
|
||
|
||
// erpDocDeleteCore 删除单据（软删主表、硬删明细），仅草稿/驳回可删
|
||
func erpDocDeleteCore(a erpActor, id uint64) (int, string) {
|
||
doc, errMsg := erpLoadEditable(id, a.Tid, []int8{models.ErpDocStatusDraft, models.ErpDocStatusRejected})
|
||
if errMsg != "" {
|
||
return 400, errMsg
|
||
}
|
||
now := time.Now()
|
||
tx, err := models.Orm.Begin()
|
||
if err != nil {
|
||
return 500, "删除失败"
|
||
}
|
||
rollback := true
|
||
defer func() { if rollback { _ = tx.Rollback() } }()
|
||
if _, err = tx.QueryTable(new(models.ErpDocument)).Filter("id", doc.ID).
|
||
Update(orm.Params{"delete_time": now, "update_time": now}); err != nil {
|
||
return 500, "删除失败: " + err.Error()
|
||
}
|
||
// 明细随主表硬删：主表只软删，历史仍可追溯；明细无独立查询价值
|
||
if _, err = tx.QueryTable(new(models.ErpDocumentItem)).Filter("doc_id", doc.ID).Delete(); err != nil {
|
||
return 500, "删除失败: " + err.Error()
|
||
}
|
||
if err = tx.Commit(); err != nil {
|
||
return 500, "删除失败"
|
||
}
|
||
rollback = false
|
||
return 200, ""
|
||
}
|
||
|
||
// erpDocCancelCore 作废：草稿/驳回/审批中均可作废；已生效单据不做反向单据，直接拒绝，
|
||
// 保证「已生效=流水已入账」这一不可篡改前提。
|
||
func erpDocCancelCore(a erpActor, id uint64) (int, string) {
|
||
doc, errMsg := erpLoadEditable(id, a.Tid, []int8{
|
||
models.ErpDocStatusDraft, models.ErpDocStatusRejected, models.ErpDocStatusPending,
|
||
})
|
||
if errMsg != "" {
|
||
return 400, errMsg
|
||
}
|
||
now := time.Now()
|
||
params := orm.Params{"status": models.ErpDocStatusCancelled, "instance_id": 0, "update_time": now}
|
||
if _, err := models.Orm.QueryTable(new(models.ErpDocument)).Filter("id", doc.ID).Update(params); err != nil {
|
||
return 500, "作废失败: " + err.Error()
|
||
}
|
||
if doc.InstanceID > 0 {
|
||
approvalEngine.CancelInstance(doc.InstanceID, "单据已作废")
|
||
}
|
||
return 200, ""
|
||
}
|
||
|
||
// erpDocApproveCore 直接审核生效（未走审批流时使用）。库存/往来账效果在同一事务内落地。
|
||
func erpDocApproveCore(a erpActor, id uint64) (int, string) {
|
||
if id == 0 {
|
||
return 400, "无效的ID"
|
||
}
|
||
if err := erp.ApproveDocument(id, a.Tid, fmt.Sprintf("%d", a.UID), a.Name); err != nil {
|
||
return 400, err.Error()
|
||
}
|
||
return 200, ""
|
||
}
|
||
|
||
// erpDocSubmitCore 提交审批：flowID 为 0 时按单据类型自动选流。
|
||
// 流程未配置人工节点时引擎会直接结束实例，此时同步单据终态。
|
||
func erpDocSubmitCore(a erpActor, id, flowID uint64) (uint64, int, string) {
|
||
if id == 0 {
|
||
return 0, 400, "无效的ID"
|
||
}
|
||
doc, errMsg := erpLoadEditable(id, a.Tid, []int8{models.ErpDocStatusDraft, models.ErpDocStatusRejected})
|
||
if errMsg != "" {
|
||
return 0, 400, errMsg
|
||
}
|
||
if len(erpDocItems(models.Orm, doc.ID)) == 0 {
|
||
return 0, 400, "单据没有明细行，无法提交"
|
||
}
|
||
bizType := models.ErpDocApprovalBizType(doc.DocType)
|
||
deptID := erpUserOrgID(a.TidNum, a.UID)
|
||
if flowID == 0 {
|
||
flowID = erpPickFlowID(a.TidNum, deptID, bizType)
|
||
}
|
||
if flowID == 0 {
|
||
return 0, 400, "该单据类型尚未配置审批流程，可直接审核或到「审批流配置」中新增"
|
||
}
|
||
instID, err := approvalEngine.Submit(approvalEngine.SubmitInput{
|
||
Scope: models.ApprovalScopeTenant,
|
||
Tid: a.TidNum,
|
||
FlowID: flowID,
|
||
BizType: bizType,
|
||
BizID: doc.ID,
|
||
BizTitle: fmt.Sprintf("[%s] %s %s", docTypeLabelOf(doc.DocType), doc.DocNo, doc.PartnerName),
|
||
SubmitUID: a.UID,
|
||
SubmitName: a.Name,
|
||
DeptID: deptID,
|
||
FormData: map[string]interface{}{
|
||
"doc_type": doc.DocType,
|
||
"doc_no": doc.DocNo,
|
||
"total_amount": doc.TotalAmount,
|
||
"actual_amount": doc.ActualAmount,
|
||
"total_qty": doc.TotalQty,
|
||
"warehouse_id": doc.WarehouseID,
|
||
"partner_id": doc.PartnerID,
|
||
"partner_type": doc.PartnerType,
|
||
},
|
||
})
|
||
if err != nil {
|
||
return 0, 400, err.Error()
|
||
}
|
||
now := time.Now()
|
||
if _, err := models.Orm.QueryTable(new(models.ErpDocument)).Filter("id", doc.ID).
|
||
Update(orm.Params{"status": models.ErpDocStatusPending, "instance_id": instID, "update_time": now}); err != nil {
|
||
return 0, 500, "提交失败: " + err.Error()
|
||
}
|
||
approvalEngine.SyncBizResult(instID, approvalEngine.InstanceStatusOf(instID))
|
||
return instID, 200, ""
|
||
}
|
||
|
||
type erpFlowRow struct {
|
||
FlowID uint64 `json:"flow_id"`
|
||
FlowCode string `json:"flow_code"`
|
||
FlowName string `json:"flow_name"`
|
||
BizType string `json:"biz_type"`
|
||
}
|
||
|
||
// erpDocFlowsCore 该单据类型可用的审批流（先精确匹配 erp_xxx，再回落到模块级 erp）
|
||
func erpDocFlowsCore(a erpActor, docType string) (string, []erpFlowRow, int, string) {
|
||
if !erpDocTypes[docType] {
|
||
return "", nil, 400, "未知的单据类型"
|
||
}
|
||
bizType := models.ErpDocApprovalBizType(docType)
|
||
deptID := erpUserOrgID(a.TidNum, a.UID)
|
||
flows, err := approvalEngine.ListAvailableFlows(models.ApprovalScopeTenant, a.TidNum, bizType, deptID)
|
||
if err != nil {
|
||
return bizType, nil, 500, err.Error()
|
||
}
|
||
if len(flows) == 0 {
|
||
flows, _ = approvalEngine.ListAvailableFlows(models.ApprovalScopeTenant, a.TidNum, "erp", deptID)
|
||
}
|
||
out := make([]erpFlowRow, 0, len(flows))
|
||
for _, f := range flows {
|
||
out = append(out, erpFlowRow{f.FlowID, f.FlowCode, f.FlowName, f.BizType})
|
||
}
|
||
return bizType, out, 200, ""
|
||
}
|
||
|
||
// erpDocExecutableCore 取来源订单中尚可执行的明细行（入库/出库/退货按行带出，避免超收超发）
|
||
func erpDocExecutableCore(a erpActor, id uint64) (map[string]interface{}, int, string) {
|
||
doc, e := erpLoadDoc(id, a.Tid)
|
||
if e != nil {
|
||
return nil, 404, "单据未找到"
|
||
}
|
||
isReturn := doc.DocType == models.ErpDocPurchaseReturn || doc.DocType == models.ErpDocSalesReturn
|
||
items := erpDocItems(models.Orm, doc.ID)
|
||
out := make([]map[string]interface{}, 0, len(items))
|
||
for _, it := range items {
|
||
basis := it.Quantity
|
||
used := it.ExecutedQty
|
||
if isReturn {
|
||
used = erpReturnedQty(a.Tid, it.ID, 0)
|
||
}
|
||
remain := basis - used
|
||
if remain < -0.000001 {
|
||
remain = 0
|
||
}
|
||
out = append(out, map[string]interface{}{
|
||
"item_id": it.ID, "product_id": it.ProductID, "product_name": it.ProductName,
|
||
"spec": it.Spec, "unit": it.Unit, "batch_no": it.BatchNo,
|
||
"quantity": it.Quantity, "unit_price": it.UnitPrice, "amount": it.Amount,
|
||
"executed_qty": round4f(used), "remain_qty": round4f(remain),
|
||
})
|
||
}
|
||
return map[string]interface{}{"doc": doc, "items": out}, 200, ""
|
||
}
|
||
|
||
// erpTakeSheetCore 盘点表初始化：带出当前账面数量与加权成本，盘点员只改实盘数
|
||
func erpTakeSheetCore(a erpActor, warehouseID uint64) ([]map[string]interface{}, int, string) {
|
||
var stocks []models.ErpStock
|
||
_, _ = models.Orm.QueryTable(new(models.ErpStock)).
|
||
Filter("tenant_id", a.Tid).Filter("warehouse_id", warehouseID).
|
||
OrderBy("product_id", "batch_no").All(&stocks)
|
||
ids := make([]uint64, 0, len(stocks))
|
||
for _, s := range stocks {
|
||
ids = append(ids, s.ProductID)
|
||
}
|
||
pmap := erpProductMap(a.Tid, ids)
|
||
out := make([]map[string]interface{}, 0, len(stocks))
|
||
for _, s := range stocks {
|
||
p := pmap[s.ProductID]
|
||
out = append(out, map[string]interface{}{
|
||
"product_id": s.ProductID, "product_name": p.ProductName, "product_code": p.ProductCode,
|
||
"spec": p.Spec, "unit": p.BaseUnit, "batch_no": s.BatchNo,
|
||
"book_qty": s.Quantity, "cost_price": s.CostPrice,
|
||
})
|
||
}
|
||
return out, 200, ""
|
||
}
|
||
|
||
// erpDocMetaDict 开单页所需字典与默认值（两端共用同一份口径）
|
||
func erpDocMetaDict(a erpActor) map[string]interface{} {
|
||
s := erp.GetSettings(a.Tid)
|
||
types := make([]map[string]interface{}, 0, len(models.ErpDocTypeLabel))
|
||
for _, k := range []string{
|
||
models.ErpDocPurchaseOrder, models.ErpDocPurchaseIn, models.ErpDocPurchaseReturn,
|
||
models.ErpDocSalesOrder, models.ErpDocSalesOut, models.ErpDocSalesReturn,
|
||
models.ErpDocOtherIn, models.ErpDocOtherOut, models.ErpDocTransfer, models.ErpDocStockTake,
|
||
} {
|
||
types = append(types, map[string]interface{}{
|
||
"value": k, "label": models.ErpDocTypeLabel[k],
|
||
"affects_stock": models.ErpDocAffectsStock(k),
|
||
"partner_type": docTypePartner(k),
|
||
})
|
||
}
|
||
return map[string]interface{}{
|
||
"doc_types": types,
|
||
"statuses": []map[string]interface{}{
|
||
{"value": 0, "label": "草稿"}, {"value": 1, "label": "审批中"},
|
||
{"value": 2, "label": "已生效"}, {"value": 3, "label": "已驳回"}, {"value": 4, "label": "已作废"},
|
||
},
|
||
"default_warehouse_id": s.DefaultWarehouseID,
|
||
"sales_price_type": s.SalesPriceType,
|
||
"negative_stock": s.NegativeAllowed,
|
||
}
|
||
}
|