Files
bj_power/bj_power_mes/internal/logic/dashboard_manage.go
T
SunYF 4c4cda1d41 feat: 移除工艺物料与混产模板实体、新增产线清线与 PLC 监控实时推送、看板双屏增强
- 移除实体:MES 删除 FlowMaterial(工艺物料)与 MixProductionTemplate(混产模板)全套(schema/ent 生成码/handler/logic),清理关联路由与种子
- 新增功能:产线清线(line_clearance handler + logic)、PLC 监控 WebSocket 实时推送(ws/plc_monitor_hub + handler)
- 看板增强:新增管理屏与 KPI 组件(BoardManage/BoardKpi),调整演示屏 Mock 与各看板面板
- MES 完善:PLC 匹配/扭矩扫描/签收、工艺卡 PDF 与工单、AGV 链路、叫料/备料/在制品/短料预测等逻辑与前端调整
- 工位终端:删除离线面板 OfflinePanel,调整主界面/物料面板与 api/store/handler/路由
- WMS:AGV 托盘、物料与 MES 客户端调整及前端帮助/基础数据/叫料/托盘页
- 文档:更新产线API/客户问题/案例/部署手册/问题记录
2026-11-19 08:31:05 +08:00

364 lines
12 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
// 管理屏聚合(2026-11-16 客户 22 条诉求)。
// 双屏机制:演示屏(未登录/参观指导)报喜不报忧;管理屏(其他登录账号)渲染本文件聚合的负面/管理数据。
// 全部复用现有底座,不新建数据表、不重复造轮子:
// - 停机原因:reasonDict + station_state.reason(现成字典与写入点)
// - 不良:torque_record.NG + workpiece_process.NG(现成 NG 数据)
// - 返修报废:trial_record(成品试验区,已建表)
// - 节拍:workpiece_process.duration_sec(与 processflow.WorkloadRow 同源口径)
// - 缺料:shortage_request + 现成支撑台数推算口径
// - 告警:alert 表现成未处置项
import (
"context"
"sort"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/alert"
"bj_power_mes/ent/dailyplan"
"bj_power_mes/ent/shortagerequest"
"bj_power_mes/ent/stationstate"
"bj_power_mes/ent/torquerecord"
"bj_power_mes/ent/workpiece"
"bj_power_mes/ent/workpieceprocess"
)
// buildManage 管理屏聚合总入口。每块单独容错,某块失败只降级该块,不影响整屏。
func (s *Service) buildManage(ctx context.Context, today time.Time) ManageStats {
m := ManageStats{
DownstopTop: []RankItem{},
DefectTop: []RankItem{},
Tempo: TempoStats{ByOperator: []TempoRow{}, ByProcess: []TempoRow{}, ByStation: []TempoRow{}, Days: 1},
Shortages: []ShortageRow{},
LowStockAlerts: []StockAlert{},
}
m.DownstopTop = s.buildDownstopTop(ctx, today)
m.DefectTop, m.NgRate, m.NgTotal = s.buildDefectTop(ctx, today)
m.Trials = s.buildTrialSummary(ctx)
m.Tempo = s.buildTempo(ctx, today)
m.Shortages = s.buildShortages(ctx)
return m
}
// buildDownstopTop 停机 TOP:按当天 station_state.reason(停机原因字典)聚合,附工位号。
// 客户诉求 5:停机 TOP 排行(缺料/工具故障/其他设备),原因字典已就绪(reasonDict["stop"])。
func (s *Service) buildDownstopTop(ctx context.Context, today time.Time) []RankItem {
reasonCnt := map[string]int{}
reasonStations := map[string][]int{}
if pauses, err := s.ctx.EntClient.StationState.Query().
Where(stationstate.Date(today.Format("2006-01-02")), stationstate.Paused(true)).All(ctx); err == nil {
for _, p := range pauses {
reason := strings.TrimSpace(p.Reason)
if reason == "" {
reason = "未填写原因"
}
reasonCnt[reason]++
reasonStations[reason] = append(reasonStations[reason], p.StationNo)
}
}
return rankFromReasonMap(reasonCnt, reasonStations, "停机")
}
// buildDefectTop 不良率/不良总数/不良分类 TOP(客户诉求 6,生产中)。
// 数据源:当天拧紧 NG(torque_record)+ 工艺 NG(workpiece_process)。
// 不良原因字典(reasonDict["defect"])在终端已按类选择,但 NG 明细未逐条存原因字段(当前底座),
// 故分类 TOP 用「按工位 / 按人」两个维度呈现,与 NgByStation/NgByOperator 契约一致。
func (s *Service) buildDefectTop(ctx context.Context, today time.Time) ([]RankItem, float64, int) {
tomorrow := today.Add(24 * time.Hour)
byStation := map[string]int{}
byOperator := map[string]int{}
total, ng := 0, 0
if recs, err := s.ctx.EntClient.TorqueRecord.Query().
Where(torquerecord.TimeGTE(today), torquerecord.TimeLT(tomorrow)).All(ctx); err == nil {
for _, r := range recs {
total++
if strings.EqualFold(r.Result, "NG") {
ng++
byStation[r.StationNo]++
byOperator[r.Operator]++
}
}
}
ngRate := safeRate(float64(ng), float64(total))
// 合并工位与人员两个维度到同一 TOP(工位前缀区分,key 唯一)
merged := map[string]int{}
for k, v := range byStation {
merged["工位·"+k] += v
}
for k, v := range byOperator {
if k == "" {
k = "未记录"
}
merged["人员·"+k] += v
}
top := rankFromReasonMap(merged, map[string][]int{}, "不良")
return top, ngRate, ng
}
// buildTrialSummary 返修/报废原因(客户诉求 7,生产后试验区):直接读 trial_record 表。
func (s *Service) buildTrialSummary(ctx context.Context) TrialSummary {
out := TrialSummary{Reasons: []RankItem{}}
reasonCnt := map[string]int{}
if rows, err := s.ctx.EntClient.TrialRecord.Query().All(ctx); err == nil {
for _, r := range rows {
switch r.Result {
case TrialResultOK:
out.OK++
case TrialResultRepair:
out.Repair++
case TrialResultScrap:
out.Scrap++
}
if r.Result == TrialResultRepair || r.Result == TrialResultScrap {
reason := strings.TrimSpace(r.Reason)
if reason == "" {
reason = "未填写原因"
}
reasonCnt[reason]++
}
}
}
out.Reasons = rankFromReasonMap(reasonCnt, map[string][]int{}, "原因")
return out
}
// buildTempo 节拍对比/瓶颈识别(客户诉求 9,禁止降级)。
// 复用 processflow.WorkloadRow 同源口径:时长取 workpiece_process.duration_sec。
// 默认统计当天(Days=1);前端选 1/3/5 天跨度时通过独立查询接口获取(见 DashboardTempo)。
func (s *Service) buildTempo(ctx context.Context, today time.Time) TempoStats {
return s.buildTempoSince(ctx, today, 1)
}
// buildTempoSince 按跨度(天)聚合节拍。给富快照用 days=1,给独立查询接口用 days=1/3/5。
func (s *Service) buildTempoSince(ctx context.Context, from time.Time, days int) TempoStats {
out := TempoStats{
ByOperator: []TempoRow{}, ByProcess: []TempoRow{}, ByStation: []TempoRow{}, Days: days,
}
since := from.AddDate(0, 0, -(days - 1))
type agg struct {
count int
sumSec int
}
byOp := map[string]*agg{}
byProc := map[string]*agg{}
bySt := map[string]*agg{}
if rows, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.EndedAtGTE(since)).All(ctx); err == nil {
for _, r := range rows {
dur := r.DurationSec
if dur <= 0 {
continue
}
op := strings.TrimSpace(r.Operator)
if op == "" {
op = "未记录"
}
proc := strings.TrimSpace(r.ProcessName)
if proc == "" {
proc = "未命名工艺"
}
st := strings.TrimSpace(r.StationNo)
if st == "" {
st = "0"
}
add := func(m map[string]*agg, k string) {
a := m[k]
if a == nil {
a = &agg{}
m[k] = a
}
a.count++
a.sumSec += dur
}
add(byOp, op)
add(byProc, proc)
add(bySt, "工位"+st)
}
}
toRows := func(m map[string]*agg) []TempoRow {
rows := make([]TempoRow, 0, len(m))
minAvg := 0
for k, a := range m {
avg := 0
if a.count > 0 {
avg = a.sumSec / a.count
}
rows = append(rows, TempoRow{Key: k, Label: k, Count: a.count, AvgSec: avg})
if avg > 0 && (minAvg == 0 || avg < minAvg) {
minAvg = avg
}
}
for i := range rows {
// 相对效率 = 最快平均耗时 / 本行平均耗时 × 100(越快越接近 100)
if rows[i].AvgSec > 0 && minAvg > 0 {
rows[i].EffRate = float64(minAvg) / float64(rows[i].AvgSec) * 100
}
}
sort.Slice(rows, func(i, j int) bool { return rows[i].AvgSec > rows[j].AvgSec }) // 耗时最长(瓶颈)排前
return rows
}
out.ByOperator = toRows(byOp)
out.ByProcess = toRows(byProc)
out.ByStation = toRows(bySt)
return out
}
// buildShortages 即将缺料(客户诉求 10):读 shortage_request 当前 PENDING 单,按工位聚合。
// 现有 shortage_predict(evaluateShortageAfterReport)推的是支撑台数,本处把待审批补料单按工位列出;
// etaMinutes=-1 表示无节拍数据无法估算,前端显示「—」。
func (s *Service) buildShortages(ctx context.Context) []ShortageRow {
out := []ShortageRow{}
reqs, err := s.ctx.EntClient.ShortageRequest.Query().
Where(shortagerequest.Status("PENDING")).
Order(ent.Desc(shortagerequest.FieldCreatedAt)).Limit(30).All(ctx)
if err != nil || len(reqs) == 0 {
return out
}
seen := map[int]bool{}
for _, r := range reqs {
if seen[r.StationNo] {
continue
}
seen[r.StationNo] = true
out = append(out, ShortageRow{
StationNo: r.StationNo,
Material: r.MaterialName,
SupportQty: 0,
Critical: true,
EtaMinutes: -1,
})
}
return out
}
// DashboardTempo 独立节拍查询接口(客户诉求 9:按天/3天/5天跨度汇总)。
// 由前端选择跨度时调用,不进 60s 快照缓存。
func (s *Service) DashboardTempo(ctx context.Context, days int) TempoStats {
if days < 1 {
days = 1
}
if days > 5 {
days = 5
}
return s.buildTempoSince(ctx, dayStart(time.Now()), days)
}
// DashboardContractQuery 合同号反查(客户诉求 1/8):按合同号反查关联工单及成品 SN。
// 复用 workorder.ContractNo 过滤(ListWorkOrders 同源口径)+ workpiece 按工单反查 SN。
func (s *Service) DashboardContractQuery(ctx context.Context, contractNo string) (*ContractFlow, error) {
out := &ContractFlow{ContractNo: contractNo, Orders: []ContractOrder{}, Found: false}
contractNo = strings.TrimSpace(contractNo)
if contractNo == "" {
return out, nil
}
wos, err := s.ListWorkOrders(ctx, "", "", "", "", contractNo, "", "", 50, 0, 0)
if err != nil {
return out, err
}
for _, wo := range wos {
co := ContractOrder{
OrderNo: wo.WorkOrderNo, ProductName: wo.ProductName,
TotalQty: wo.Quantity, DoneQty: wo.FinishedNum, Status: wo.Status,
FinishedSNs: []string{}, MaterialLots: []string{},
}
// 成品 SN:workpiece 按工单反查(SN 是成品唯一标识)
if wps, e := s.ctx.EntClient.Workpiece.Query().Where(workpiece.OrderNoEQ(wo.WorkOrderNo)).All(ctx); e == nil {
for _, wp := range wps {
if sn := strings.TrimSpace(wp.Sn); sn != "" {
co.FinishedSNs = append(co.FinishedSNs, sn)
}
}
}
if len(co.FinishedSNs) > 0 || co.DoneQty > 0 {
out.Found = true
}
out.Orders = append(out.Orders, co)
}
if len(out.Orders) > 0 {
out.Found = true
}
return out, nil
}
// DashboardBatchTrace 来料批次反查成品(客户诉求 8):按批次号反查用到该批次的成品 SN 列表。
// 复用 association_trace(工件-物料关联)现成表;无关联数据时返回 found=false。
func (s *Service) DashboardBatchTrace(ctx context.Context, batch string) (*BatchTrace, error) {
out := &BatchTrace{Batch: batch, SNs: []string{}, Found: false}
batch = strings.TrimSpace(batch)
if batch == "" {
return out, nil
}
// association_trace.batch_items 是 JSON 数组,无法 SQL 过滤,拉全部在内存里比对批次(现场关联量可控)
seen := map[string]bool{}
if rows, err := s.ctx.EntClient.AssociationTrace.Query().All(ctx); err == nil {
for _, r := range rows {
hit := false
for _, b := range r.BatchItems {
if strings.TrimSpace(b) == batch {
hit = true
break
}
}
if hit && r.FinishedSn != "" && !seen[r.FinishedSn] {
seen[r.FinishedSn] = true
out.SNs = append(out.SNs, r.FinishedSn)
}
}
}
out.Found = len(out.SNs) > 0
return out, nil
}
// rankFromReasonMap 通用原因聚合 → RankItem 列表(按 count 降序,带工位号),供停机/不良/返修原因共用。
func rankFromReasonMap(cnt map[string]int, stations map[string][]int, prefix string) []RankItem {
out := make([]RankItem, 0, len(cnt))
for k, v := range cnt {
out = append(out, RankItem{Key: k, Label: prefix + "·" + k, Count: v, StationNos: stations[k]})
}
sort.Slice(out, func(i, j int) bool { return out[i].Count > out[j].Count })
return out
}
// buildManageAlarms 告警中心未处置项接入管理屏告警条(客户诉求 2)。
// 现两条告警源(拧紧NG/PLC在途)保留,追加 alert 表 UNREAD 项。
func (s *Service) buildManageAlarms(ctx context.Context, today time.Time, base []AlarmItem) []AlarmItem {
items := append([]AlarmItem{}, base...)
if unread, err := s.ctx.EntClient.Alert.Query().
Where(alert.Status("UNREAD")).
Order(ent.Desc(alert.FieldCreatedAt)).Limit(10).All(ctx); err == nil {
for _, a := range unread {
msg := strings.TrimSpace(a.Content)
if msg == "" {
msg = a.Title
}
level := strings.ToLower(a.Level)
if level != "critical" && level != "warning" {
level = "warning"
}
items = append(items, AlarmItem{
ID: "alert-" + itoa(a.ID), Level: level, Type: a.Type,
Target: a.Target, Message: msg,
Time: fmtDashboardTime(a.CreatedAt), Status: a.Status,
})
}
}
return items
}
// 工位计划数(客户诉求 4):读当天 daily_plan.stationPlanQty(map[string]int),按工位号映射。
func (s *Service) stationPlanQtyMap(ctx context.Context, today time.Time) map[string]int {
out := map[string]int{}
if plans, err := s.ctx.EntClient.DailyPlan.Query().
Where(dailyplan.PlanDate(today.Format("2006-01-02"))).All(ctx); err == nil {
for _, p := range plans {
for k, v := range p.StationPlanQty {
out[k] += v
}
}
}
return out
}