Files
bj_power/bj_power_mes/internal/logic/workpiece_bind.go
T
SunYF af554cea75 feat: 同步失败台账双向可重试 + 拧紧枪按工位配置 + 虚拟工位体系 + 去Redis与文档口径对齐
- 同步失败台账:MES/WMS 双端新增台账与页面,跨系统通知失败落台账、人工重试或标记已处理,不自动重传;重试前先判对端终态;叫料、配送、出库回写失败提示指向台账;补幂等建表脚本与菜单权限。
- 拧紧枪:新增按工位配置页,展示控制器地址与三把枪通道号(仅供查看,不参与采集校验);「允许手填」由全局开关改为每工位开关,关闭时校验该工位已配控制器;终端启动/登录上报配置并按本工位拉取,扭矩手填框按本工位置灰;补全局值迁移到各工位的脚本。
- 工位体系:终端未配置工位号时登录页可选(含虚拟工位),固定工位模式保留;虚拟/线下位不叫料、不退料、不作转产目标,未采集绑定放行并说明原因;叫料期望接驳台改为选填。
- AGV与出库:补「出库单已送达」回写;空车回充、接驳台传感器失联、配送状态更新失败均落预警或留痕并提示人工核对;人工出库不引入送达状态;出库单支持目标工位/接驳台并扩展导出列。
- 基础设施:看板缓存由Redis改为MES进程内实现,文档与启动脚本同步去Redis;扫码监听支持多地址、端口被占自动降级;PLC对账与工位报警在MES不可达时降级放行并留日志。
- 文档与帮助:案例与部署手册按实测订正(工位绑定、菜单名称、补料由班组长代提、菜单覆盖对照、虚拟工位);迁移脚本改为本地即时执行并登记7个已执行脚本;三端页面帮助改为「业务/操作/影响范围/后果」四要素。
- 测试:新增独立Go模块,按三个业务场景做真实HTTP与真实写库的流水测试,含运行报告。
2026-11-09 18:58:47 +08:00

547 lines
21 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"
"math"
"sort"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/dock"
"bj_power_mes/ent/flowmaterial"
"bj_power_mes/ent/workpiece"
"bj_power_mes/ent/workpiecebind"
"bj_power_mes/ent/workpieceprocess"
)
// RemoveBind 撤销一条绑定(仅允许未报工前的误扫纠正;报工后不可撤销)
func (s *Service) RemoveBind(ctx context.Context, sn string, flowId int, materialCode, bindValue, operator string) error {
if sn == "" || materialCode == "" || bindValue == "" {
return errors.New("sn/materialCode/bindValue 必填")
}
// 该工艺已报工(存在实绩)则不允许撤销
done, err := s.ctx.EntClient.WorkpieceProcess.Query().
Where(workpieceprocess.Sn(sn), workpieceprocess.FlowId(flowId)).Exist(ctx)
if err != nil {
return err
}
if done {
return errors.New("该工艺已报工,不能撤销装配绑定")
}
n, err := s.ctx.EntClient.WorkpieceBind.Delete().
Where(workpiecebind.Sn(sn), workpiecebind.FlowId(flowId),
workpiecebind.MaterialCode(materialCode), workpiecebind.BindValue(bindValue)).Exec(ctx)
if err != nil {
return err
}
if n == 0 {
return errors.New("未找到该绑定记录")
}
s.ctx.EventLog.Write(ctx, "workpiece.bind.remove", "", operator, "workpiece_bind", sn,
"撤销装配绑定", map[string]any{"flowId": flowId, "materialCode": materialCode, "bindValue": bindValue})
return nil
}
// BindWorkpiece 独立绑定接口:工人在工位扫一件绑一件(报工前的逐条扫码/防错),
// 与报工携带 binds 等价,落库后立即返回结果供前端即时反馈(SN 重复/料不匹配当场报错)。
func (s *Service) BindWorkpiece(ctx context.Context, sn, orderNo string, flowId int, stationNo string, operator string, items []BindItemReq) (map[string]any, error) {
bound, err := s.applyBinds(ctx, s.ctx.EntClient, sn, orderNo, flowId, stationNo, operator, items)
if err != nil {
return nil, err
}
if bound > 0 {
s.ctx.EventLog.Write(ctx, "workpiece.bind", orderNo, operator, "workpiece_bind", sn,
"装机绑定物料", map[string]any{"flowId": flowId, "count": bound})
s.notifyDashboard()
}
// 返回最新面板,前端据此刷新齐套状态
panel, err := s.StationBindPanelData(ctx, sn, flowId)
if err != nil {
return map[string]any{"bound": bound}, nil
}
return map[string]any{"bound": bound, "panel": panel}, nil
}
// ---------- 装机绑定(工位装配物料追溯 + 工艺物料清单强校验) ----------
// 业务口径(2026-11-06 拍板):物料本身不绑工单——物料/批次是工位共享的,装到 SN 工件上
// 才通过工件关联到工单;绑定记录一律挂 sn,不挂工位账。
// BindItemReq 单条装机绑定请求(报工时随 steps 一并提交)
type BindItemReq struct {
MaterialCode string `json:"materialCode"`
BindValue string `json:"bindValue"` // 序列号=否=批次号;序列号=是=SN
}
// bindTarget 某工艺要求装配的物料定义(源自工艺物料清单 flow_material)
type bindTarget struct {
MaterialCode string
MaterialName string
Spec string
Unit string
SnMode int // 是否逐件SN管理:1 序列号=是(录SN) / 2 序列号=否
UnitQty float64
}
// workpieceProduct 解析工件所属产品编码与工单(sn → workpiece → workOrder)
func (s *Service) workpieceProduct(ctx context.Context, client *ent.Client, sn string) (*ent.Workpiece, *ent.WorkOrder, error) {
wp, err := client.Workpiece.Query().Where(workpiece.Sn(sn)).First(ctx)
if err != nil {
return nil, nil, errors.New("工件未进线登记")
}
if wp.WorkOrderId <= 0 {
return wp, nil, errors.New("工件未关联工单")
}
wo, err := client.WorkOrder.Get(ctx, wp.WorkOrderId)
if err != nil || wo == nil {
return wp, nil, errors.New("工件所属工单不存在")
}
return wp, wo, nil
}
// stationBindTargets 取某工艺(flowId)要求装配的物料清单(工艺物料清单 flow_material)。
func (s *Service) stationBindTargets(ctx context.Context, client *ent.Client, flowId int) ([]bindTarget, error) {
items, err := client.FlowMaterial.Query().
Where(flowmaterial.FlowId(flowId)).All(ctx)
if err != nil {
return nil, err
}
out := make([]bindTarget, 0, len(items))
for _, it := range items {
out = append(out, bindTarget{
MaterialCode: it.MaterialCode, MaterialName: it.MaterialName, Spec: it.Spec,
Unit: it.Unit, SnMode: it.SnMode, UnitQty: it.UnitQty,
})
}
return out, nil
}
// applyBinds 报工时应用装机绑定(落库 + 防错校验):
// ① 料必须配置在该工位的工艺物料清单(flow_material)中;
// ② 电气件 SN 全局防重:已被其他工件绑定则拒绝(防错拿/防重复装机);
// ③ 同一工件同一料同一绑定值幂等(重复扫码不报错,静默去重)。
// 返回绑定成功条数。
func (s *Service) applyBinds(ctx context.Context, client *ent.Client, sn, orderNo string, flowId int, stationNo string, operator string, items []BindItemReq) (int, error) {
if len(items) == 0 {
return 0, nil
}
wp, _, err := s.workpieceProduct(ctx, client, sn)
if err != nil {
return 0, err
}
if wp.Status == "DONE" || wp.Status == "SCRAPPED" {
return 0, errors.New("已完工/报废工件不能再绑定物料")
}
// 本工艺物料清单全集:materialCode → 定义(校验料合法性 + 取物料快照)
fmMap := map[string]*ent.FlowMaterial{}
targets, err := s.stationBindTargets(ctx, client, flowId)
if err != nil {
return 0, err
}
for i := range targets {
fmMap[targets[i].MaterialCode] = &ent.FlowMaterial{
MaterialCode: targets[i].MaterialCode, MaterialName: targets[i].MaterialName,
Spec: targets[i].Spec, Unit: targets[i].Unit,
SnMode: targets[i].SnMode, UnitQty: targets[i].UnitQty,
}
}
bound := 0
for _, it := range items {
mc := strings.TrimSpace(it.MaterialCode)
bv := strings.TrimSpace(it.BindValue)
if mc == "" || bv == "" {
return bound, errors.New("物料编码与绑定值不能为空")
}
fm, ok := fmMap[mc]
if !ok {
return bound, fmt.Errorf("物料 %s 未配置在工艺「%s」的物料清单,不能绑定", mc, s.flowNameById(ctx, flowId))
}
snMode := fm.SnMode
if snMode != 1 {
snMode = 2
}
// 同工件同料同值幂等
exists, _ := client.WorkpieceBind.Query().
Where(workpiecebind.Sn(sn), workpiecebind.MaterialCode(mc), workpiecebind.BindValue(bv)).Exist(ctx)
if exists {
continue
}
// 序列号=是 SN 全局防重
if snMode == 1 {
other, _ := client.WorkpieceBind.Query().
Where(workpiecebind.BindValue(bv), workpiecebind.BindType("SN"), workpiecebind.SnNEQ(sn)).First(ctx)
if other != nil {
return bound, fmt.Errorf("序列号=是SN %s 已绑定到工件 %s(工艺「%s」),不能重复装机",
bv, other.Sn, s.flowNameById(ctx, other.FlowId))
}
}
bindType := "BATCH"
if snMode == 1 {
bindType = "SN"
}
if err := client.WorkpieceBind.Create().
SetSn(sn).SetOrderNo(orderNo).SetFlowId(flowId).
SetStationNo(stationNo).SetMaterialCode(mc).SetMaterialName(fm.MaterialName).
SetSpec(fm.Spec).SetUnit(fm.Unit).SetSnMode(snMode).
SetBindValue(bv).SetBindType(bindType).SetOperator(operator).
Exec(ctx); err != nil {
return bound, err
}
bound++
}
return bound, nil
}
// stationHasEnabledLineDock 判断工位是否为「实体工位」:存在启用的 line 类型接驳台。
// 虚拟/线下位(如末端下料检测位 11/12)无接驳台、不承载 AGV 物料物流,
// 因此不采集装配物料绑定,报工/完工/追溯/终端面板一律放行(2026-11-08 B2 拍板)。
func (s *Service) stationHasEnabledLineDock(ctx context.Context, client *ent.Client, stationNo int) bool {
if stationNo <= 0 {
return false
}
n, err := client.Dock.Query().Where(
dock.StationNo(stationNo), dock.DockTypeEQ("line"), dock.StatusEQ("ENABLED")).Count(ctx)
return err == nil && n > 0
}
const bindSkipReason = "该工序未采集绑定(工位无接驳台)"
// BindNotCollected 追溯页:因候选工位无接驳台而未采集装配绑定的工序。
type BindNotCollected struct {
FlowId int `json:"flowId"`
FlowName string `json:"flowName"`
StationNo int `json:"stationNo"`
Reason string `json:"reason"`
}
// flowBindGate 按工单工艺组合判定每道工序是否需采集装配绑定:
// 多工位同工艺=并行候选工位,任一候选工位有启用 line 接驳台即需采集;
// 该工序全部候选均无接驳台(虚拟/线下位)时不采集,并返回追溯用未采集清单。
func (s *Service) flowBindGate(ctx context.Context, client *ent.Client, wo *ent.WorkOrder) (map[int]bool, []BindNotCollected) {
items, _ := RouteStationsFromWO(ctx, client, wo)
required := map[int]bool{}
seen := map[int]bool{}
skipped := []BindNotCollected{}
for _, it := range items {
if s.stationHasEnabledLineDock(ctx, client, it.StationNo) {
required[it.FlowId] = true
}
}
for _, it := range items {
if seen[it.FlowId] || required[it.FlowId] {
continue
}
seen[it.FlowId] = true
skipped = append(skipped, BindNotCollected{
FlowId: it.FlowId, FlowName: s.flowNameById(ctx, it.FlowId),
StationNo: it.StationNo, Reason: bindSkipReason,
})
}
return required, skipped
}
// validateStationBinds 校验某工件在某工艺的装配物料是否绑齐(齐套强校验核心):
// 返回缺料明细(空串=齐套)。判定:电气件(SN) 绑定的不同SN数 ≥ 单台用量;结构件(批次) 至少绑定1个批次号。
// 该工艺未配置物料清单,或报工工位无启用产线接驳台(不采集绑定)时放行。
func (s *Service) validateStationBinds(ctx context.Context, client *ent.Client, sn string, flowId int, requireBinds bool) (string, error) {
if _, _, err := s.workpieceProduct(ctx, client, sn); err != nil {
return "", err
}
if !requireBinds {
return "", nil // 工位无启用产线接驳台(虚拟/线下位)→ 不采集绑定,放行
}
targets, err := s.stationBindTargets(ctx, client, flowId)
if err != nil {
return "", err
}
if len(targets) == 0 {
return "", nil // 该工艺未配置装配物料 → 不校验
}
// 已绑定明细:按 物料编码 → 绑定值集合
binds, _ := client.WorkpieceBind.Query().
Where(workpiecebind.Sn(sn), workpiecebind.FlowId(flowId)).All(ctx)
boundMap := map[string]map[string]bool{}
for _, b := range binds {
if boundMap[b.MaterialCode] == nil {
boundMap[b.MaterialCode] = map[string]bool{}
}
boundMap[b.MaterialCode][b.BindValue] = true
}
missing := []string{}
for _, t := range targets {
set := boundMap[t.MaterialCode]
boundCount := len(set)
need := int(math.Ceil(t.UnitQty))
if need < 1 {
need = 1
}
if t.SnMode == 1 { // 序列号=是 SN:需绑满单台用量
if boundCount < need {
missing = append(missing, fmt.Sprintf("%s(%s):需绑定%d颗SN,已绑%d颗", t.MaterialCode, t.MaterialName, need, boundCount))
}
} else { // 序列号=否:至少绑定1个批次号
if boundCount < 1 {
missing = append(missing, fmt.Sprintf("%s(%s):未绑定批次号", t.MaterialCode, t.MaterialName))
}
}
}
if len(missing) == 0 {
return "", nil
}
return "装配物料未绑齐:" + strings.Join(missing, ";"), nil
}
// validateAllFlows 完工兜底:按工单工艺组合(唯一路线源头)逐工艺校验装配物料齐套。
// 同一工艺绑多工位时只校验一次(按 FlowId 去重);该工序候选工位全无启用 line 接驳台
// (虚拟/线下位,未采集绑定)时跳过,不再把「没绑」误判成缺料。
func (s *Service) validateAllFlows(ctx context.Context, client *ent.Client, sn string, wo *ent.WorkOrder) (string, error) {
if _, _, err := s.workpieceProduct(ctx, client, sn); err != nil {
return "", err
}
items, _ := RouteStationsFromWO(ctx, client, wo)
required, _ := s.flowBindGate(ctx, client, wo)
missing := []string{}
seen := map[int]bool{}
for _, it := range items {
if seen[it.FlowId] {
continue
}
seen[it.FlowId] = true
if !required[it.FlowId] {
continue // 该工序全部候选工位无接驳台 → 未采集绑定,不参与齐套
}
msg, err := s.validateStationBinds(ctx, client, sn, it.FlowId, true)
if err != nil {
return "", err
}
if msg != "" {
missing = append(missing, fmt.Sprintf("工艺「%s」:%s", s.flowNameById(ctx, it.FlowId), msg))
}
}
if len(missing) == 0 {
return "", nil
}
return strings.Join(missing, ";"), nil
}
// InspectionBindItem 检验记录/检验单附带的装配物料绑定明细条目
// (客户需求:每个工位对精密器件扫码录入,记录在检验单上)
type InspectionBindItem struct {
Sn string `json:"sn"`
FlowName string `json:"flowName"` // 装配工艺名
StationNo string `json:"stationNo"` // 绑定工位
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
BindValue string `json:"bindValue"` // 序列号=是=SN / 序列号=否=批次号
BindMode string `json:"bindMode"` // 序列号=是 / 序列号=否
Operator string `json:"operator"`
CreatedAt time.Time `json:"createdAt"`
}
// inspectionBindItems 按 SN 查跨工艺全部装配绑定明细(供检验记录详情/检验单附明细区;无绑定返回空不报错)
func (s *Service) inspectionBindItems(ctx context.Context, sn string) []InspectionBindItem {
if sn == "" {
return nil
}
binds, err := s.ctx.EntClient.WorkpieceBind.Query().
Where(workpiecebind.Sn(sn)).
Order(ent.Asc(workpiecebind.FieldFlowId), ent.Asc(workpiecebind.FieldID)).
All(ctx)
if err != nil || len(binds) == 0 {
return nil
}
out := make([]InspectionBindItem, 0, len(binds))
for _, b := range binds {
mode := "序列号=否"
if b.SnMode == 1 {
mode = "序列号=是"
}
out = append(out, InspectionBindItem{
Sn: b.Sn, FlowName: s.flowNameById(ctx, b.FlowId), StationNo: b.StationNo,
MaterialCode: b.MaterialCode, MaterialName: b.MaterialName, Spec: b.Spec,
BindValue: b.BindValue, BindMode: mode, Operator: b.Operator, CreatedAt: b.CreatedAt,
})
}
return out
}
// InspectionBinds 检验记录详情:按 SN 返回装配物料绑定明细(跨工艺,标注工艺/工位)
func (s *Service) InspectionBinds(ctx context.Context, sn string) []InspectionBindItem {
return s.inspectionBindItems(ctx, sn)
}
// ListWorkpieceBinds 查询工件的装机绑定明细
func (s *Service) ListWorkpieceBinds(ctx context.Context, sn string) ([]*ent.WorkpieceBind, error) {
q := s.ctx.EntClient.WorkpieceBind.Query()
if sn != "" {
q = q.Where(workpiecebind.Sn(sn))
}
return q.Order(ent.Asc(workpiecebind.FieldFlowId), ent.Asc(workpiecebind.FieldID)).Limit(2000).All(ctx)
}
// BindTraceVO 追溯页:装机绑定明细 + 每工艺齐套状态 + 装机物料明细
type BindTraceVO struct {
Binds []*ent.WorkpieceBind `json:"binds"`
Complete bool `json:"complete"`
Missing string `json:"missing"`
BomTree []BindNode `json:"bomTree"` // 装机物料明细(按工单工艺组合×工艺物料清单平铺一层,无多级树)
NotCollected []BindNotCollected `json:"notCollected"` // 无接驳台工序:未采集绑定原因
}
// BindNode 追溯用的装机物料明细节点(平铺一层;多级 BOM 已于 2026-09-23 退役,无下级展开)
type BindNode struct {
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Unit string `json:"unit"`
SnMode int `json:"snMode"` // 1 序列号=是 / 2 序列号=否
Qty float64 `json:"qty"` // 折算到单台成品的用量
}
// BuildBindTrace 组装某工件装机绑定追溯(含全工艺齐套状态 + 物料组成树,供成品档案/追溯页展示)
func (s *Service) BuildBindTrace(ctx context.Context, sn string) (*BindTraceVO, error) {
binds, err := s.ListWorkpieceBinds(ctx, sn)
if err != nil {
return nil, err
}
_, wo, err := s.workpieceProduct(ctx, s.ctx.EntClient, sn)
if err != nil {
return nil, err
}
missing, err := s.validateAllFlows(ctx, s.ctx.EntClient, sn, wo)
if err != nil {
return nil, err
}
// 无接驳台工序未采集绑定:追溯页显式给出原因,避免与「已绑齐」的空列表混淆
_, skipped := s.flowBindGate(ctx, s.ctx.EntClient, wo)
// 物料组成:按工单工艺组合×工艺物料清单平铺一层(物料清单已删除,无多级树)
var tree []BindNode
for _, it := range s.WorkOrderUnitUsage(ctx, wo) {
tree = append(tree, BindNode{
MaterialCode: it.MaterialCode, MaterialName: it.MaterialName,
Spec: it.Spec, Unit: it.Unit, SnMode: it.SnMode,
Qty: it.UnitQty,
})
}
return &BindTraceVO{Binds: binds, Complete: missing == "", Missing: missing,
BomTree: tree, NotCollected: skipped}, nil
}
// BindRequiredItem 应绑清单条目(工位终端展示引导 + 前端齐套计算)
type BindRequiredItem struct {
MaterialCode string `json:"materialCode"`
MaterialName string `json:"materialName"`
Spec string `json:"spec"`
Unit string `json:"unit"`
SnMode int `json:"snMode"` // 1 序列号=是(录SN) / 2 序列号=否
UnitQty float64 `json:"unitQty"`
Need int `json:"need"` // 需绑数量
Bound []string `json:"bound"` // 已绑定的批次号/SN 列表
BoundCount int `json:"boundCount"`
Complete bool `json:"complete"`
}
// StationBindPanel 某工件在某工艺的装配绑定面板数据(应绑清单 + 已绑情况)
type StationBindPanel struct {
Enabled bool `json:"enabled"` // 本工艺是否启用装配物料绑定
Required []BindRequiredItem `json:"required"`
Complete bool `json:"complete"`
Missing string `json:"missing"`
StationNo int `json:"stationNo"` // 工位号(从工单工艺组合该 flow 条目派生)
FlowId int `json:"flowId"`
LastBinds []*ent.WorkpieceBind `json:"lastBinds"` // 最近10条绑定记录
StationNames map[int]string `json:"-"`
HasLineDock bool `json:"hasLineDock"` // 候选工位是否有启用 line 接驳台
SkipReason string `json:"skipReason"` // 无需采集绑定的原因
}
// StationBindPanelData 供工位终端在报工前拉取:本工件本工艺该装什么、已装什么
// 业务口径(2026-11-06 拍板):装配物料绑定是「当前工件齐套视图」,不是工位账——
// 与工位账(叫料池四数/物料明细)并存、互不替代;齐套看的是这一台 SN 绑没绑齐。
func (s *Service) StationBindPanelData(ctx context.Context, sn string, flowId int) (*StationBindPanel, error) {
_, wo, err := s.workpieceProduct(ctx, s.ctx.EntClient, sn)
if err != nil {
return nil, err
}
targets, err := s.stationBindTargets(ctx, s.ctx.EntClient, flowId)
if err != nil {
return nil, err
}
// 工位号从工单工艺组合该 flow 的条目派生(组合是唯一路线源头)
stationNo := 0
if items, _ := RouteStationsFromWO(ctx, s.ctx.EntClient, wo); len(items) > 0 {
for _, it := range items {
if it.FlowId == flowId {
stationNo = it.StationNo
break
}
}
}
// B2(2026-11-08):候选工位无启用 line 接驳台 → 该工序不采集装配绑定,
// 面板不展示「需绑批次/需绑SN」,齐套恒为 true,前端不会拦截报工。
hasDock := s.stationHasEnabledLineDock(ctx, s.ctx.EntClient, stationNo)
panel := &StationBindPanel{
Enabled: len(targets) > 0 && hasDock, FlowId: flowId, StationNo: stationNo,
HasLineDock: hasDock, Required: []BindRequiredItem{},
}
if !hasDock {
panel.SkipReason = bindSkipReason
}
// 全量绑定(齐套判定必须按全量统计,不能用 limit 截断,否则多料/多SN会误判缺料)
allBinds, _ := s.ctx.EntClient.WorkpieceBind.Query().
Where(workpiecebind.Sn(sn), workpiecebind.FlowId(flowId)).All(ctx)
boundMap := map[string]map[string]bool{}
for _, b := range allBinds {
if boundMap[b.MaterialCode] == nil {
boundMap[b.MaterialCode] = map[string]bool{}
}
boundMap[b.MaterialCode][b.BindValue] = true
}
for _, t := range targets {
if !hasDock {
break // 无接驳台工位不展示「需绑批次 / 需绑SN」应绑清单
}
need := int(math.Ceil(t.UnitQty))
if need < 1 {
need = 1
}
bound := make([]string, 0, len(boundMap[t.MaterialCode]))
for v := range boundMap[t.MaterialCode] {
bound = append(bound, v)
}
sort.Strings(bound)
item := BindRequiredItem{
MaterialCode: t.MaterialCode, MaterialName: t.MaterialName, Spec: t.Spec, Unit: t.Unit,
SnMode: t.SnMode, UnitQty: t.UnitQty, Need: need, Bound: bound,
BoundCount: len(bound),
}
if t.SnMode == 1 {
item.Complete = len(bound) >= need
} else {
item.Complete = len(bound) >= 1
}
panel.Required = append(panel.Required, item)
}
allComplete := true
for _, r := range panel.Required {
if !r.Complete {
allComplete = false
break
}
}
panel.Complete = allComplete
if !allComplete && hasDock {
panel.Missing, _ = s.validateStationBinds(ctx, s.ctx.EntClient, sn, flowId, true)
}
// 最近绑定(仅展示用)
sort.Slice(allBinds, func(i, j int) bool { return allBinds[i].ID > allBinds[j].ID })
if len(allBinds) > 10 {
allBinds = allBinds[:10]
}
panel.LastBinds = allBinds
return panel, nil
}