835 lines
31 KiB
Go
835 lines
31 KiB
Go
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
|
||
}
|