Files
bj_power/bj_power_mes/internal/logic/torque.go
T
SunYF 8be6e03a15 docs: 统一修正全项目“SN管理”相关术语为“序列号”
本次 commit 统一修正了全项目范围内关于 SN 管理的术语表述,将原“SN管理”、“序列号件”、“批次件”等表述调整为“序列号”、“序列号=是”、“序列号=否”,同时同步更新了相关文档、代码注释、前端提示文本、数据库 schema 注释、API 文档等,确保全链路术语统一,消除理解歧义。
2026-10-10 15:58:59 +08:00

219 lines
8.4 KiB
Go

package logic
import (
"context"
"errors"
"strconv"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/processstep"
"bj_power_mes/ent/station"
"bj_power_mes/ent/stepcriterion"
"bj_power_mes/ent/torquerecord"
"bj_power_mes/ent/workpiece"
)
type TorqueReq struct {
Sn string `json:"sn"`
WorkOrder string `json:"workOrder"`
WorkOrderNo string `json:"workOrderNo"`
StationNo string `json:"stationNo"`
ScrewNo string `json:"screwNo"`
Strain float64 `json:"strain"` // 扭矩
Torque float64 `json:"torque"`
Angle float64 `json:"angle"`
Result string `json:"result"`
Operator string `json:"operator"`
Time time.Time `json:"time"`
}
// ReportTorque 接收拧紧数据(工位终端/内部接口上报),入库并做扭矩 RANGE 判定写 step_data。
// operatorId:落库操作人用户ID,由 MES 从当前登录态 JWT 解析,即「本次发送所用的登录人」。
func (s *Service) ReportTorque(ctx context.Context, req TorqueReq, operator string, operatorId int) error {
if req.Sn == "" {
return errors.New("sn 不能为空")
}
if req.Strain == 0 {
req.Strain = req.Torque
}
result := req.Result
if result == "" {
result = "OK"
}
workOrderNo := req.WorkOrder
if workOrderNo == "" {
workOrderNo = req.WorkOrderNo
}
if req.Time.IsZero() {
req.Time = time.Now()
}
_, err := s.ctx.EntClient.TorqueRecord.Create().
SetWorkOrderNo(workOrderNo).SetSn(req.Sn).SetScrewNo(req.ScrewNo).
SetStrain(req.Strain).SetTorque(req.Strain).SetAngle(req.Angle).
SetResult(result).SetOperator(operator).SetOperatorId(operatorId).SetStationNo(req.StationNo).
SetTime(req.Time).Save(ctx)
if err != nil {
return err
}
s.ctx.EventLog.Write(ctx, "torque.report", workOrderNo, operator, "torque_record", req.Sn, "接收拧紧数据上报", map[string]any{"strain": req.Strain, "angle": req.Angle, "result": result})
s.evaluateTorqueCriterion(ctx, req.Sn, req.StationNo, req.Strain, req.Angle, operator)
s.notifyDashboard()
return nil
}
// evaluateTorqueCriterion 依据「isTorque 步骤 + RANGE 考核标准」自动判定 OK/NG 写入 step_data。
// 判定完全依据步骤 isTorque 标记与区间逻辑,不再依赖指标名(如「扭矩」),
// 避免误命名(如「时间」)导致整段判定静默失效;与 dashboard.loadTorqueCriterion 共用
// torqueRangeCriteria,口径统一。仅取上报工位所绑定工艺流程内的扭矩标准,跨流程/无关步骤不会误判。
func (s *Service) evaluateTorqueCriterion(ctx context.Context, sn, stationNo string, strain, angle float64, operator string) {
crits, _ := s.torqueRangeCriteria(ctx, s.stationFlowId(ctx, stationNo))
ng := false
for _, c := range crits {
ok := true
if c.Min != nil && strain < *c.Min {
ok = false
}
if c.Max != nil && strain > *c.Max {
ok = false
}
_, _ = s.ctx.EntClient.StepData.Create().
SetSn(sn).SetStepId(c.StepId).SetCriterionId(c.ID).
SetCriterionName(c.Name).SetCriterionLogic(c.Logic).
SetValue(strain).SetIsOK(ok).SetOperator(operator).Save(ctx)
if !ok {
ng = true
}
}
if ng {
// 反查该 SN 所属工单号一并写入预警,供预警中心按工单号检索(客户第12条)
orderNo := ""
if wp, e := s.ctx.EntClient.Workpiece.Query().Where(workpiece.Sn(sn)).First(ctx); e == nil {
orderNo = wp.OrderNo
}
s.Evaluate(ctx, "torque_ng", 1, "拧紧扭矩不合格", "SN="+sn+" 工位"+stationNo, "torque_record", sn, orderNo)
}
}
// stationFlowId 由工位号取绑定工艺流程 ID;未绑定/非法工位返回 0。
func (s *Service) stationFlowId(ctx context.Context, stationNo string) int {
no, err := strconv.Atoi(strings.TrimSpace(stationNo))
if err != nil || no <= 0 {
return 0
}
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(no)).First(ctx)
if err != nil || st.FlowId <= 0 {
return 0
}
return st.FlowId
}
// torqueRangeCriteria 取「isTorque 步骤 + RANGE 逻辑」的考核标准(即扭矩规格)。
// flowId>0 限定某个工艺流程;flowId<=0 取全部流程(供看板全局控制图使用)。
// 判定完全依据步骤 isTorque 标记与区间逻辑,不依赖指标名,杜绝「时间」等误命名导致漏判。
func (s *Service) torqueRangeCriteria(ctx context.Context, flowId int) ([]*ent.StepCriterion, error) {
stepQ := s.ctx.EntClient.ProcessStep.Query().Where(processstep.IsTorque(true))
if flowId > 0 {
stepQ = stepQ.Where(processstep.FlowId(flowId))
}
steps, err := stepQ.All(ctx)
if err != nil {
return nil, err
}
if len(steps) == 0 {
return nil, nil
}
ids := make([]int, 0, len(steps))
for _, st := range steps {
ids = append(ids, st.ID)
}
return s.ctx.EntClient.StepCriterion.Query().
Where(stepcriterion.StepIdIn(ids...), stepcriterion.Logic("RANGE")).
All(ctx)
}
// ListTorqueRecords 查询拧紧数据(四条件复合取交集:工单号/SN/日期区间/工位)
func (s *Service) ListTorqueRecords(ctx context.Context, sn, workOrderNo, stationNo string, from, to time.Time) ([]*ent.TorqueRecord, error) {
q := s.ctx.EntClient.TorqueRecord.Query()
if sn != "" {
// 大小写不敏感(2026-09-08 全项目搜索规范)
q = q.Where(torquerecord.SnEqualFold(sn))
}
if workOrderNo != "" {
q = q.Where(torquerecord.WorkOrderNoEqualFold(workOrderNo))
}
if stationNo != "" {
q = q.Where(torquerecord.StationNoEqualFold(stationNo))
}
if !from.IsZero() {
q = q.Where(torquerecord.TimeGTE(from))
}
if !to.IsZero() {
q = q.Where(torquerecord.TimeLTE(to))
}
return q.Order(ent.Desc(torquerecord.FieldTime)).Limit(500).All(ctx)
}
// ProcessStepTemplate 下发给前端渲染的参数采集模板
type ProcessStepTemplate struct {
ID int `json:"id"`
Seq int `json:"seq"`
Name string `json:"name"`
CollectType string `json:"collectType"` // AUTO(拧紧枪自动)/MANUAL(手填)/NONE
IsTorque bool `json:"isTorque"`
NeedCheck bool `json:"needCheck"`
// 签字机制(需求B):操作工报工前须签字确认 / 检验员待签任务须签字确认方可流转
NeedOperatorSign bool `json:"needOperatorSign"`
NeedInspectorSign bool `json:"needInspectorSign"`
Remark string `json:"remark"`
Attachment []map[string]string `json:"attachment"` // 本步骤图纸/附件 [{name,url}],按工序分发到工位终端
Criteria []CriterionVO `json:"criteria"`
}
// CriterionVO 考核标准视图
type CriterionVO struct {
ID int `json:"id"`
Name string `json:"name"`
Unit string `json:"unit"`
Logic string `json:"logic"` // GE/LE/GT/LT/RANGE/EQUAL/NONE
Target float64 `json:"target"`
Min *float64 `json:"min"`
Max *float64 `json:"max"`
}
// ListStationSteps 按工位号加载该工位绑定且「启用」的工艺流程的工序步骤(含考核标准)。
// 链路:工位号 → station.flow_id → 工艺流程(绑定关系在「工位绑定」页维护,流程可绑任意工位)。
// 选工位 → 自动带出该工位的工序步骤(供巡检终端等按工位渲染)。
func (s *Service) ListStationSteps(ctx context.Context, stationNo int) ([]*ProcessStepTemplate, error) {
if stationNo < 1 {
return []*ProcessStepTemplate{}, nil
}
st, err := s.ctx.EntClient.Station.Query().Where(station.StationNo(stationNo)).First(ctx)
if err != nil || st.FlowId <= 0 {
// 该工位未绑定工艺流程:返回空模板(前端提示)
return []*ProcessStepTemplate{}, nil
}
flow, err := s.ctx.EntClient.ProcessFlow.Get(ctx, st.FlowId)
if err != nil || flow.Status != "ACTIVE" {
return []*ProcessStepTemplate{}, nil
}
return s.flowSteps(ctx, flow.ID), nil
}
// StepItemReq 一次保存的一个步骤(含其考核标准)
type StepItemReq struct {
ID int `json:"id"`
Seq int `json:"seq"`
Name string `json:"name"`
CollectType string `json:"collectType"`
IsTorque bool `json:"isTorque"`
NeedCheck bool `json:"needCheck"`
// 签字机制(需求B):保存工艺步骤时携带,落库到 process_step 表
NeedOperatorSign bool `json:"needOperatorSign"`
NeedInspectorSign bool `json:"needInspectorSign"`
Remark string `json:"remark"`
Attachment []map[string]string `json:"attachment"` // 本步骤图纸/附件 [{name,url}]
Criteria []CriterionVO `json:"criteria"`
}