package logic import ( "context" "errors" "fmt" "sort" "time" "bj_power_mes/ent" "bj_power_mes/ent/dailyplan" "bj_power_mes/ent/dock" "bj_power_mes/ent/workorder" "bj_power_mes/internal/verr" ) // parseDate 解析 yyyy-MM-dd 或标准时间 func parseDate(v string) (time.Time, error) { if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil { return t, nil } return time.ParseInLocation(time.RFC3339, v, time.Local) } type DailyPlanReq struct { Id int `json:"id"` OrderNo string `json:"orderNo"` PlanDate string `json:"planDate"` PlanQty int `json:"planQty"` CompletedQty int `json:"completedQty"` Status string `json:"status"` StationPlanQty map[string]int `json:"stationPlanQty"` // 工位号(字符串键)→计划产量分配;缺省按路线均分 // 批量排产(新建时与 PlanDate 二选一):日期范围 [start,end] + 分摊模式 PlanRange []string `json:"planRange"` // [start,end] yyyy-MM-dd,批量生成多条日排产 Mode string `json:"mode"` // AVG(平均分摊)/FIXED(固定日产);单条保存时忽略 } // SaveDailyPlan 创建/更新日排产(同一 工单+日期 唯一) // 排产状态枚举统一为:PENDING(待执行)/PROCESSING(执行中)/DONE(已完成)/CANCELLED(已取消) func (s *Service) SaveDailyPlan(ctx context.Context, req DailyPlanReq, operator string) error { // 收集式校验(2026-10-20 报错规范):一次收全,前端 ErrorListDialog 一次列全 ve := verr.New() if req.OrderNo == "" { ve.Add("orderNo", "工单号必填", "请选择要排产的工单(仅未排满的工单可选)") } wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(req.OrderNo)).First(ctx) if err != nil { if req.OrderNo != "" { ve.Add("orderNo", "工单 "+req.OrderNo+" 不存在", "请回工单列表核对该工单号,或重新选择工单") } return ve.OrNil() } // 以下校验相互独立,收集式并列(不再发现一个就 return) if wo.Status == "DONE" || wo.Status == "CANCELLED" { ve.Add("orderNo", "工单 "+req.OrderNo+" 已完成或已取消,不能排产", "如需排产请先新建工单,或把该工单恢复为可执行状态") } if wo.Status == "PAUSED" { ve.Add("orderNo", "工单 "+req.OrderNo+" 已暂停", "先在工单列表把工单恢复为执行中,再来排产") } if err := s.ValidateWOCombinationForSchedule(ctx, wo); err != nil { ve.Add("flowCombination", err.Error(), "到工单详情检查工艺组合与各工位的绑定关系,修正后重试") } // 批量排产(新建 + 日期范围):一键生成多天日排产,参考工单「自动排产」 if req.Id == 0 && len(req.PlanRange) == 2 && req.PlanRange[0] != "" && req.PlanRange[1] != "" { if ve.Len() > 0 { return ve.OrNil() } return s.saveDailyPlanBatch(ctx, req, operator, wo) } // 单条排产(编辑既有行 / 新建单日) if req.PlanDate == "" { ve.Add("planDate", "排产日期必填", "请选择排产日期(格式 yyyy-MM-dd)") } if req.PlanQty <= 0 { ve.Add("planQty", "排产数量需大于 0", "请填写当天的计划产量(正整数)") } // 合计护栏(2026-10-20 统一口径:累计排产合计不得超过工单总数量) total := req.PlanQty sameDateDone := false if req.PlanDate != "" { cur, _ := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.OrderNo(req.OrderNo)).All(ctx) // 本次 req.PlanQty 恒计入;若「工单+日期」已有记录,则原值作废只算新值(避免旧值+新值重复累计) for _, p := range cur { if p.PlanDate == req.PlanDate { if p.CompletedQty > 0 { sameDateDone = true } continue } total += p.PlanQty } } if sameDateDone { ve.Add("planDate", "排产日 "+req.PlanDate+" 已有完工数量,不能修改计划数量", "该日已开工生产,数量锁定;如需调整请先与生产确认,或另排其他日期") } if req.PlanQty > 0 && total > wo.Quantity { over := total - wo.Quantity ve.Add("planQty", fmt.Sprintf("工单 %s 总量 %d 件,累计排产将达 %d 件,超出 %d 件", req.OrderNo, wo.Quantity, total, over), fmt.Sprintf("把本次排产数量减到 %d 件或以下,或先调整工单总量", req.PlanQty-over)) } switch req.Status { case "", "PENDING", "PROCESSING", "DONE", "CANCELLED", "CONFIRMED": default: ve.Add("status", "非法的排产状态", "请刷新页面后重试(状态仅 待执行/执行中/已完成/已取消/已启用)") } if err := ve.OrNil(); err != nil { return err } spq := req.StationPlanQty if spq == nil { spq = map[string]int{} } exist, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.OrderNo(req.OrderNo), dailyplan.PlanDate(req.PlanDate)).First(ctx) status := req.Status if req.Status == "" { status = "PENDING" } if err == nil && exist != nil { // 编辑时若不传 status,保留该行原有状态(避免编辑把已启用(CONFIRMED)误回退为待启用) if req.Status == "" { status = exist.Status } _, err = s.ctx.EntClient.DailyPlan.UpdateOneID(exist.ID). SetOrderNo(req.OrderNo).SetPlanDate(req.PlanDate).SetPlanQty(req.PlanQty).SetStatus(status).SetStationPlanQty(spq).Save(ctx) if err != nil { return err } } else { _, err = s.ctx.EntClient.DailyPlan.Create(). SetOrderNo(req.OrderNo).SetPlanDate(req.PlanDate).SetPlanQty(req.PlanQty). SetStatus(status).SetStationPlanQty(spq).SetOperator(operator).Save(ctx) if err != nil { return err } } s.ctx.EventLog.Write(ctx, "daily.plan.save", req.OrderNo, operator, "daily_plan", req.OrderNo, "保存日排产", map[string]any{"planDate": req.PlanDate, "planQty": req.PlanQty}) // 叫料池重算(B5:排产是池子唯一来源,任何变更立即对齐) _, _ = s.RecomputePoolAll(ctx) s.notifyDashboard() return nil } // saveDailyPlanBatch 批量排产(新建 + 日期范围):把 total 件按模式分摊到范围内每一天, // 生成多条 daily_plan(status=PENDING 待人工启用)。合计受「未开工数量」约束,执行中/已完工日计划受保护不被覆盖。 func (s *Service) saveDailyPlanBatch(ctx context.Context, req DailyPlanReq, operator string, wo *ent.WorkOrder) error { // 收集式校验(2026-10-20 报错规范) ve := verr.New() dates, err := expandDates([]DateSegment{{Start: req.PlanRange[0], End: req.PlanRange[1]}}) if err != nil { ve.Add("planRange", err.Error(), "日期区间应为 yyyy-MM-dd,且结束日期不早于开始日期") } if len(dates) == 0 { ve.Add("planRange", "请选择排产日期范围", "选好起止日期后再批量排产") } remain, err := s.unscheduledQty(ctx, wo) if err != nil { return err } quota := remain // 剩余可排 = 工单总数量 − 累计已排产量 if quota < 0 { quota = 0 } days := len(dates) switch req.Mode { case "FIXED": if req.PlanQty <= 0 { ve.Add("planQty", "固定日产模式需填写每日产量", "把「每日产量」填为大于 0 的整数") } else if days > 0 && req.PlanQty*days > quota { ve.Add("planQty", fmt.Sprintf("固定日产 %d×%d 天 = %d 件,超过剩余可排 %d 件", req.PlanQty, days, req.PlanQty*days, quota), fmt.Sprintf("把每日产量降到 %d 或以下,或扩大日期范围后重试", quota/days)) } case "AVG", "": if req.PlanQty <= 0 { ve.Add("planQty", "排产总数量需大于 0", "填写本次要排的总件数") } else if req.PlanQty > quota { ve.Add("planQty", fmt.Sprintf("本次排产总量 %d 件,超过剩余可排 %d 件(工单总量 − 累计已排)", req.PlanQty, quota), fmt.Sprintf("把总数量减到 %d 件或以下", quota)) } default: ve.Add("mode", "排产模式仅支持 平均分摊 / 固定日产", "在「分摊模式」里重新选择后重试") } if err := ve.OrNil(); err != nil { return err } var planQty []int if req.Mode == "FIXED" { planQty = distributeQty(req.PlanQty*days, days, "FIXED", req.PlanQty) } else { planQty = distributeQty(req.PlanQty, days, "AVG", 0) } sum := 0 for _, q := range planQty { sum += q } if sum == 0 { ve := verr.New() ve.Add("planQty", "该工单剩余可排为 0,无需排产(已排满)", "如需增产请先调整工单总量,或检查已有排产数量") return ve.OrNil() } for i, ds := range dates { q := planQty[i] if q <= 0 { continue } existOne, _ := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.OrderNo(req.OrderNo), dailyplan.PlanDate(ds)).First(ctx) if existOne != nil { // 保护执行中/已完工的排产不被覆盖(其数量已计入 existTotal,跳过不会超排) if existOne.Status == "PROCESSING" || existOne.Status == "DONE" { continue } _, err = s.ctx.EntClient.DailyPlan.UpdateOneID(existOne.ID). SetPlanQty(q).SetStatus("PENDING").SetStationPlanQty(map[string]int{}).SetOperator(operator).Save(ctx) } else { _, err = s.ctx.EntClient.DailyPlan.Create(). SetOrderNo(req.OrderNo).SetPlanDate(ds).SetPlanQty(q). SetStatus("PENDING").SetStationPlanQty(map[string]int{}).SetOperator(operator).Save(ctx) } if err != nil { return err } } s.ctx.EventLog.Write(ctx, "daily.plan.batch", req.OrderNo, operator, "daily_plan", req.OrderNo, "日排产批量生成", map[string]any{"days": days, "total": sum, "mode": req.Mode, "quota": quota}) // 叫料池重算(B5) _, _ = s.RecomputePoolAll(ctx) s.notifyDashboard() return nil } // SuggestedDockCodes 查工单工艺组合覆盖工位的接驳台编码,供排产/备料默认推荐。 // 路线唯一源头 = 工单 flow_combination(按工位号升序);接驳台真源 = dock 表(按 station_no 聚合, // 一个工位可配 左L/右R 多个接驳台),station.dock_code 仅默认兜底,故统一从 dock 表取全集。 func (s *Service) SuggestedDockCodes(ctx context.Context, orderNo string) []string { wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(orderNo)).First(ctx) if err != nil { return nil } items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo) if len(items) == 0 { return nil } docks, err := s.ctx.EntClient.Dock.Query(). Where(dock.StationNoIn(RouteStationsOfWO(items)...), dock.DockTypeEQ("line")). Order(ent.Asc(dock.FieldStationNo), ent.Asc(dock.FieldDockCode)). All(ctx) if err != nil { return nil } seen := map[string]bool{} out := []string{} for _, d := range docks { if d.DockCode != "" && !seen[d.DockCode] { seen[d.DockCode] = true out = append(out, d.DockCode) } } return out } // syncPlansByOrderStatus 工单状态联动日排产: // - 工单 → IN_PROGRESS:该工单 PENDING 排产置 PROCESSING(开始执行) // - 工单 → DONE:已足额完工(completedQty>=planQty)的排产置 DONE;其余未完成排产置 CANCELLED // - 工单 → CANCELLED:该工单未完成(PENDING/PROCESSING)排产全部置 CANCELLED func (s *Service) syncPlansByOrderStatus(ctx context.Context, orderNo, woStatus, operator string) { if orderNo == "" { return } plans, err := s.ctx.EntClient.DailyPlan.Query(). Where(dailyplan.OrderNo(orderNo), dailyplan.StatusIn("PENDING", "PROCESSING")).All(ctx) if err != nil { return } changed := 0 to := "" for _, p := range plans { switch woStatus { case "IN_PROGRESS": to = "PROCESSING" case "DONE": if p.CompletedQty >= p.PlanQty { to = "DONE" } else { to = "CANCELLED" } case "CANCELLED": to = "CANCELLED" default: return } if p.Status == to { continue } if _, err := s.ctx.EntClient.DailyPlan.UpdateOneID(p.ID).SetStatus(to).Save(ctx); err == nil { changed++ } } if changed > 0 { s.ctx.EventLog.Write(ctx, "daily.plan.status_sync", orderNo, operator, "daily_plan", orderNo, "工单状态联动排产", map[string]any{"woStatus": woStatus, "changed": changed}) // 叫料池重算(B5:排产状态被联动改掉,池子跟随对齐) _, _ = s.RecomputePoolAll(ctx) } } // ListDailyPlans 按工单/日期查询日排产 // sort: "asc" 按排产日期升序(从前到后,默认,满足客户查看习惯) / "desc" 降序(最新在前)。 // 日排产属业务计划表(非录入流水),不受「增量列表倒序」铁律约束,默认按排产日期升序展示。 func (s *Service) ListDailyPlans(ctx context.Context, orderNo, planDate, sort string) ([]*ent.DailyPlan, error) { q := s.ctx.EntClient.DailyPlan.Query() if orderNo != "" { q = q.Where(dailyplan.OrderNo(orderNo)) } if planDate != "" { q = q.Where(dailyplan.PlanDate(planDate)) } if sort == "desc" { return q.Order(ent.Desc(dailyplan.FieldPlanDate)).All(ctx) } return q.Order(ent.Asc(dailyplan.FieldPlanDate)).All(ctx) } // DailyPlanRow 日排产行(附工单工艺组合,供前端派生路线/接驳台展示) type DailyPlanRow struct { *ent.DailyPlan FlowCombination []map[string]int `json:"flowCombination"` } // ListDailyPlansPaged 日排产分页列表 + 每行附带所属工单的工艺组合。 // 防内存炸弹:planDateStart/planDateEnd 限定日期窗口(默认今天~今天+30 由前端传); // page/pageSize 分页(pageSize 上限 200),返回总行数 total 供前端分页。默认按 planDate 升序。 func (s *Service) ListDailyPlansPaged(ctx context.Context, planDateStart, planDateEnd string, page, pageSize int, sort string) ([]*DailyPlanRow, int64, error) { if page < 1 { page = 1 } if pageSize < 1 { pageSize = 50 } if pageSize > 200 { pageSize = 200 } base := s.ctx.EntClient.DailyPlan.Query() if planDateStart != "" { base = base.Where(dailyplan.PlanDateGTE(planDateStart)) } if planDateEnd != "" { base = base.Where(dailyplan.PlanDateLTE(planDateEnd)) } total, err := base.Count(ctx) if err != nil { return nil, 0, err } if sort == "desc" { base = base.Order(ent.Desc(dailyplan.FieldPlanDate)) } else { base = base.Order(ent.Asc(dailyplan.FieldPlanDate)) } plans, err := base.Limit(pageSize).Offset((page - 1) * pageSize).All(ctx) if err != nil { return nil, 0, err } orderNos := make([]string, 0, len(plans)) seen := map[string]bool{} for _, p := range plans { if !seen[p.OrderNo] { seen[p.OrderNo] = true orderNos = append(orderNos, p.OrderNo) } } combByOrder := map[string][]map[string]int{} if len(orderNos) > 0 { wos, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNoIn(orderNos...)).All(ctx) if err == nil { for _, wo := range wos { combByOrder[wo.WorkOrderNo] = wo.FlowCombination } } } rows := make([]*DailyPlanRow, 0, len(plans)) for _, p := range plans { rows = append(rows, &DailyPlanRow{DailyPlan: p, FlowCombination: combByOrder[p.OrderNo]}) } return rows, int64(total), nil } // UnplannedWorkOrder 未排产工单(供日排产页「未排产」入口展示) type UnplannedWorkOrder struct { OrderNo string `json:"orderNo"` ProductTypeId int `json:"productTypeId"` Quantity int `json:"quantity"` Status string `json:"status"` } // ListUnplannedWorkOrders 工单状态 ∈ {CREATED,RELEASED,IN_PROGRESS} 且日排产表无任何记录的工单。 // 用于日排产页顶部「有 N 个工单尚未排产」入口;每次进入页面查询一次即可(前端缓存 60s)。 func (s *Service) ListUnplannedWorkOrders(ctx context.Context) ([]*UnplannedWorkOrder, error) { wos, err := s.ctx.EntClient.WorkOrder.Query(). Where(workorder.StatusIn("CREATED", "IN_PROGRESS")).All(ctx) if err != nil { return nil, err } planned := map[string]bool{} if ps, e := s.ctx.EntClient.DailyPlan.Query().Select(dailyplan.FieldOrderNo).All(ctx); e == nil { for _, p := range ps { planned[p.OrderNo] = true } } out := make([]*UnplannedWorkOrder, 0, len(wos)) for _, wo := range wos { if planned[wo.WorkOrderNo] { continue } out = append(out, &UnplannedWorkOrder{ OrderNo: wo.WorkOrderNo, ProductTypeId: wo.ProductTypeId, Quantity: wo.Quantity, Status: wo.Status, }) } return out, nil } // ForScheduleWorkOrder 下拉可选工单(日排产新建用):只返回"剩余可排 > 0"的工单。 type ForScheduleWorkOrder struct { WorkOrderNo string `json:"workOrderNo"` ProductCode string `json:"productCode"` ProductName string `json:"productName"` Quantity int `json:"quantity"` ScheduledQty int `json:"scheduledQty"` RemainQty int `json:"remainQty"` } // ListWorkOrdersForSchedule 返回未排满(剩余可排 > 0)的工单,供日排产工单号下拉过滤。 // 与 /daily-plans/unplanned("完全未排产"横幅入口)区分:本接口包含"部分排产"的工单。 func (s *Service) ListWorkOrdersForSchedule(ctx context.Context, keyword string) ([]*ForScheduleWorkOrder, error) { wos, err := s.ListWorkOrders(ctx, "", "", "", "", "", "", keyword, 0) if err != nil { return nil, err } // 一次性汇总各工单累计已排产量,避免 N+1 plans, err := s.ctx.EntClient.DailyPlan.Query().All(ctx) if err != nil { return nil, err } schedByOrder := map[string]int{} for _, p := range plans { schedByOrder[p.OrderNo] += p.PlanQty } out := make([]*ForScheduleWorkOrder, 0, len(wos)) for _, wo := range wos { sched := schedByOrder[wo.WorkOrderNo] remain := wo.Quantity - sched if remain <= 0 { continue // 已排满,排除 } out = append(out, &ForScheduleWorkOrder{ WorkOrderNo: wo.WorkOrderNo, ProductCode: wo.ProductCode, ProductName: wo.ProductName, Quantity: wo.Quantity, ScheduledQty: sched, RemainQty: remain, }) } return out, nil } // DeleteDailyPlan 删除一条日排产记录 func (s *Service) DeleteDailyPlan(ctx context.Context, id int) error { if err := s.ctx.EntClient.DailyPlan.DeleteOneID(id).Exec(ctx); err != nil { return err } // 叫料池重算(B5) _, _ = s.RecomputePoolAll(ctx) return nil } // SetDailyPlanStatus 日排产启用/停用(人工专用入口,POST /daily-plans/:id/status): // 仅允许 PENDING(待执行)↔CONFIRMED(已启用) 之间切换;执行中/已完成/已取消由系统联动维护,无人工入口。 // 启用(→CONFIRMED)前校验所属工单(按排产 orderNo 查)状态必须为 IN_PROGRESS(执行中)。 // 只 UPDATE status 字段,绝不触碰计划数量/分产量等其它列。 func (s *Service) SetDailyPlanStatus(ctx context.Context, id int, target, operator string) error { if id <= 0 { return errors.New("缺少排产 id") } if target != "PENDING" && target != "CONFIRMED" { return errors.New("仅支持 启用/停用 操作") } p, err := s.ctx.EntClient.DailyPlan.Get(ctx, id) if err != nil { return errors.New("日排产不存在") } if p.Status != "PENDING" && p.Status != "CONFIRMED" { return errors.New("仅支持 启用/停用 操作") } if p.Status == target { return nil // 幂等:状态相同直接成功 } if target == "CONFIRMED" { wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(p.OrderNo)).First(ctx) if err != nil { return errors.New("工单不存在") } if wo.Status != "IN_PROGRESS" { return errors.New("工单未开工,不能启用排产") } } if err := s.ctx.EntClient.DailyPlan.UpdateOneID(id).SetStatus(target).Exec(ctx); err != nil { return err } s.ctx.EventLog.Write(ctx, "daily.plan.status", p.OrderNo, operator, "daily_plan", p.OrderNo, "排产启用/停用", map[string]any{"id": id, "from": p.Status, "to": target}) // 叫料池重算(B5:启用=池子开关,领导置非启用即不可叫) _, _ = s.RecomputePoolAll(ctx) s.notifyDashboard() return nil } // ---------- 排产预览/确认(引导式,M9 定稿 2026-09-29:预览逐日可调、总数据必须对上) ---------- // DateSegment 日期区间 [start, end](含两端),yyyy-MM-dd type DateSegment struct { Start string `json:"start"` End string `json:"end"` } // AutoScheduleReq 引导式自动排产请求 // Mode: AVG(平均分摊到区间各天) / FIXED(固定日产 dailyQty) // Segments: 一个或多个日期区间(如 6/23-26、6/28-29),区间并集去重排序 type AutoScheduleReq struct { OrderNo string `json:"orderNo"` Mode string `json:"mode"` DailyQty int `json:"dailyQty"` // FIXED 模式每日产量 Segments []DateSegment `json:"segments"` } // unscheduledQty 剩余可排数量 = 工单总数量 − 累计已排产量(ΣplanQty)。 // 2026-10-20 口径统一:排产护栏只看"累计已排是否超过工单总数",不再扣减已完工/在产 // (已完工/在产工件由生产实绩独立追踪,排产是计划口径,二者解耦,避免误拦合法排产)。 func (s *Service) unscheduledQty(ctx context.Context, wo *ent.WorkOrder) (int, error) { sched, err := s.ScheduledQtyOf(ctx, wo.WorkOrderNo) if err != nil { return 0, err } remain := wo.Quantity - sched if remain < 0 { remain = 0 } return remain, nil } // ScheduledQtyOf 累计已排产量:该工单在所有日排产中的 planQty 合计(导出,供 handler 复用)。 func (s *Service) ScheduledQtyOf(ctx context.Context, orderNo string) (int, error) { plans, err := s.ctx.EntClient.DailyPlan.Query().Where(dailyplan.OrderNo(orderNo)).All(ctx) if err != nil { return 0, err } sum := 0 for _, p := range plans { sum += p.PlanQty } return sum, nil } // expandDates 把多个日期区间展开为去重、升序的日期列表(yyyy-MM-dd) func expandDates(segments []DateSegment) ([]string, error) { seen := map[string]bool{} out := []string{} for _, seg := range segments { start, e1 := time.ParseInLocation("2006-01-02", seg.Start, time.Local) end, e2 := time.ParseInLocation("2006-01-02", seg.End, time.Local) if e1 != nil || e2 != nil || !end.After(start) && !end.Equal(start) { return nil, errors.New("日期区间格式错误(应为 yyyy-MM-dd,且结束≥开始):" + seg.Start + "~" + seg.End) } for d := start; !d.After(end); d = d.AddDate(0, 0, 1) { ds := d.Format("2006-01-02") if !seen[ds] { seen[ds] = true out = append(out, ds) } } } sort.Strings(out) return out, nil } // distributeQty 把 total 件分摊到 days 天: // AVG 平均分摊(余数补到前面几天,合计=total);FIXED 每日 dailyQty(末日取余数,合计=min(total, dailyQty*days))。 // 返回每日数量切片(长度=days)。调用方需自行校验 total 不超过可排上限(quota)。 func distributeQty(total, days int, mode string, dailyQty int) []int { out := make([]int, days) if days <= 0 || total <= 0 { return out } switch mode { case "FIXED": left := total for i := 0; i < days; i++ { if left >= dailyQty { out[i] = dailyQty left -= dailyQty } else { out[i] = left left = 0 } } default: // AVG base := total / days for i := 0; i < days; i++ { out[i] = base } for i := 0; i < total-base*days; i++ { out[i]++ } } return out } // autoScheduleGuard 排产公共校验:工单存在/状态/工艺组合一致; // 返回工单、应排总数(quota=未开工数量−既有排产合计)、既有排产按日期索引。 func (s *Service) autoScheduleGuard(ctx context.Context, orderNo string) (*ent.WorkOrder, int, map[string]*ent.DailyPlan, error) { wo, err := s.ctx.EntClient.WorkOrder.Query().Where(workorder.WorkOrderNo(orderNo)).First(ctx) if err != nil { return nil, 0, nil, errors.New("工单不存在") } if wo.Status == "DONE" || wo.Status == "CANCELLED" { return nil, 0, nil, errors.New("该工单已完成或已取消,不能排产") } if wo.Status == "PAUSED" { return nil, 0, nil, errors.New("该工单已暂停,恢复执行前不能排产") } // 排产继承工单工艺组合(唯一路线源头,不可改):先校验组合与工位绑定一致 if err := s.ValidateWOCombinationForSchedule(ctx, wo); err != nil { return nil, 0, nil, err } remain, err := s.unscheduledQty(ctx, wo) if err != nil { return nil, 0, nil, err } exist, _ := s.ctx.EntClient.DailyPlan.Query().Where(dailyplan.OrderNo(orderNo)).All(ctx) byDate := make(map[string]*ent.DailyPlan, len(exist)) for _, p := range exist { byDate[p.PlanDate] = p } quota := remain // 应排总数 = 剩余可排 = 工单总数量 − 累计已排产量 if quota < 0 { quota = 0 } return wo, quota, byDate, nil } // AutoSchedulePreviewRow 排产预览行:Editable=false 的日已执行中/已完成,数量锁定不可调 type AutoSchedulePreviewRow struct { Date string `json:"date"` Qty int `json:"qty"` Editable bool `json:"editable"` ExistStatus string `json:"existStatus"` // 该日既有排产状态;""=无既有排产 } // AutoSchedulePreview 排产预览结果:可调行(Editable=true)数量合计 == Quota,确认时原样提交 type AutoSchedulePreview struct { OrderNo string `json:"orderNo"` Quota int `json:"quota"` // 应排总数 = 未开工数量 − 既有排产合计 Rows []AutoSchedulePreviewRow `json:"rows"` } // AutoSchedulePreview 排产预览(不落库,M9 定稿 2026-09-29):按模式给出初始逐日数量, // 用户在预览中逐日自行调节(前松/中紧/后松等任意节奏),确认走 AutoScheduleApply。 // 已执行中/已完成的日期原样展示并锁定(其数量已计入既有排产、不占本次 quota)。 func (s *Service) AutoSchedulePreview(ctx context.Context, req AutoScheduleReq) (*AutoSchedulePreview, error) { // 收集式校验(2026-10-20 报错规范) ve := verr.New() if req.OrderNo == "" { ve.Add("orderNo", "工单号必填", "请选择要排产的工单") } if req.Mode != "AVG" && req.Mode != "FIXED" { ve.Add("mode", "排产模式仅支持 平均分摊 / 固定日产", "在「分摊模式」里重新选择") } if req.Mode == "FIXED" && req.DailyQty <= 0 { ve.Add("dailyQty", "固定日产模式需填写每日产量", "把「每日产量」填为大于 0 的整数") } if err := ve.OrNil(); err != nil { return nil, err } dates, err := expandDates(req.Segments) if err != nil { ve.Add("segments", err.Error(), "日期区间应为 yyyy-MM-dd,且结束日期不早于开始日期") return nil, ve.OrNil() } if len(dates) == 0 { ve.Add("segments", "请至少选择一个日期区间", "选择排产的起止日期后再预览") return nil, ve.OrNil() } _, quota, byDate, err := s.autoScheduleGuard(ctx, req.OrderNo) if err != nil { // guard 内多为单点校验(工单不存在/状态/组合),包装进收集式保持响应形态统一 ve.Add("orderNo", err.Error(), "请核对该工单的状态与工艺组合后重试") return nil, ve.OrNil() } if quota == 0 { ve.Add("orderNo", "该工单剩余可排为 0,无需排产(已排满)", "如需增产请先调整工单总量,或检查已有排产数量") return nil, ve.OrNil() } rows := make([]AutoSchedulePreviewRow, 0, len(dates)) editDates := make([]string, 0, len(dates)) for _, ds := range dates { if p := byDate[ds]; p != nil && (p.Status == "PROCESSING" || p.Status == "DONE") { rows = append(rows, AutoSchedulePreviewRow{Date: ds, Qty: p.PlanQty, Editable: false, ExistStatus: p.Status}) continue } editDates = append(editDates, ds) rows = append(rows, AutoSchedulePreviewRow{Date: ds, Qty: 0, Editable: true}) } if len(editDates) == 0 { ve.Add("segments", "所选日期均已有执行中/已完成的排产,无可调日期", "更换其他日期区间(执行中/已完成的日期不能重排)") return nil, ve.OrNil() } if req.Mode == "FIXED" && quota > req.DailyQty*len(editDates) { ve.Add("dailyQty", fmt.Sprintf("固定日产 %d×可调天数 %d = %d 件,不足应排总数 %d 件", req.DailyQty, len(editDates), req.DailyQty*len(editDates), quota), "增加日期区间,或提高每日产量后重新预览") return nil, ve.OrNil() } mode := "AVG" if req.Mode == "FIXED" { mode = "FIXED" } initial := distributeQty(quota, len(editDates), mode, req.DailyQty) k := 0 for i := range rows { if rows[i].Editable { rows[i].Qty = initial[k] k++ } } return &AutoSchedulePreview{OrderNo: req.OrderNo, Quota: quota, Rows: rows}, nil } // AutoScheduleApplyItem 确认排产的逐日数量(预览中用户自行调节后的结果) type AutoScheduleApplyItem struct { Date string `json:"date"` Qty int `json:"qty"` } // AutoScheduleApplyReq 确认排产请求:Σ逐日数量必须等于应排总数(总数据要对的上) type AutoScheduleApplyReq struct { OrderNo string `json:"orderNo"` Items []AutoScheduleApplyItem `json:"items"` } // AutoScheduleApply 确认排产(预览手调后提交): // 校验 Σ逐日数量 == 应排总数(quota)、逐日 ≥0、不触碰执行中/已完成日期; // 数量为 0 的日删除既有待执行行(不新建 0 行),其余覆盖式写入 status=PENDING 待人工启用。 func (s *Service) AutoScheduleApply(ctx context.Context, req AutoScheduleApplyReq, operator string) error { // 收集式校验(2026-10-20 报错规范):逐日明细错误一次收全 ve := verr.New() if req.OrderNo == "" { ve.Add("orderNo", "工单号必填", "请选择要排产的工单") } if len(req.Items) == 0 { ve.Add("items", "排产明细为空", "请先生成排产预览、逐日调整后再确认") } if err := ve.OrNil(); err != nil { return err } _, quota, byDate, err := s.autoScheduleGuard(ctx, req.OrderNo) if err != nil { ve.Add("orderNo", err.Error(), "请核对该工单的状态与工艺组合后重试") return ve.OrNil() } if quota == 0 { ve.Add("orderNo", "该工单剩余可排为 0,无需排产(已排满)", "如需增产请先调整工单总量,或检查已有排产数量") return ve.OrNil() } seen := map[string]bool{} sum := 0 for _, it := range req.Items { if _, err := parseDate(it.Date); err != nil { ve.Add("items", "日期格式错误(应为 yyyy-MM-dd):"+it.Date, "逐行检查明细中的日期格式") continue } if seen[it.Date] { ve.Add("items", "日期重复:"+it.Date, "同一日期只保留一行明细") continue } seen[it.Date] = true if it.Qty < 0 { ve.Add("items", "日期 "+it.Date+" 的排产数量为负数", "把该日数量改为 0 或正整数") continue } if p := byDate[it.Date]; p != nil && (p.Status == "PROCESSING" || p.Status == "DONE") { ve.Add("items", "日期 "+it.Date+" 的排产已执行中/已完成,不能修改", "确认时去掉该日期,或保持该日原数量不变") continue } sum += it.Qty } if ve.Len() == 0 && sum != quota { ve.Add("items", fmt.Sprintf("各日合计 %d 件 ≠ 应排总数 %d 件(总数据必须对上)", sum, quota), fmt.Sprintf("回到预览调整各日数量,使合计等于 %d 件", quota)) } if err := ve.OrNil(); err != nil { return err } for _, it := range req.Items { existOne := byDate[it.Date] switch { case it.Qty == 0: if existOne != nil { if err := s.ctx.EntClient.DailyPlan.DeleteOneID(existOne.ID).Exec(ctx); err != nil { return err } } case existOne != nil: // 覆盖式更新;原 CONFIRMED 回退 PENDING,需重新人工启用(与原自动排产口径一致) if _, err := s.ctx.EntClient.DailyPlan.UpdateOneID(existOne.ID). SetPlanQty(it.Qty).SetStatus("PENDING").SetOperator(operator).Save(ctx); err != nil { return err } default: if _, err := s.ctx.EntClient.DailyPlan.Create(). SetOrderNo(req.OrderNo).SetPlanDate(it.Date).SetPlanQty(it.Qty). SetStatus("PENDING").SetOperator(operator).Save(ctx); err != nil { return err } } } s.ctx.EventLog.Write(ctx, "daily.plan.apply", req.OrderNo, operator, "daily_plan", req.OrderNo, "确认排产(预览逐日调节)", map[string]any{"days": len(req.Items), "total": sum, "quota": quota}) // 叫料池重算(B5) _, _ = s.RecomputePoolAll(ctx) s.notifyDashboard() return nil }