package logic import ( "context" "errors" "fmt" "math" "sort" "strconv" "strings" "time" "bj_power_mes/ent" "bj_power_mes/ent/dailyplan" "bj_power_mes/ent/productbom" "bj_power_mes/ent/productprocessmaterial" "bj_power_mes/ent/workorder" "bj_power_mes/internal/wmsclient" ) // ProducibleResult 可生产数量计算结果(供 WMS 按需实时拉取) type ProducibleResult struct { Items []wmsclient.ProducibleItem `json:"items"` Demands []wmsclient.ProducibleDemand `json:"demands"` Avail map[string]int `json:"avail"` // 各物料 WMS 可用量(供排产支撑逐日消耗模拟复用) ComputedAt int64 `json:"computedAt"` } // MaterialDemandRow MES 排产物料需求行(按物料汇总,未来 N 天窗口)。 // WMS「缺料补货」视图实时拉此数据,对比本地可用库存得出排产缺料量。 type MaterialDemandRow struct { MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` DemandQty int `json:"demandQty"` // 未来 N 天排产总需求(台数×单台含损耗用量,向上取整) StartDate string `json:"startDate"` // 需求窗口起(YYYY-MM-DD) EndDate string `json:"endDate"` // 需求窗口止(YYYY-MM-DD) } // ProducibleSupportItem 排产支撑:单张工单的可生产套数与短板物料说明 type ProducibleSupportItem struct { OrderNo string `json:"orderNo"` ProductCode string `json:"productCode"` ProductName string `json:"productName"` ProducibleQty int `json:"producibleQty"` ShortText string `json:"shortText"` } // ProducibleDailyRow 单工单逐日模拟的某物料当日消耗量与剩余量 type ProducibleDailyRow struct { Date string `json:"date"` MaterialCode string `json:"materialCode"` Consumed float64 `json:"consumed"` // 当日消耗(当日该物料需求台数 × 单台含损耗用量) Before float64 `json:"before"` // 当日扣减前可用量 Remain float64 `json:"remain"` // 当日扣减后剩余量 Source string `json:"source"` // 账目来源:产品工艺分账 / 工艺总账(无分账回退) } // ProducibleOrderRow 单工单逐日模拟结果(按工单逐个模拟消耗) type ProducibleOrderRow struct { WorkOrderNo string `json:"workOrderNo"` ProductCode string `json:"productCode"` ProducibleQty int `json:"producibleQty"` BottleneckMaterial string `json:"bottleneckMaterial"` SupportUntil string `json:"supportUntil"` SupportDays int `json:"supportDays"` DailyRows []ProducibleDailyRow `json:"dailyRows"` UsageBreakdown []ProducibleUsageRow `json:"usageBreakdown"` } // ProducibleUsageRow 抽屉里的「物料账目来源」明细:按产品工艺分账逐工艺列出的单台用量。 // 宏观测算与逐日消耗仍走工艺总账口径,本结构只用于展示账目来源,不参与计算。 type ProducibleUsageRow struct { Seq int `json:"seq"` // 工单工艺组合中的第几道工艺 FlowId int `json:"flowId"` FlowName string `json:"flowName"` MaterialCode string `json:"materialCode"` MaterialName string `json:"materialName"` Unit string `json:"unit"` UnitQty float64 `json:"unitQty"` // 单台净用量 LossRate float64 `json:"lossRate"` // 损耗率%(展示口径,取工艺总账) EffQty float64 `json:"effQty"` // 单台含损耗用量 Source string `json:"source"` // 产品工艺分账 / 工艺总账(无分账回退) } // ProducibleBottleneck 总支撑瓶颈:最早见底那个工单 type ProducibleBottleneck struct { WorkOrderNo string `json:"workOrderNo"` MaterialCode string `json:"materialCode"` Date string `json:"date"` } // ProducibleSupportResult 排产支撑总览:逐工单可生产套数 + 整体还能满产多少天/支撑到哪天/最先告罄短板物料。 // 原有 items/supportDays/supportUntil/shortBoardMaterial/computedAt 语义保持不变; // orders/bottleneck 为「按工单逐个模拟」新增字段。 type ProducibleSupportResult struct { Items []ProducibleSupportItem `json:"items"` SupportDays int `json:"supportDays"` SupportUntil string `json:"supportUntil"` ShortBoardMaterial string `json:"shortBoardMaterial"` ComputedAt int64 `json:"computedAt"` Orders []ProducibleOrderRow `json:"orders"` Bottleneck *ProducibleBottleneck `json:"bottleneck"` } // planOrdersBetween 取 [start,end] 窗口内(按排产日期 PlanDate,非工单起止日期)未取消日排产: // 返回 工单号→排产台数 合并映射(同工单多日排产累加)。 func (s *Service) planOrdersBetween(ctx context.Context, start, end string) (map[string]int, error) { plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.PlanDateGTE(start), dailyplan.PlanDateLTE(end)).All(ctx) if err != nil { return nil, err } qty := map[string]int{} for _, p := range plans { if p.Status == "CANCELLED" { continue } qty[p.OrderNo] += p.PlanQty } for no, q := range qty { if q <= 0 { delete(qty, no) } } return qty, nil } // loadOrderUsage 批量加载工单(工单号→单台用料行)。工单号不存在或组合无物料的不进映射。 func (s *Service) loadOrderUsage(ctx context.Context, orderNos []string) map[string][]UsageRow { usageByOrder := map[string][]UsageRow{} if len(orderNos) == 0 { return usageByOrder } wos, err := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.WorkOrderNoIn(orderNos...)).All(ctx) if err != nil { return usageByOrder } for _, wo := range wos { if u := s.WorkOrderUnitUsage(ctx, wo); len(u) > 0 { usageByOrder[wo.WorkOrderNo] = u } } return usageByOrder } // ComputeProducible 计算「可生产数量」+「未来5天物料需求」,结果直接返回(不做定时推送)。 // // 业务口径(物料清单已删除,物料跟着工单走): // - 可生产套数 = 按"有未取消日排产的工单"逐单计算:min(各物料可用量 ÷ 该工单单台含损耗用量)。 // 单台用量来自该工单工艺组合×工艺物料清单;库存可用量在 WMS,由 MES 拉取后本地计算。 // - 未来5天需求量 = 近5天(含今日)日排产台数 × 工单单台含损耗用量,按物料汇总(按排产日期算), // 供 WMS 备料四态「预警」判定(客户诉求 问题记录 L256)。 // // 两系统独立运行约束:未配置 WMS 或不可达时返回错误,由调用方(WMS)提示,绝不阻塞 MES。 func (s *Service) ComputeProducible(ctx context.Context) (*ProducibleResult, error) { if s.ctx.Wms == nil || s.ctx.EntClient == nil { return nil, errors.New("未配置 WMS 服务地址,无法计算可生产数量;请在系统设置中填写 WMS 地址后重试") } today := time.Now().Format("2006-01-02") planQty, err := s.planOrdersBetween(ctx, today, addDays(today, 59)) if err != nil { return nil, err } if len(planQty) == 0 { return &ProducibleResult{ Items: []wmsclient.ProducibleItem{}, Demands: []wmsclient.ProducibleDemand{}, Avail: map[string]int{}, ComputedAt: time.Now().Unix(), }, nil } orderNos := make([]string, 0, len(planQty)) for no := range planQty { orderNos = append(orderNos, no) } sort.Strings(orderNos) usageByOrder := s.loadOrderUsage(ctx, orderNos) // 拉取 WMS 各物料可用量(仅工单用料涉及的物料) codeSet := map[string]bool{} for _, usage := range usageByOrder { for _, it := range usage { codeSet[it.MaterialCode] = true } } codes := make([]string, 0, len(codeSet)) for c := range codeSet { codes = append(codes, c) } sort.Strings(codes) avail, err := s.ctx.Wms.StockAvailable(ctx, codes) if err != nil { // 业务友好提示:不把底层网络/连接技术细节返回给前端;详细错误由 EventLog 与框架日志捕获 return nil, errors.New("无法获取 WMS 库存可用量(WMS 服务未启动或网络不可达),排产支撑暂不可用;请检查 WMS 服务状态或稍后重试") } // 产品名称映射(本地产品档案优先=M6,工单快照兜底) nameMap := map[string]string{} if rows, _, e := s.ListProductTypes(ctx, ""); e == nil { for _, p := range rows { nameMap[p.Code] = p.Name } } prodCodeByOrder := map[string]string{} if wos, e := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.WorkOrderNoIn(orderNos...)).All(ctx); e == nil { for _, wo := range wos { prodCodeByOrder[wo.WorkOrderNo] = wo.ProductCode } } // 逐工单计算可生产套数 = min(floor(可用量 ÷ 单台含损耗用量)),短板物料取最小值前3 now := time.Now().Unix() items := make([]wmsclient.ProducibleItem, 0, len(orderNos)) for _, no := range orderNos { usage, ok := usageByOrder[no] if !ok { continue // 工单组合无物料清单,无法评估 } minSets := -1 type shortRow struct { text string set int } shorts := make([]shortRow, 0, len(usage)) for _, it := range usage { if it.EffQty <= 0 { continue } a := avail[it.MaterialCode] sets := int(math.Floor(float64(a) / it.EffQty)) if sets < 0 { sets = 0 } if minSets < 0 || sets < minSets { minSets = sets } name := it.MaterialName if name == "" { name = it.MaterialCode } shorts = append(shorts, shortRow{ text: fmt.Sprintf("%s(%s) 可用%d÷单台%s=%d套", name, it.MaterialCode, a, trimNum(it.EffQty), sets), set: sets, }) } if minSets < 0 { minSets = 0 } sort.SliceStable(shorts, func(i, j int) bool { return shorts[i].set < shorts[j].set }) pick := make([]string, 0, 3) for _, sr := range shorts { if sr.set == minSets && len(pick) < 3 { pick = append(pick, sr.text) } } pc := prodCodeByOrder[no] items = append(items, wmsclient.ProducibleItem{ OrderNo: no, ProductCode: pc, ProductName: nameMap[pc], ProducibleQty: minSets, ShortText: strings.Join(pick, "; "), ComputedAt: now, }) } // 未来 N 天物料需求(备料四态「预警」数据源;窗口天数在「基础设置」页配置,默认 5) demands := s.computeFutureDemand(ctx, s.CfgInt(ctx, CfgDemandDays, 5)) return &ProducibleResult{ Items: items, Demands: demands, Avail: avail, ComputedAt: time.Now().Unix(), }, nil } // ComputeMaterialDemand WMS 缺料补货数据源:未来 N 天(按排产日期)排产物料需求,按物料汇总。 // 与 ComputeProducible 共享工单用料汇总:MES 只产出"需求量",可用量由 WMS 自己比。 func (s *Service) ComputeMaterialDemand(ctx context.Context, days int) ([]MaterialDemandRow, error) { if s.ctx.EntClient == nil { return nil, errors.New("未配置数据库连接") } if days <= 0 { days = s.CfgInt(ctx, CfgDemandDays, 5) // 未传窗口 → 基础设置需求窗口天数 } today := time.Now() start := today.Format("2006-01-02") end := today.AddDate(0, 0, days-1).Format("2006-01-02") planQty, err := s.planOrdersBetween(ctx, start, end) if err != nil { return nil, err } if len(planQty) == 0 { return []MaterialDemandRow{}, nil } orderNos := make([]string, 0, len(planQty)) for no := range planQty { orderNos = append(orderNos, no) } usageByOrder := s.loadOrderUsage(ctx, orderNos) if len(usageByOrder) == 0 { return []MaterialDemandRow{}, nil } // 需求 = Σ 排产台数 × 单台含损耗用量(向上取整);名称/单位取自工艺物料快照 demand := map[string]int{} nameUnit := map[string]struct{ name, unit string }{} for no, qty := range planQty { usage, ok := usageByOrder[no] if !ok || qty <= 0 { continue } for _, it := range usage { if it.EffQty <= 0 { continue } demand[it.MaterialCode] += int(math.Ceil(float64(qty) * it.EffQty)) nameUnit[it.MaterialCode] = struct{ name, unit string }{it.MaterialName, it.Unit} } } if len(demand) == 0 { return []MaterialDemandRow{}, nil } mcodes := make([]string, 0, len(demand)) for c := range demand { mcodes = append(mcodes, c) } sort.Strings(mcodes) out := make([]MaterialDemandRow, 0, len(mcodes)) for _, c := range mcodes { nu := nameUnit[c] out = append(out, MaterialDemandRow{ MaterialCode: c, MaterialName: nu.name, Unit: nu.unit, DemandQty: demand[c], StartDate: start, EndDate: end, }) } return out, nil } // computeFutureDemand 近 N 天(含今日)日排产台数 × 工单单台含损耗用量,按物料汇总为未来需求量。 // 窗口按排产日期算(工单起止日期≠排产日期,一律以排产日期为准);N 在「基础设置」页配置(默认 5)。 func (s *Service) computeFutureDemand(ctx context.Context, days int) []wmsclient.ProducibleDemand { rows, err := s.ComputeMaterialDemand(ctx, days) if err != nil || len(rows) == 0 { return nil } out := make([]wmsclient.ProducibleDemand, 0, len(rows)) for _, r := range rows { out = append(out, wmsclient.ProducibleDemand{MaterialCode: r.MaterialCode, Future5Qty: r.DemandQty}) } return out } // ComputeProducibleSupport 计算排产支撑视图(§A2 / §D1)。 // 复用 ComputeProducible 得到逐工单可生产套数,再用 WMS 可用量对日排产做逐日消耗模拟, // 得出整体还能满产多少天、支撑到哪天、最先告罄的短板物料;排产只排 N 天时,第 N+1 天起用近3天平均日需求外推。 func (s *Service) ComputeProducibleSupport(ctx context.Context) (*ProducibleSupportResult, error) { base, err := s.ComputeProducible(ctx) if err != nil { return nil, err } res := &ProducibleSupportResult{ ComputedAt: base.ComputedAt, SupportDays: 0, SupportUntil: time.Now().Format("2006-01-02"), } for _, it := range base.Items { res.Items = append(res.Items, ProducibleSupportItem{ OrderNo: it.OrderNo, ProductCode: it.ProductCode, ProductName: it.ProductName, ProducibleQty: it.ProducibleQty, ShortText: it.ShortText, }) } usageByOrder := s.loadOrderUsage(ctx, orderNosOf(base.Items)) days, until, shortBoard := s.simulateSupport(ctx, usageByOrder, base.Avail) res.SupportDays = days res.SupportUntil = until res.ShortBoardMaterial = shortBoard // 按工单逐个模拟(原有总览字段语义不变) qtyByOrder := map[string]int{} codeByOrder := map[string]string{} for _, it := range base.Items { qtyByOrder[it.OrderNo] = it.ProducibleQty codeByOrder[it.OrderNo] = it.ProductCode } res.Orders, res.Bottleneck = s.simulateSupportByOrder(ctx, usageByOrder, base.Avail, qtyByOrder, codeByOrder) // 逐工单补「物料账目来源」明细:宏观汇总与逐日消耗口径不变(工艺总账), // 明细区另按产品工艺分账逐工艺展示实际领料量,点进抽屉即可核到账目来源。 breakdownByOrder := s.loadUsageBreakdown(ctx, orderNosOf(base.Items)) for i := range res.Orders { rows := breakdownByOrder[res.Orders[i].WorkOrderNo] res.Orders[i].UsageBreakdown = rows srcByCode := map[string]string{} for _, r := range rows { if _, has := srcByCode[r.MaterialCode]; !has || r.Source == "产品工艺分账" { srcByCode[r.MaterialCode] = r.Source } } for j := range res.Orders[i].DailyRows { src := srcByCode[res.Orders[i].DailyRows[j].MaterialCode] if src == "" { src = "工艺总账" } res.Orders[i].DailyRows[j].Source = src } } return res, nil } // loadUsageBreakdown 批量加载工单的「物料账目来源」明细(工单号 → 分账明细行)。 func (s *Service) loadUsageBreakdown(ctx context.Context, orderNos []string) map[string][]ProducibleUsageRow { out := map[string][]ProducibleUsageRow{} if len(orderNos) == 0 { return out } wos, err := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.WorkOrderNoIn(orderNos...)).All(ctx) if err != nil { return out } for _, wo := range wos { out[wo.WorkOrderNo] = s.orderUsageBreakdown(ctx, wo) } return out } // orderUsageBreakdown 按产品工艺分账(product_process_material)逐工艺列出单台用量(2026-11-18 纯分账口径): // 损耗率取产品总账(product_bom)同名物料;工艺无分账行则该工艺不列出。 // 与 MaterialsByFlowForWO(叫料/备料/装机绑定的算料口径)同源,仅用于抽屉展示,不参与上方宏观测算。 func (s *Service) orderUsageBreakdown(ctx context.Context, wo *ent.WorkOrder) []ProducibleUsageRow { if wo == nil || s.ctx.EntClient == nil { return []ProducibleUsageRow{} } items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo) fseen := map[int]bool{} flowIDs := make([]int, 0, len(items)) for _, it := range items { if it.FlowId > 0 && !fseen[it.FlowId] { fseen[it.FlowId] = true flowIDs = append(flowIDs, it.FlowId) } } if len(flowIDs) == 0 { return []ProducibleUsageRow{} } flowName := map[int]string{} for _, fid := range flowIDs { if f, err := s.ctx.EntClient.ProcessFlow.Get(ctx, fid); err == nil { flowName[fid] = f.Name } } allocByFlow := map[int][]*ent.ProductProcessMaterial{} if wo.ProductProcessId > 0 { if rows, err := s.ctx.EntClient.ProductProcessMaterial.Query(). Where(productprocessmaterial.ProductProcessId(wo.ProductProcessId)).All(ctx); err == nil { for _, r := range rows { allocByFlow[r.FlowId] = append(allocByFlow[r.FlowId], r) } } } lossByCode := map[string]float64{} if wo.ProductCode != "" { if boms, err := s.ctx.EntClient.ProductBOM.Query().Where(productbom.ProductCode(wo.ProductCode)).All(ctx); err == nil { for _, b := range boms { lossByCode[b.MaterialCode] = b.LossRate } } } out := []ProducibleUsageRow{} for seq, fid := range flowIDs { rows := allocByFlow[fid] if len(rows) == 0 { continue } sort.SliceStable(rows, func(i, j int) bool { return rows[i].Seq < rows[j].Seq }) for _, r := range rows { loss := lossByCode[r.MaterialCode] out = append(out, ProducibleUsageRow{ Seq: seq + 1, FlowId: fid, FlowName: flowName[fid], MaterialCode: r.MaterialCode, MaterialName: r.MaterialName, Unit: r.Unit, UnitQty: r.UnitQty, LossRate: loss, EffQty: r.UnitQty * (1 + loss/100), Source: "产品工艺分账", }) } } return out } // orderNosOf 从可生产结果提取工单号(保持顺序) func orderNosOf(items []wmsclient.ProducibleItem) []string { out := make([]string, 0, len(items)) for _, it := range items { if it.OrderNo != "" { out = append(out, it.OrderNo) } } return out } // simulateSupport 逐日消耗模拟:用 WMS 可用量 avail 对日排产做逐日扣减,直到某物料不足。 // 返回 支撑满产天数、支撑到哪天、最先告罄短板物料(名称+编码,无排产返回"无排产计划")。 func (s *Service) simulateSupport(ctx context.Context, usageByOrder map[string][]UsageRow, avail map[string]int) (int, string, string) { today := time.Now() start := today.Format("2006-01-02") end := today.AddDate(0, 0, 59).Format("2006-01-02") plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.PlanDateGTE(start), dailyplan.PlanDateLTE(end)).All(ctx) if err != nil { return 0, start, "无排产计划" } planByDate := map[string]map[string]int{} // date -> orderNo -> qty for _, p := range plans { if p.Status == "CANCELLED" || p.PlanQty <= 0 { continue } if _, has := usageByOrder[p.OrderNo]; !has { continue // 工单组合无物料清单,不参与消耗模拟 } if planByDate[p.PlanDate] == nil { planByDate[p.PlanDate] = map[string]int{} } planByDate[p.PlanDate][p.OrderNo] += p.PlanQty } if len(planByDate) == 0 { return 0, start, "无排产计划" } // 物料名称 matName := map[string]string{} for _, usage := range usageByOrder { for _, it := range usage { matName[it.MaterialCode] = it.MaterialName } } // 排序排产日 dates := make([]string, 0, len(planByDate)) for d := range planByDate { dates = append(dates, d) } sort.Strings(dates) // 当前剩余可用量 remaining := map[string]float64{} for k, v := range avail { remaining[k] = float64(v) } // 逐日真实排产消耗 history := make([]map[string]int, 0, len(dates)) // 每日各物料需求(用于外推均值) supportDays := 0 shortBoard := "" for _, d := range dates { dayDemand := dayMaterialDemand(planByDate[d], usageByOrder) history = append(history, dayDemand) // 扣减 fail := false for mat, q := range dayDemand { remaining[mat] -= float64(q) if remaining[mat] < 0 && shortBoard == "" { name := matName[mat] if name == "" { name = mat } shortBoard = fmt.Sprintf("%s(%s)", name, mat) fail = true } } if fail { break } supportDays++ } // 排产日已耗尽仍有余量 → 用近 N 天平均日需求外推(N 在「基础设置」页配置,默认 3) if shortBoard == "" { // 计算均值(取最近 min(N,len) 天) n := len(history) if n == 0 { return supportDays, addDays(start, supportDays), "" } window := s.CfgInt(ctx, CfgExtrapWindow, 3) lo := 0 if n > window { lo = n - window } avg := map[string]float64{} cnt := float64(n - lo) for i := lo; i < n; i++ { for mat, q := range history[i] { avg[mat] += float64(q) } } for mat := range avg { avg[mat] /= cnt } // 近 N 天平均日需求全为0(无有效单台用量)→ 无更多需求,不再外推 totalAvg := 0.0 for _, q := range avg { totalAvg += q } if totalAvg <= 0 { return supportDays, addDays(start, supportDays), "" } // 外推:每日按 avg 扣减,直到某物料不足(封顶天数在「基础设置」页配置,防死循环) capDays := s.CfgInt(ctx, CfgExtrapCap, 365) for supportDays < capDays { fail := false for mat, q := range avg { if q <= 0 { continue } remaining[mat] -= q if remaining[mat] < 0 && shortBoard == "" { name := matName[mat] if name == "" { name = mat } shortBoard = fmt.Sprintf("%s(%s)", name, mat) fail = true } } if fail { break } supportDays++ } } return supportDays, addDays(start, supportDays), shortBoard } // simulateSupportByOrder 对每个有未取消日排产的工单独立逐日模拟(复用 simulateSupport 逐日口径、 // loadOrderUsage 单台含损耗用量与 WMS 可用量):从 avail 出发按该工单的日排产逐日扣减,得出 // 每工单「哪个物料哪天见底 / 撑到哪天 / 可产套数 / 逐日剩余量 dailyRows」; // 总支撑瓶颈 = 最早见底那个工单(工单号 + 物料 + 日期)。窗口/外推沿用 CfgExtrapWindow/CfgExtrapCap。 func (s *Service) simulateSupportByOrder(ctx context.Context, usageByOrder map[string][]UsageRow, avail map[string]int, producibleQty map[string]int, productCode map[string]string) ([]ProducibleOrderRow, *ProducibleBottleneck) { start := time.Now().Format("2006-01-02") end := addDays(start, 59) plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.PlanDateGTE(start), dailyplan.PlanDateLTE(end)).All(ctx) rows := []ProducibleOrderRow{} if err != nil { return rows, nil } // 每工单:排产日 → 当天台数(未取消、且工单有物料清单才参与) orderDays := map[string]map[string]int{} for _, p := range plans { if p.Status == "CANCELLED" || p.PlanQty <= 0 { continue } if _, has := usageByOrder[p.OrderNo]; !has { continue } if orderDays[p.OrderNo] == nil { orderDays[p.OrderNo] = map[string]int{} } orderDays[p.OrderNo][p.PlanDate] += p.PlanQty } orderNos := make([]string, 0, len(orderDays)) for no := range orderDays { orderNos = append(orderNos, no) } sort.Strings(orderNos) // 物料名称 matName := map[string]string{} for _, usage := range usageByOrder { for _, it := range usage { matName[it.MaterialCode] = it.MaterialName } } window := s.CfgInt(ctx, CfgExtrapWindow, 3) capDays := s.CfgInt(ctx, CfgExtrapCap, 365) var bottleneck *ProducibleBottleneck for _, no := range orderNos { dates := make([]string, 0, len(orderDays[no])) for d := range orderDays[no] { dates = append(dates, d) } sort.Strings(dates) // 每个工单独立从 WMS 可用量出发 remaining := map[string]float64{} for k, v := range avail { remaining[k] = float64(v) } dailyRows := make([]ProducibleDailyRow, 0, len(dates)*2) history := make([]map[string]int, 0, len(dates)) supportDays := 0 shortMat, shortDate := "", "" for _, d := range dates { dayDemand := dayMaterialDemand(map[string]int{no: orderDays[no][d]}, usageByOrder) history = append(history, dayDemand) fail := false for mat, q := range dayDemand { before := remaining[mat] remaining[mat] -= float64(q) dailyRows = append(dailyRows, ProducibleDailyRow{ Date: d, MaterialCode: mat, Consumed: float64(q), Before: before, Remain: remaining[mat], }) if remaining[mat] < 0 && shortMat == "" { shortMat, shortDate = mat, d fail = true } } if fail { break } supportDays++ } // 排产日耗尽仍有余量 → 近 N 天平均日需求外推(沿用窗口/封顶) if shortMat == "" && len(history) > 0 { n := len(history) lo := 0 if n > window { lo = n - window } avg := map[string]float64{} cnt := float64(n - lo) for i := lo; i < n; i++ { for mat, q := range history[i] { avg[mat] += float64(q) } } for mat := range avg { avg[mat] /= cnt } totalAvg := 0.0 for _, q := range avg { totalAvg += q } if totalAvg > 0 { for supportDays < capDays { fail := false // 2026-11-10:外推日也产出逐日明细,抽屉里能看到完整模拟期(标注为「外推」) extDate := addDays(start, supportDays) for mat, q := range avg { if q <= 0 { continue } before := remaining[mat] remaining[mat] -= q dailyRows = append(dailyRows, ProducibleDailyRow{ Date: extDate, MaterialCode: mat, Consumed: q, Before: before, Remain: remaining[mat], }) if remaining[mat] < 0 && shortMat == "" { shortMat, shortDate = mat, extDate fail = true } } if fail { break } supportDays++ } } } until := addDays(start, supportDays) shortText := "" if shortMat != "" { name := matName[shortMat] if name == "" { name = shortMat } shortText = fmt.Sprintf("%s(%s)", name, shortMat) } rows = append(rows, ProducibleOrderRow{ WorkOrderNo: no, ProductCode: productCode[no], ProducibleQty: producibleQty[no], BottleneckMaterial: shortText, SupportUntil: until, SupportDays: supportDays, DailyRows: dailyRows, }) if shortMat != "" && shortDate != "" { if bottleneck == nil || shortDate < bottleneck.Date { bottleneck = &ProducibleBottleneck{WorkOrderNo: no, MaterialCode: shortMat, Date: shortDate} } } } return rows, bottleneck } // dayMaterialDemand 计算某日各物料需求(逐工单台数 × 工单单台含损耗用量,向上取整) func dayMaterialDemand(planOfDay map[string]int, usageByOrder map[string][]UsageRow) map[string]int { demand := map[string]int{} for orderNo, qty := range planOfDay { usage := usageByOrder[orderNo] if len(usage) == 0 || qty <= 0 { continue } for _, it := range usage { if it.EffQty <= 0 { continue } demand[it.MaterialCode] += int(math.Ceil(float64(qty) * it.EffQty)) } } return demand } // addDays YYYY-MM-DD + n 天 → YYYY-MM-DD func addDays(date string, n int) string { t, err := time.Parse("2006-01-02", date) if err != nil { return date } return t.AddDate(0, 0, n).Format("2006-01-02") } // trimNum 单台用量展示:整数不带小数点,非整数保留原精度 func trimNum(f float64) string { if f == math.Trunc(f) { return strconv.Itoa(int(f)) } return strconv.FormatFloat(f, 'f', -1, 64) }