- 移除station表的hasDock、dockCode字段及相关代码 - 新增dock表注释及关联逻辑,支持一个工位绑定多个接驳台 - 更新工位相关的seed、logic、schema及前端代码,适配新的接驳台管理方式 - 新增SQL注释固化脚本,完善MES表注释
877 lines
31 KiB
Go
877 lines
31 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"sort"
|
||
"strings"
|
||
"time"
|
||
|
||
"bj_power_mes/ent"
|
||
"bj_power_mes/ent/dailyplan"
|
||
"bj_power_mes/ent/flowmaterial"
|
||
"bj_power_mes/ent/inspectionrecord"
|
||
"bj_power_mes/ent/processflow"
|
||
"bj_power_mes/ent/processstep"
|
||
"bj_power_mes/ent/station"
|
||
"bj_power_mes/ent/stepcriterion"
|
||
"bj_power_mes/ent/workorder"
|
||
"bj_power_mes/ent/workpieceprocess"
|
||
)
|
||
|
||
// ---------- 工艺流程(块3) ----------
|
||
|
||
// FlowReq 工艺流程保存请求(流程=菜谱,只描述"怎么干")
|
||
// Stations:绑定工位列表(可多选,一个流程可绑多个工位)。
|
||
type FlowReq struct {
|
||
Id int `json:"id"`
|
||
Name string `json:"name"`
|
||
Stations []int `json:"stations"`
|
||
PdfFile string `json:"pdfFile"`
|
||
Status string `json:"status"`
|
||
Remark string `json:"remark"`
|
||
Steps []StepItemReq `json:"steps"`
|
||
}
|
||
|
||
// FlowVO 工艺流程视图(含工序步骤 + 绑定该流程的工位号)
|
||
type FlowVO struct {
|
||
Id int `json:"id"`
|
||
Name string `json:"name"`
|
||
PdfFile string `json:"pdfFile"`
|
||
Status string `json:"status"`
|
||
Remark string `json:"remark"`
|
||
Stations []int `json:"stations"`
|
||
Steps []*ProcessStepTemplate `json:"steps"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
}
|
||
|
||
// ListFlows 查询工艺流程(可按工位号过滤:只认「关联工位」页的绑定关系 station.flow_id)
|
||
// page>0 时真分页返回 map{total,list,page,pageSize}(管理页用);page=0 全量数组(工位终端兼容)
|
||
func (s *Service) ListFlows(ctx context.Context, stationNo, page, pageSize int) (any, error) {
|
||
q := s.ctx.EntClient.ProcessFlow.Query().
|
||
Order(ent.Asc(processflow.FieldID))
|
||
flows, err := q.All(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
stations, _ := s.ctx.EntClient.Station.Query().All(ctx)
|
||
flowToStations := map[int][]int{}
|
||
for _, st := range stations {
|
||
if st.FlowId > 0 {
|
||
flowToStations[st.FlowId] = append(flowToStations[st.FlowId], st.StationNo)
|
||
}
|
||
}
|
||
out := make([]*FlowVO, 0, len(flows))
|
||
for _, f := range flows {
|
||
// 过滤:指定工位号时,只返回绑定了该工位的流程
|
||
if stationNo > 0 {
|
||
hit := false
|
||
for _, st := range flowToStations[f.ID] {
|
||
if st == stationNo {
|
||
hit = true
|
||
break
|
||
}
|
||
}
|
||
if !hit {
|
||
continue
|
||
}
|
||
}
|
||
vo := &FlowVO{
|
||
Id: f.ID, Name: f.Name,
|
||
PdfFile: f.PdfFile, Status: f.Status, Remark: f.Remark,
|
||
Stations: []int{}, Steps: s.flowSteps(ctx, f.ID), CreatedAt: f.CreatedAt,
|
||
}
|
||
if list, ok := flowToStations[f.ID]; ok {
|
||
vo.Stations = list
|
||
}
|
||
out = append(out, vo)
|
||
}
|
||
if page > 0 {
|
||
total := len(out)
|
||
start := (page - 1) * pageSize
|
||
if start > total {
|
||
start = total
|
||
}
|
||
end := start + pageSize
|
||
if end > total {
|
||
end = total
|
||
}
|
||
return map[string]any{"total": total, "list": out[start:end], "page": page, "pageSize": pageSize}, nil
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// SaveFlow 保存工艺流程(可一次绑定多个工位)。
|
||
// 约束:① 绑定工位必须已存在(工位主数据由数据库维护,本接口不自动创建);
|
||
// ② 一个工位同时只能绑定一个流程(保存时直接覆盖旧绑定);
|
||
// ③ 停用流程不再自动解绑工位(绑定关系由本保存接口显式维护,启停只切流程状态)。
|
||
func (s *Service) SaveFlow(ctx context.Context, req FlowReq, operator string) error {
|
||
if req.Name == "" {
|
||
return errors.New("流程名称必填")
|
||
}
|
||
// 解析绑定工位列表
|
||
seen := map[int]bool{}
|
||
stations := []int{}
|
||
for _, no := range req.Stations {
|
||
if no < 1 || seen[no] {
|
||
continue
|
||
}
|
||
seen[no] = true
|
||
stations = append(stations, no)
|
||
}
|
||
status := req.Status
|
||
if status == "" {
|
||
status = "ACTIVE"
|
||
}
|
||
if status != "ACTIVE" && status != "INACTIVE" {
|
||
return errors.New("非法状态")
|
||
}
|
||
// 绑定语义(2026-09-08 定稿):直接更换——一个工位只有一条关联数据,
|
||
// 保存时所选工位一律改绑到本流程(覆盖旧绑定),不再报"已被启用流程绑定"冲突。
|
||
var flowID int
|
||
if req.Id > 0 {
|
||
upd := s.ctx.EntClient.ProcessFlow.UpdateOneID(req.Id).
|
||
SetName(req.Name).SetStatus(status).SetRemark(req.Remark)
|
||
if req.PdfFile != "" {
|
||
upd.SetPdfFile(req.PdfFile)
|
||
}
|
||
if _, err := upd.Save(ctx); err != nil {
|
||
return err
|
||
}
|
||
flowID = req.Id
|
||
} else {
|
||
f, err := s.ctx.EntClient.ProcessFlow.Create().
|
||
SetName(req.Name).SetPdfFile(req.PdfFile).
|
||
SetStatus(status).SetRemark(req.Remark).Save(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
flowID = f.ID
|
||
}
|
||
// 绑定同步:把绑定列表整体指向该流程(旧绑定该流程但不在列表内的工位解绑)
|
||
boundNow, _ := s.ctx.EntClient.Station.Query().Where(station.FlowId(flowID)).All(ctx)
|
||
for _, st := range boundNow {
|
||
if !seen[st.StationNo] {
|
||
_, _ = s.ctx.EntClient.Station.UpdateOneID(st.ID).SetFlowId(0).Save(ctx)
|
||
}
|
||
}
|
||
for _, no := range stations {
|
||
if err := s.syncStationFlow(ctx, no, flowID); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
// 覆盖式重建该流程的工序步骤及考核标准
|
||
_, _ = s.ctx.EntClient.ProcessStep.Delete().Where(processstep.FlowId(flowID)).Exec(ctx)
|
||
for _, st := range req.Steps {
|
||
if st.Name == "" {
|
||
continue
|
||
}
|
||
rec, err := s.ctx.EntClient.ProcessStep.Create().
|
||
SetFlowId(flowID).SetSeq(st.Seq).SetName(st.Name).
|
||
SetCollectType(st.CollectType).SetIsTorque(st.IsTorque).SetNeedCheck(st.NeedCheck).
|
||
SetNeedOperatorSign(st.NeedOperatorSign).SetNeedInspectorSign(st.NeedInspectorSign).
|
||
SetRemark(st.Remark).SetAttachment(st.Attachment).Save(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
_, _ = s.ctx.EntClient.StepCriterion.Delete().Where(stepcriterion.StepId(rec.ID)).Exec(ctx)
|
||
for _, c := range st.Criteria {
|
||
if c.Name == "" || c.Logic == "" || c.Logic == "NONE" {
|
||
continue
|
||
}
|
||
b := s.ctx.EntClient.StepCriterion.Create().
|
||
SetStepId(rec.ID).SetName(c.Name).SetUnit(c.Unit).SetLogic(c.Logic).SetTarget(c.Target)
|
||
if c.Min != nil {
|
||
b = b.SetMin(*c.Min)
|
||
}
|
||
if c.Max != nil {
|
||
b = b.SetMax(*c.Max)
|
||
}
|
||
if err := b.Exec(ctx); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
s.ctx.EventLog.Write(ctx, "process.flow.save", "", operator, "process_flow", "", "维护工艺流程",
|
||
map[string]any{"flowId": flowID, "stations": stations, "steps": len(req.Steps)})
|
||
return nil
|
||
}
|
||
|
||
// syncStationFlow 同步工位绑定:工位 stationNo 绑定到 flowID(工位不存在时报错,不自动创建)
|
||
func (s *Service) syncStationFlow(ctx context.Context, stationNo, flowID int) error {
|
||
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx)
|
||
if err != nil {
|
||
return fmt.Errorf("工位 %d 不存在,请先在工位主数据中维护", stationNo)
|
||
}
|
||
_, err = s.ctx.EntClient.Station.UpdateOneID(st.ID).SetFlowId(flowID).Save(ctx)
|
||
return err
|
||
}
|
||
|
||
func (s *Service) DeleteFlow(ctx context.Context, id int, operator string) error {
|
||
// 删除前先解除所有工位绑定,再清步骤与流程本身
|
||
_, _ = s.ctx.EntClient.Station.Update().
|
||
Where(station.FlowId(id)).
|
||
SetFlowId(0).Save(ctx)
|
||
_, _ = s.ctx.EntClient.ProcessStep.Delete().Where(processstep.FlowId(id)).Exec(ctx)
|
||
s.ctx.EventLog.Write(ctx, "process.flow.delete", "", operator, "process_flow", "", "删除工艺流程", map[string]any{"flowId": id})
|
||
return s.ctx.EntClient.ProcessFlow.DeleteOneID(id).Exec(ctx)
|
||
}
|
||
|
||
// flowSteps 查询某流程的工序步骤(含考核标准)
|
||
func (s *Service) flowSteps(ctx context.Context, flowId int) []*ProcessStepTemplate {
|
||
steps, _ := s.ctx.EntClient.ProcessStep.Query().
|
||
Where(processstep.FlowId(flowId)).Order(ent.Asc(processstep.FieldSeq)).All(ctx)
|
||
out := make([]*ProcessStepTemplate, 0, len(steps))
|
||
for _, st := range steps {
|
||
t := &ProcessStepTemplate{
|
||
ID: st.ID, Seq: st.Seq,
|
||
Name: st.Name, CollectType: st.CollectType, IsTorque: st.IsTorque, NeedCheck: st.NeedCheck,
|
||
NeedOperatorSign: st.NeedOperatorSign, NeedInspectorSign: st.NeedInspectorSign,
|
||
Remark: st.Remark, Attachment: st.Attachment, Criteria: []CriterionVO{},
|
||
}
|
||
crits, _ := s.ctx.EntClient.StepCriterion.Query().
|
||
Where(stepcriterion.StepId(st.ID)).All(ctx)
|
||
for _, c := range crits {
|
||
t.Criteria = append(t.Criteria, CriterionVO{
|
||
ID: c.ID, Name: c.Name, Unit: c.Unit, Logic: c.Logic,
|
||
Target: c.Target, Min: c.Min, Max: c.Max,
|
||
})
|
||
}
|
||
out = append(out, t)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ---------- 工位主数据(块3) ----------
|
||
|
||
type StationReq struct {
|
||
Id int `json:"id"`
|
||
StationNo int `json:"stationNo"`
|
||
Name string `json:"name"`
|
||
StationType *string `json:"stationType"`
|
||
FlowId *int `json:"flowId"`
|
||
VisibleTabs []string `json:"visibleTabs"` // 终端可见页签(空=全部显示)
|
||
}
|
||
|
||
type StationVO struct {
|
||
Id int `json:"id"`
|
||
StationNo int `json:"stationNo"`
|
||
Name string `json:"name"`
|
||
FlowId int `json:"flowId"`
|
||
FlowName string `json:"flowName"`
|
||
StationType string `json:"stationType"`
|
||
Status string `json:"status"`
|
||
IsBuiltin bool `json:"isBuiltin"`
|
||
VisibleTabs []string `json:"visibleTabs"`
|
||
}
|
||
|
||
func (s *Service) ListStations(ctx context.Context) ([]*StationVO, error) {
|
||
stas, err := s.ctx.EntClient.Station.Query().Order(ent.Asc(station.FieldStationNo)).All(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
flows, _ := s.ctx.EntClient.ProcessFlow.Query().All(ctx)
|
||
flowMap := map[int]*ent.ProcessFlow{}
|
||
for _, f := range flows {
|
||
flowMap[f.ID] = f
|
||
}
|
||
out := make([]*StationVO, 0, len(stas))
|
||
for _, st := range stas {
|
||
vo := &StationVO{Id: st.ID, StationNo: st.StationNo, Name: st.Name, FlowId: st.FlowId, StationType: st.StationType, Status: st.Status, IsBuiltin: st.IsBuiltin, VisibleTabs: st.VisibleTabs}
|
||
if f, ok := flowMap[st.FlowId]; ok {
|
||
vo.FlowName = f.Name
|
||
}
|
||
out = append(out, vo)
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// SaveStation 维护工位:
|
||
// - 工位号已存在 → 只改名称/类型/绑定流程(不增删工位)
|
||
// - 工位号不存在 → 新增工位;新增的工位号由用户自定义,允许扩展 14、15…(虚拟/物理均可)
|
||
//
|
||
// 工位数量以数据库为准,前端下拉随 station 表自动增减;虚拟工位(0/13/14...)不连 PLC、仅记录。
|
||
// 内置工位(种子/初始化数据,is_builtin=true)需连 PLC 并必须按工位号顺序流转,
|
||
// 不允许手动更改工位类型;页面新增的工位一律为非内置,可改类型、可删除。
|
||
// 接驳台为独立主数据(MES dock 表),一个工位可绑定多个接驳台,关系以 dock.station_no 为准,页面不维护。
|
||
func (s *Service) SaveStation(ctx context.Context, req StationReq, operator string) error {
|
||
if req.StationNo < 0 {
|
||
return errors.New("工位号非法(需 ≥ 0)")
|
||
}
|
||
if req.StationNo == 0 && req.Name == "" {
|
||
return errors.New("工位号非法")
|
||
}
|
||
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(req.StationNo)).First(ctx)
|
||
if err != nil {
|
||
// 新增工位:工位号不存在即创建
|
||
if req.Name == "" {
|
||
return errors.New("请填写工位名称")
|
||
}
|
||
stype := "LINE"
|
||
if req.StationType != nil {
|
||
stype = *req.StationType
|
||
if stype != "LINE" && stype != "OFFLINE" {
|
||
return errors.New("工位类型仅支持 LINE/OFFLINE")
|
||
}
|
||
}
|
||
cr := s.ctx.EntClient.Station.Create().
|
||
SetStationNo(req.StationNo).SetName(req.Name).SetStationType(stype).SetStatus("ENABLED").
|
||
// 页面「新增工位」创建的是非内置工位(可改类型、可删除);内置工位只能由种子/初始化数据产生。
|
||
SetIsBuiltin(false)
|
||
if len(req.VisibleTabs) > 0 {
|
||
cr.SetVisibleTabs(req.VisibleTabs)
|
||
}
|
||
if req.FlowId != nil && *req.FlowId > 0 {
|
||
flow, fErr := s.ctx.EntClient.ProcessFlow.Get(ctx, *req.FlowId)
|
||
if fErr != nil {
|
||
return errors.New("所选工艺流程不存在")
|
||
}
|
||
if flow.Status != "ACTIVE" {
|
||
return errors.New("该工艺流程已停用,请先启用后再绑定工位")
|
||
}
|
||
cr.SetFlowId(*req.FlowId)
|
||
}
|
||
created, cErr := cr.Save(ctx)
|
||
if cErr != nil {
|
||
return cErr
|
||
}
|
||
s.ctx.EventLog.Write(ctx, "station.create", "", operator, "station", "",
|
||
"新增工位", map[string]any{"stationNo": created.StationNo, "name": created.Name})
|
||
return nil
|
||
}
|
||
// 仅改名称:flowId 不传(nil)保留原绑定;0=解绑;>0=绑定指定启用流程
|
||
upd := s.ctx.EntClient.Station.UpdateOneID(st.ID).SetName(req.Name)
|
||
if req.StationType != nil {
|
||
t := *req.StationType
|
||
if t != "LINE" && t != "OFFLINE" {
|
||
return errors.New("工位类型仅支持 LINE/OFFLINE")
|
||
}
|
||
// 内置工位对应实体产线固定位置(含 PLC 通讯与顺序流转),工位类型不可手动更改。
|
||
if st.IsBuiltin && t != st.StationType {
|
||
return errors.New("内置工位不允许修改工位类型")
|
||
}
|
||
if !st.IsBuiltin {
|
||
upd.SetStationType(t)
|
||
}
|
||
}
|
||
if req.FlowId != nil {
|
||
fid := *req.FlowId
|
||
if fid > 0 {
|
||
flow, fErr := s.ctx.EntClient.ProcessFlow.Get(ctx, fid)
|
||
if fErr != nil {
|
||
return errors.New("所选工艺流程不存在")
|
||
}
|
||
if flow.Status != "ACTIVE" {
|
||
return errors.New("该工艺流程已停用,请先启用后再绑定工位")
|
||
}
|
||
upd.SetFlowId(fid)
|
||
} else {
|
||
upd.SetFlowId(0)
|
||
}
|
||
}
|
||
// 终端可见页签:传 nil=不改;传空数组=清空(全部显示);传列表=按配置显示
|
||
if req.VisibleTabs != nil {
|
||
upd.SetVisibleTabs(req.VisibleTabs)
|
||
}
|
||
if _, err := upd.Save(ctx); err != nil {
|
||
return err
|
||
}
|
||
s.ctx.EventLog.Write(ctx, "station.save", "", operator, "station", "", "维护工位",
|
||
map[string]any{"stationNo": req.StationNo})
|
||
return nil
|
||
}
|
||
|
||
// DeleteStation 删除工位:内置工位不允许删除(对应实体产线位置,需连 PLC 且必须按顺序流转);
|
||
// 非内置工位(页面新增的)允许删除。
|
||
func (s *Service) DeleteStation(ctx context.Context, id int, operator string) error {
|
||
if id <= 0 {
|
||
return errors.New("缺少 id")
|
||
}
|
||
st, err := s.ctx.EntClient.Station.Get(ctx, id)
|
||
if err != nil {
|
||
return errors.New("工位不存在")
|
||
}
|
||
if st.IsBuiltin {
|
||
return errors.New("内置工位不允许删除")
|
||
}
|
||
if err := s.ctx.EntClient.Station.DeleteOneID(st.ID).Exec(ctx); err != nil {
|
||
return err
|
||
}
|
||
s.ctx.EventLog.Write(ctx, "station.delete", "", operator, "station", "", "删除工位",
|
||
map[string]any{"stationNo": st.StationNo, "name": st.Name})
|
||
return nil
|
||
}
|
||
|
||
// SetFlowStatus 工艺流程启用/停用。
|
||
// 新语义:绑定关系由「保存流程」显式维护(一个流程可绑多工位),启停只切换流程状态,
|
||
// 不再自动解绑/绑定工位;停用流程对已绑定工位不可用(工位取步骤时按 ACTIVE 过滤)。
|
||
func (s *Service) SetFlowStatus(ctx context.Context, id int, status, operator string) error {
|
||
if id <= 0 {
|
||
return errors.New("缺少 id")
|
||
}
|
||
if status != "ACTIVE" && status != "INACTIVE" {
|
||
return errors.New("非法状态")
|
||
}
|
||
flow, err := s.ctx.EntClient.ProcessFlow.Get(ctx, id)
|
||
if err != nil {
|
||
return errors.New("工艺流程不存在")
|
||
}
|
||
if flow.Status == status {
|
||
return nil
|
||
}
|
||
// 启用无需额外动作:绑定由保存流程时校验(一个工位不会被两个启用流程占用)
|
||
if err := s.ctx.EntClient.ProcessFlow.UpdateOneID(id).SetStatus(status).Exec(ctx); err != nil {
|
||
return err
|
||
}
|
||
action := "停用工艺流程"
|
||
if status == "ACTIVE" {
|
||
action = "启用工艺流程"
|
||
}
|
||
s.ctx.EventLog.Write(ctx, "process.flow.status", "", operator, "process_flow", "", action, map[string]any{"flowId": id, "status": status, "name": flow.Name})
|
||
return nil
|
||
}
|
||
|
||
// ---------- 工位任务(块4/5:工位终端拉取) ----------
|
||
|
||
func (s *Service) StationTask(ctx context.Context, stationNo int) (map[string]any, error) {
|
||
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx)
|
||
if err != nil {
|
||
return nil, errors.New("工位不存在或未配置")
|
||
}
|
||
// 工位终端可见工单 = 今日已启用排产(CONFIRMED/执行中)且工单已下发/在制(RELEASED/IN_PROGRESS)。
|
||
// 与状态机对齐:工单下发=批准生产、排产启用=排进某一天;未下发或未排进今天的工单,终端一律不显示。
|
||
orderNos := []string{}
|
||
today := time.Now().Format("2006-01-02")
|
||
plans, _ := s.ctx.EntClient.DailyPlan.Query().
|
||
Where(dailyplan.PlanDate(today), dailyplan.StatusIn("CONFIRMED", "PROCESSING")).
|
||
Order(ent.Asc(dailyplan.FieldID)).All(ctx)
|
||
nos := make([]string, 0, len(plans))
|
||
seen := map[string]bool{}
|
||
for _, p := range plans {
|
||
if !seen[p.OrderNo] {
|
||
seen[p.OrderNo] = true
|
||
nos = append(nos, p.OrderNo)
|
||
}
|
||
}
|
||
if len(nos) > 0 {
|
||
wos, _ := s.ctx.EntClient.WorkOrder.Query().
|
||
Where(workorder.WorkOrderNoIn(nos...), workorder.StatusIn("RELEASED", "IN_PROGRESS")).
|
||
Order(ent.Asc(workorder.FieldID)).All(ctx)
|
||
for _, w := range wos {
|
||
orderNos = append(orderNos, w.WorkOrderNo)
|
||
}
|
||
}
|
||
// M4:工位终端按「本工位绑定的工艺流程」驱动。
|
||
// 产线定义 = 关联工位(station.flow_id)+ 工位号 1→12 顺序,已无独立"工艺路线/路线段"对象。
|
||
// 本工位要干哪些步骤,完全取决于 station.flow_id 指向的流程图,工单的 processSeq 只决定走哪些工位。
|
||
activeFlowId := st.FlowId
|
||
var flow *ent.ProcessFlow
|
||
if activeFlowId > 0 {
|
||
flow, _ = s.ctx.EntClient.ProcessFlow.Get(ctx, activeFlowId)
|
||
}
|
||
steps := []*ProcessStepTemplate{}
|
||
if flow != nil && flow.Status == "ACTIVE" {
|
||
steps = s.flowSteps(ctx, flow.ID)
|
||
}
|
||
return map[string]any{
|
||
"stationNo": st.StationNo,
|
||
"stationName": st.Name,
|
||
"flowId": activeFlowId,
|
||
"flow": flow,
|
||
"flowActive": flow != nil && flow.Status == "ACTIVE",
|
||
"steps": steps,
|
||
"orderNos": orderNos,
|
||
// 终端可见页签(按工位配置;空=全部显示)
|
||
"tabs": st.VisibleTabs,
|
||
}, nil
|
||
}
|
||
|
||
// WorkloadRow 绩效/工作量聚合行(按人/按工位/明细三视图共用)
|
||
// 前端按 camelCase 读取,必须显式标注 json tag(否则 Go 默认序列化为 PascalCase 导致列空白)
|
||
type WorkloadRow struct {
|
||
Operator string `json:"operator"`
|
||
StationNo string `json:"stationNo"`
|
||
Date string `json:"date"`
|
||
OrderNo string `json:"orderNo"`
|
||
FlowId int `json:"flowId"`
|
||
ProcessName string `json:"processName"`
|
||
DoneCount int `json:"doneCount"`
|
||
OkCount int `json:"okCount"`
|
||
NgCount int `json:"ngCount"`
|
||
// Item M 绩效效率:作业时长取自 workpiece_process.duration_sec
|
||
TotalDurationSec int `json:"totalDurationSec"` // 累计作业时长(秒)
|
||
AvgDurationSec int `json:"avgDurationSec"` // 平均作业时长(秒)=累计/完成数
|
||
Efficiency float64 `json:"efficiency"` // 效率(件/小时)=完成数/(累计时长/3600)
|
||
}
|
||
|
||
// finalizeWorkloadRow 由累计作业时长与完成数派生平均作业时长与效率
|
||
func finalizeWorkloadRow(r *WorkloadRow) {
|
||
if r.DoneCount > 0 {
|
||
r.AvgDurationSec = r.TotalDurationSec / r.DoneCount
|
||
}
|
||
if r.TotalDurationSec > 0 {
|
||
r.Efficiency = float64(r.DoneCount) / (float64(r.TotalDurationSec) / 3600.0)
|
||
}
|
||
}
|
||
|
||
// StationSessionRow 上机记录行(由现有数据推导,零新表):
|
||
// 上机时间=开工签到(CHECKIN)时刻;下机时间=签到后该人该工位最后一条活动
|
||
// (报工 endedAt / 巡检记录 createdAt 取较大者,以同工位同人的下一次签到为界);
|
||
// 加工件数=窗口内报工实绩计数。口径说明:下机为「最后活动」推断,未签到则无记录。
|
||
type StationSessionRow struct {
|
||
Operator string `json:"operator"`
|
||
StationNo string `json:"stationNo"`
|
||
Date string `json:"date"` // 归属日期(签到那天)
|
||
CheckinAt string `json:"checkinAt"` // 上机时间(开工签到)
|
||
LastActiveAt string `json:"lastActiveAt"` // 下机时间(最后活动)
|
||
DurationSec int `json:"durationSec"` // 在机时长(秒)=下机-上机
|
||
DoneCount int `json:"doneCount"` // 加工件数
|
||
Efficiency float64 `json:"efficiency"` // 效率(件/小时)
|
||
}
|
||
|
||
const fmtSessionTime = "2006-01-02 15:04:05"
|
||
|
||
// buildStationSessions 由开工签到 + 报工实绩推导上机记录(按签到倒序)。
|
||
// rows 为已按 操作人/工位/日期 过滤的报工实绩(工单号筛选不影响本视图)。
|
||
func (s *Service) buildStationSessions(ctx context.Context, operator, stationNo, from, to string, rows []*ent.WorkpieceProcess) []StationSessionRow {
|
||
// 巡检记录:同筛选(不含工单号),既提供签到点也提供活动点
|
||
q := s.ctx.EntClient.InspectionRecord.Query()
|
||
if operator != "" {
|
||
q = q.Where(inspectionrecord.Operator(operator))
|
||
}
|
||
if stationNo != "" {
|
||
q = q.Where(inspectionrecord.StationNo(stationNo))
|
||
}
|
||
if from != "" {
|
||
if f, err := time.Parse("2006-01-02", from); err == nil {
|
||
q = q.Where(inspectionrecord.CreatedAtGTE(f))
|
||
}
|
||
}
|
||
if to != "" {
|
||
if t, err := time.Parse("2006-01-02", to); err == nil {
|
||
q = q.Where(inspectionrecord.CreatedAtLT(t.Add(24 * time.Hour)))
|
||
}
|
||
}
|
||
insps, err := q.All(ctx)
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
|
||
// 活动时间轴:key=操作人|工位 → 有序活动时刻列表(报工 + 巡检)
|
||
type key struct{ op, st string }
|
||
act := map[key][]time.Time{}
|
||
addAct := func(op, st string, t time.Time) {
|
||
if op == "" || t.IsZero() {
|
||
return
|
||
}
|
||
k := key{op, st}
|
||
act[k] = append(act[k], t)
|
||
}
|
||
for _, r := range rows {
|
||
t := r.CreatedAt
|
||
if r.EndedAt != nil {
|
||
t = *r.EndedAt
|
||
}
|
||
addAct(r.Operator, r.StationNo, t)
|
||
}
|
||
for _, in := range insps {
|
||
addAct(in.Operator, in.StationNo, in.CreatedAt)
|
||
}
|
||
for k := range act {
|
||
times := act[k]
|
||
sort.Slice(times, func(i, j int) bool { return times[i].Before(times[j]) })
|
||
act[k] = times
|
||
}
|
||
|
||
// 签到 → 会话:结束=窗口内最后活动(下一次签到为界),无活动则时长 0
|
||
type ck struct {
|
||
k key
|
||
at time.Time
|
||
}
|
||
checkins := make([]ck, 0, len(insps))
|
||
for _, in := range insps {
|
||
if in.Category == "CHECKIN" {
|
||
checkins = append(checkins, ck{key{in.Operator, in.StationNo}, in.CreatedAt})
|
||
}
|
||
}
|
||
sort.Slice(checkins, func(i, j int) bool {
|
||
if checkins[i].k.op != checkins[j].k.op {
|
||
return checkins[i].k.op < checkins[j].k.op
|
||
}
|
||
if checkins[i].k.st != checkins[j].k.st {
|
||
return checkins[i].k.st < checkins[j].k.st
|
||
}
|
||
return checkins[i].at.Before(checkins[j].at)
|
||
})
|
||
|
||
out := make([]StationSessionRow, 0, len(checkins))
|
||
for i, c := range checkins {
|
||
// 窗口终点:同人同工位的下一次签到;无下一次则+24h 兜底
|
||
endBound := c.at.Add(24 * time.Hour)
|
||
if i+1 < len(checkins) && checkins[i+1].k == c.k {
|
||
endBound = checkins[i+1].at
|
||
}
|
||
row := StationSessionRow{
|
||
Operator: c.k.op,
|
||
StationNo: c.k.st,
|
||
Date: c.at.Format("2006-01-02"),
|
||
CheckinAt: c.at.Format(fmtSessionTime),
|
||
}
|
||
var last time.Time
|
||
for _, t := range act[c.k] {
|
||
if t.After(c.at) && t.Before(endBound) && t.After(last) {
|
||
last = t
|
||
} else if t.After(endBound) {
|
||
break
|
||
}
|
||
}
|
||
if !last.IsZero() {
|
||
row.LastActiveAt = last.Format(fmtSessionTime)
|
||
row.DurationSec = int(last.Sub(c.at).Seconds())
|
||
} else {
|
||
row.LastActiveAt = row.CheckinAt
|
||
}
|
||
for _, r := range rows {
|
||
if r.Operator != c.k.op || r.StationNo != c.k.st {
|
||
continue
|
||
}
|
||
t := r.CreatedAt
|
||
if r.EndedAt != nil {
|
||
t = *r.EndedAt
|
||
}
|
||
if t.After(c.at) && !t.After(last) {
|
||
row.DoneCount++
|
||
}
|
||
}
|
||
if row.DurationSec > 0 {
|
||
row.Efficiency = float64(row.DoneCount) / (float64(row.DurationSec) / 3600.0)
|
||
}
|
||
out = append(out, row)
|
||
}
|
||
// 倒序:最新签到在前(与全项目增量展示口径一致)
|
||
sort.Slice(out, func(i, j int) bool { return out[i].CheckinAt > out[j].CheckinAt })
|
||
return out
|
||
}
|
||
|
||
// Workload 绩效统计(按人/按工位/明细三视图,各自真分页)。
|
||
// orderNo 非空时按工单号模糊过滤(客户第12条「记录查看加一项看工单号查询」)。
|
||
func (s *Service) Workload(ctx context.Context, operator, stationNo, orderNo, from, to string,
|
||
opPage, opSize, stPage, stSize, detPage, detSize int) (map[string]any, error) {
|
||
q := s.ctx.EntClient.WorkpieceProcess.Query()
|
||
if operator != "" {
|
||
q = q.Where(workpieceprocess.Operator(operator))
|
||
}
|
||
if stationNo != "" {
|
||
q = q.Where(workpieceprocess.StationNo(stationNo))
|
||
}
|
||
if orderNo != "" {
|
||
q = q.Where(workpieceprocess.OrderNoContainsFold(orderNo))
|
||
}
|
||
if from != "" {
|
||
if f, err := time.Parse("2006-01-02", from); err == nil {
|
||
q = q.Where(workpieceprocess.CreatedAtGTE(f))
|
||
}
|
||
}
|
||
if to != "" {
|
||
if t, err := time.Parse("2006-01-02", to); err == nil {
|
||
q = q.Where(workpieceprocess.CreatedAtLT(t.Add(24 * time.Hour)))
|
||
}
|
||
}
|
||
rows, err := q.All(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
type key struct {
|
||
op, station, date string
|
||
code int
|
||
order string
|
||
}
|
||
agg := map[key]*WorkloadRow{}
|
||
for _, r := range rows {
|
||
// 明细聚合粒度含工单号:按工单号筛选后行内可见归属(客户追问点)
|
||
k := key{r.Operator, r.StationNo, r.CreatedAt.Format("2006-01-02"), r.FlowId, r.OrderNo}
|
||
row, ok := agg[k]
|
||
if !ok {
|
||
row = &WorkloadRow{Operator: r.Operator, StationNo: r.StationNo, Date: k.date, OrderNo: r.OrderNo, FlowId: r.FlowId, ProcessName: r.ProcessName}
|
||
agg[k] = row
|
||
}
|
||
row.DoneCount++
|
||
row.TotalDurationSec += r.DurationSec
|
||
if r.Result == "OK" {
|
||
row.OkCount++
|
||
} else {
|
||
row.NgCount++
|
||
}
|
||
}
|
||
list := make([]*WorkloadRow, 0, len(agg))
|
||
for _, v := range agg {
|
||
list = append(list, v)
|
||
}
|
||
sort.Slice(list, func(i, j int) bool {
|
||
if list[i].Operator != list[j].Operator {
|
||
return list[i].Operator < list[j].Operator
|
||
}
|
||
if list[i].StationNo != list[j].StationNo {
|
||
return list[i].StationNo < list[j].StationNo
|
||
}
|
||
if list[i].Date != list[j].Date {
|
||
return list[i].Date < list[j].Date
|
||
}
|
||
if list[i].FlowId != list[j].FlowId {
|
||
return list[i].FlowId < list[j].FlowId
|
||
}
|
||
return list[i].OrderNo < list[j].OrderNo
|
||
})
|
||
|
||
// 三个视图分别聚合(2026-09-08 绩效报表改造:按人/按工位/明细,各自真分页)
|
||
byOpAgg := map[string]*WorkloadRow{}
|
||
byStAgg := map[string]*WorkloadRow{}
|
||
for _, v := range list {
|
||
opKey := v.Operator
|
||
if o, ok := byOpAgg[opKey]; ok {
|
||
o.DoneCount += v.DoneCount
|
||
o.OkCount += v.OkCount
|
||
o.NgCount += v.NgCount
|
||
o.TotalDurationSec += v.TotalDurationSec
|
||
} else {
|
||
byOpAgg[opKey] = &WorkloadRow{Operator: v.Operator, DoneCount: v.DoneCount, OkCount: v.OkCount, NgCount: v.NgCount, TotalDurationSec: v.TotalDurationSec}
|
||
}
|
||
stKey := v.StationNo
|
||
if o, ok := byStAgg[stKey]; ok {
|
||
o.DoneCount += v.DoneCount
|
||
o.OkCount += v.OkCount
|
||
o.NgCount += v.NgCount
|
||
o.TotalDurationSec += v.TotalDurationSec
|
||
} else {
|
||
byStAgg[stKey] = &WorkloadRow{StationNo: v.StationNo, DoneCount: v.DoneCount, OkCount: v.OkCount, NgCount: v.NgCount, TotalDurationSec: v.TotalDurationSec}
|
||
}
|
||
}
|
||
paginate := func(all []*WorkloadRow, page, size int) (int, []*WorkloadRow) {
|
||
total := len(all)
|
||
start := (page - 1) * size
|
||
if start > total {
|
||
start = total
|
||
}
|
||
end := start + size
|
||
if end > total {
|
||
end = total
|
||
}
|
||
return total, all[start:end]
|
||
}
|
||
|
||
byOpList := make([]*WorkloadRow, 0, len(byOpAgg))
|
||
for _, v := range byOpAgg {
|
||
finalizeWorkloadRow(v)
|
||
byOpList = append(byOpList, v)
|
||
}
|
||
sort.Slice(byOpList, func(i, j int) bool { return byOpList[i].Operator < byOpList[j].Operator })
|
||
byStList := make([]*WorkloadRow, 0, len(byStAgg))
|
||
for _, v := range byStAgg {
|
||
finalizeWorkloadRow(v)
|
||
byStList = append(byStList, v)
|
||
}
|
||
sort.Slice(byStList, func(i, j int) bool { return byStList[i].StationNo < byStList[j].StationNo })
|
||
|
||
// 明细视图:按 (操作人,工位,日期,工艺,工单号) 聚合,与前端明细表列(orderNo/date/doneCount/okCount/ngCount)对齐
|
||
for _, v := range list {
|
||
finalizeWorkloadRow(v)
|
||
}
|
||
opTotal, byOpPage := paginate(byOpList, opPage, opSize)
|
||
stTotal, byStPage := paginate(byStList, stPage, stSize)
|
||
detTotal, detList := paginate(list, detPage, detSize)
|
||
|
||
// 上机记录:由开工签到+报工实绩推导(不受工单号筛选影响,前端在该页签禁用工单号)
|
||
sessions := s.buildStationSessions(ctx, operator, stationNo, from, to, rows)
|
||
|
||
return map[string]any{
|
||
"byOperator": map[string]any{"total": opTotal, "list": byOpPage},
|
||
"byStation": map[string]any{"total": stTotal, "list": byStPage},
|
||
"detail": map[string]any{"total": detTotal, "list": detList},
|
||
"sessions": map[string]any{"total": len(sessions), "list": sessions},
|
||
}, nil
|
||
}
|
||
|
||
// ---------- 工艺物料清单(flow_material) ----------
|
||
|
||
// FlowMaterialReq 工艺物料清单条目(保存为整表覆盖)
|
||
type FlowMaterialReq struct {
|
||
MaterialCode string `json:"materialCode"`
|
||
MaterialName string `json:"materialName"`
|
||
Spec string `json:"spec"`
|
||
Unit string `json:"unit"`
|
||
SnMode int `json:"snMode"` // 是否逐件SN管理 1序列号件(录SN)/2批次件(冗余自物料档案)
|
||
UnitQty float64 `json:"unitQty"` // 单台用量
|
||
LossRate float64 `json:"lossRate"` // 损耗率(%)
|
||
}
|
||
|
||
// ListFlowMaterials 查某工艺的物料清单(按 ID 升序)
|
||
func (s *Service) ListFlowMaterials(ctx context.Context, flowId int) ([]*ent.FlowMaterial, error) {
|
||
return s.ctx.EntClient.FlowMaterial.Query().
|
||
Where(flowmaterial.FlowId(flowId)).
|
||
Order(ent.Asc(flowmaterial.FieldID)).All(ctx)
|
||
}
|
||
|
||
// SaveFlowMaterials 保存工艺物料清单(整表覆盖:先删后插)。
|
||
// 物料编码须在 WMS 物料档案存在;WMS 不可达/异常时降级放行并记日志,避免阻塞工艺配置。
|
||
func (s *Service) SaveFlowMaterials(ctx context.Context, flowId int, items []FlowMaterialReq, operator string) error {
|
||
if flowId <= 0 {
|
||
return errors.New("flowId 必填")
|
||
}
|
||
if _, err := s.ctx.EntClient.ProcessFlow.Get(ctx, flowId); err != nil {
|
||
return errors.New("工艺不存在")
|
||
}
|
||
// WMS 物料存在性校验(缺失拒绝;不可达降级放行)
|
||
codes := make([]string, 0, len(items))
|
||
seen := map[string]bool{}
|
||
for _, it := range items {
|
||
if it.MaterialCode == "" {
|
||
return errors.New("物料编码不能为空")
|
||
}
|
||
if seen[it.MaterialCode] {
|
||
return errors.New("物料 " + it.MaterialCode + " 重复")
|
||
}
|
||
seen[it.MaterialCode] = true
|
||
codes = append(codes, it.MaterialCode)
|
||
}
|
||
if len(codes) > 0 && s.ctx.Wms != nil {
|
||
if missing, err := s.ctx.Wms.MaterialExists(ctx, codes); err != nil {
|
||
s.ctx.EventLog.Write(ctx, "flow.material.wms_skip", "", operator, "process_flow", itoa(flowId),
|
||
"WMS 物料校验不可达,已降级放行", map[string]any{"error": err.Error()})
|
||
} else if len(missing) > 0 {
|
||
return errors.New("以下物料在 WMS 物料档案中不存在:" + strings.Join(missing, "、"))
|
||
}
|
||
}
|
||
tx, err := s.ctx.EntClient.Tx(ctx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
committed := false
|
||
defer func() {
|
||
if !committed {
|
||
_ = tx.Rollback()
|
||
}
|
||
}()
|
||
client := tx.Client()
|
||
if _, err := client.FlowMaterial.Delete().Where(flowmaterial.FlowId(flowId)).Exec(ctx); err != nil {
|
||
return err
|
||
}
|
||
for _, it := range items {
|
||
if err := client.FlowMaterial.Create().
|
||
SetFlowId(flowId).
|
||
SetMaterialCode(it.MaterialCode).SetMaterialName(it.MaterialName).
|
||
SetSpec(it.Spec).SetUnit(it.Unit).SetSnMode(it.SnMode).
|
||
SetUnitQty(it.UnitQty).SetLossRate(it.LossRate).
|
||
Exec(ctx); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
if err := tx.Commit(); err != nil {
|
||
return err
|
||
}
|
||
committed = true
|
||
s.ctx.EventLog.Write(ctx, "flow.material.save", "", operator, "process_flow", itoa(flowId),
|
||
"保存工艺物料清单(整表覆盖)", map[string]any{"flowId": flowId, "count": len(items)})
|
||
return nil
|
||
}
|