Files
bj_power/bj_power_mes/internal/logic/dailyplan.go
T

835 lines
31 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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
}