Files
bj_power/bj_power_mes/internal/logic/inspection.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

460 lines
20 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"
"encoding/json"
"errors"
"net/http"
"strings"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/inspectionrecord"
"bj_power_mes/ent/material"
"bj_power_mes/ent/workpiece"
"bj_power_mes/internal/wmsclient"
)
// FlexStr 兼容客户端把数字字段传成 number 或 string(前端 stationNo 用数字,
// 标准 JSON 反序列化进 string 会报错 → 400 请求体解析失败)
type FlexStr string
func (f *FlexStr) UnmarshalJSON(b []byte) error {
s := strings.TrimSpace(string(b))
s = strings.Trim(s, `"`)
if s == "null" {
s = ""
}
*f = FlexStr(s)
return nil
}
// InspectionReq 巡检记录请求(PAD 巡检终端,块8)
type InspectionReq struct {
Category string `json:"category"` // CHECKIN/POINT/PROCESS/DONE/ALARM
StationNo FlexStr `json:"stationNo"`
Shift string `json:"shift"` // 早/中/晚
OrderNo string `json:"orderNo"` // 工单号
Sn string `json:"sn"` // 工件SN
Result string `json:"result"` // OK/NG
Items []string `json:"items"` // 点检项/异常类型
Photo string `json:"photo"` // 拍照文件名
Remark string `json:"remark"` // 文字描述/签字
Operator string `json:"operator"` // 操作人
// P0-4 过程巡检按步骤维度
ProcessCode int `json:"processCode"` // 所属工位号
StepId int `json:"stepId"` // 工艺步骤ID
StepName string `json:"stepName"` // 工艺步骤名称
MeasuredValue string `json:"measuredValue"` // 实测值
// 质量检验(过程检/完工检/来料检)扩展字段
ReportNo string `json:"reportNo"` // 报检单号
MaterialCode string `json:"materialCode"` // 物料编码(图号)
MaterialName string `json:"materialName"` // 物料名称
Manufacturer string `json:"manufacturer"` // 生产厂家
InspectionNo string `json:"inspectionNo"` // 检验单号
AttachmentIds string `json:"attachmentIds"` // 附件ID,逗号分隔
DisposalType string `json:"disposalType"` // 处置类型 退货/返修/退换/报废
DisposalRemark string `json:"disposalRemark"` // 处置说明
// 判不合格联动 WMS 在库处置的定位字段(可空=不联动):
// 序列号=是(sn_mode=1)填 SN、序列号=否(sn_mode=2)填批次号;
// 定位口径由后端按物料档案 sn_mode 判定(SN=按序列号定位 / 批次=按批次定位)
BatchSn string `json:"batchSn"`
ReturnTrackingNo string `json:"returnTrackingNo"` // 退货运单号(退货/退换处置必填)
// 完工检(FINAL)扩展:产成品入库随回流 WMS(选填,其他类别存了也无害)
RelatedStandard string `json:"relatedStandard"` // 相关标准/试验方案号
TestRecordNo string `json:"testRecordNo"` // 试验记录单号
}
// wmsDisposalType MES 中文处置方式 → WMS 内部处置枚举(RETURN/REWORK/SCRAP);
// 无法映射返回空串(不联动 WMS,仅留痕)。
func wmsDisposalType(v string) string {
switch v {
case "退货", "退换":
return "RETURN"
case "返修":
return "REWORK"
case "报废":
return "SCRAP"
}
return ""
}
// CreateInspection 提交巡检记录;ALARM 类型同时触发看板报警(SSE + 清缓存)。
// 质量检验(过程检/完工检)判不合格且填了批次号/SN 时,联动 WMS 在库处置:
// 检验留痕优先——WMS 调用失败不阻断保存,仅在返回信息中提示「库存联动失败: 原因」。
func (s *Service) CreateInspection(ctx context.Context, req InspectionReq, operator string) (string, error) {
if req.Category == "" {
return "", errors.New("记录类型必填")
}
category := req.Category
// PROCESS 为 PAD 巡检终端「过程巡检」专用;MES 车间质检「过程检」用 QC_PROCESS 隔离,
// 避免同枚举导致两个列表互混、统计口径乱(P1-8)。
if !oneOf(category, "CHECKIN", "POINT", "PROCESS", "DONE", "ALARM", "INCOMING", "FINAL", "QC_PROCESS") {
return "", errors.New("记录类型不合法")
}
result := req.Result
if result == "" {
result = "OK"
}
if req.Operator == "" {
req.Operator = operator
}
create := s.ctx.EntClient.InspectionRecord.Create().
SetCategory(category).
SetStationNo(string(req.StationNo)).
SetShift(req.Shift).
SetOrderNo(req.OrderNo).
SetSn(req.Sn).
SetResult(result).
SetItems(req.Items).
SetPhoto(req.Photo).
SetRemark(req.Remark).
SetOperator(req.Operator).
SetProcessCode(req.ProcessCode).
SetStepId(req.StepId).
SetStepName(req.StepName).
SetMeasuredValue(req.MeasuredValue)
if req.ReportNo != "" {
create.SetReportNo(req.ReportNo)
}
if req.MaterialCode != "" {
create.SetMaterialCode(req.MaterialCode)
}
if req.MaterialName != "" {
create.SetMaterialName(req.MaterialName)
}
if req.Manufacturer != "" {
create.SetManufacturer(req.Manufacturer)
}
if req.InspectionNo != "" {
create.SetInspectionNo(req.InspectionNo)
}
if req.AttachmentIds != "" {
create.SetAttachmentIds(req.AttachmentIds)
}
if req.DisposalType != "" {
create.SetDisposalType(req.DisposalType)
}
if req.DisposalRemark != "" {
create.SetDisposalRemark(req.DisposalRemark)
}
if req.BatchSn != "" {
create.SetBatchSn(req.BatchSn)
}
if req.RelatedStandard != "" {
create.SetRelatedStandard(req.RelatedStandard)
}
if req.TestRecordNo != "" {
create.SetTestRecordNo(req.TestRecordNo)
}
rec, err := create.Save(ctx)
if err != nil {
return "", err
}
s.ctx.EventLog.Write(ctx, "inspection."+category, req.OrderNo, req.Operator, "inspection_record",
req.Sn, "巡检终端提交", map[string]any{"category": category, "stationNo": string(req.StationNo), "result": result})
// 判不合格 → 联动 WMS 在库处置(缺口 B):
// 前提:结论 NG + 已选可映射的处置方式 + 物料编码与批次号/SN 齐全;
// 定位口径由后端按物料档案 sn_mode 判定:序列号=是按 SN(material_code+序列号)、序列号=否按批次(material_code+批次号)。
// WMS 调用失败不阻断检验留痕,返回信息提示「库存联动失败」,并写事件日志便于追溯。
msg := "巡检记录已提交"
if result == "NG" && req.MaterialCode != "" && req.BatchSn != "" {
if dt := wmsDisposalType(req.DisposalType); dt != "" {
snMode := 2
if m, err := s.ctx.EntClient.Material.Query().Where(material.CodeEQ(req.MaterialCode)).First(ctx); err == nil {
snMode = m.SnMode
}
wreq := wmsclient.DisposeInventoryReq{
MaterialCode: req.MaterialCode,
DisposalType: dt,
ReturnTrackingNo: req.ReturnTrackingNo,
Remark: req.DisposalRemark,
Operator: req.Operator,
}
if snMode == 1 {
wreq.Sn = req.BatchSn
} else {
wreq.BatchNo = req.BatchSn
}
if err := s.ctx.Wms.DisposeInventory(ctx, wreq); err != nil {
msg = "检验记录已保存;库存联动失败: " + err.Error()
s.recordSyncFailure("inspection.dispose", req.Sn, "/api/internal/inventory/dispose", wreq, err)
s.ctx.EventLog.Write(ctx, "inspection.wms_dispose_failed", req.OrderNo, req.Operator,
"inspection_record", req.Sn, "库存联动失败 "+err.Error(),
map[string]any{"materialCode": req.MaterialCode, "batchSn": req.BatchSn,
"disposalType": dt, "snMode": snMode})
} else {
msg = "检验记录已保存,已联动 WMS 在库处置(" + req.DisposalType + ")"
s.ctx.EventLog.Write(ctx, "inspection.wms_disposed", req.OrderNo, req.Operator,
"inspection_record", req.Sn, "已联动 WMS 在库处置 "+dt,
map[string]any{"materialCode": req.MaterialCode, "batchSn": req.BatchSn,
"disposalType": dt, "snMode": snMode})
}
}
}
// B2.3 检验不合格 → 触发 inspection_ng 预警(事件触发型,enabled 即命中,忽略阈值):
// 仅结论 NG 时触发;走 Evaluate 经 alert_rule(enabled) 门控,与拧紧/库存/超期预警同一框架。
if result == "NG" {
s.Evaluate(ctx, "inspection_ng", 1, "检验不合格",
"检验记录不合格:类型="+category+" SN="+req.Sn+" 工位"+string(req.StationNo),
"inspection_record", req.Sn, req.OrderNo)
}
// 完工检(FINAL)结论触发成品回流入库(方案A:完工检合格才入库,完工确认仅代表生产完成):
// 已通过→入库(合格)、部分通过→入库(合格)、不合格/报废→不入库待返修;
// WMS 调用结果以提示透出,不阻断检验留痕(与上方库存联动同降级策略)。
if category == "FINAL" {
msg = s.finishedInspectionInbound(ctx, rec, req, result, msg)
}
if category == "ALARM" {
// 触发看板报警:SSE 推送(看板缓存已迁进程内,无需失效外部缓存)
alarmJSON, _ := json.Marshal(map[string]any{
"level": "CRITICAL",
"type": "inspection_alarm",
"message": "巡检异常上报:" + req.Remark,
"station": string(req.StationNo),
"time": time.Now().Format("2006-01-02 15:04:05"),
})
if s.ctx.SSE != nil {
s.ctx.SSE.Publish("dashboard.alarm", string(alarmJSON))
}
}
s.notifyDashboard()
return msg, nil
}
// ListInspections 查询巡检记录(不分页,供内部/导出用,封顶 1000)
func (s *Service) ListInspections(ctx context.Context, category, operator, from, to string) ([]*ent.InspectionRecord, error) {
rows, _, err := s.ListInspectionsPaged(ctx, category, operator, from, to, "", "", "", "", "", 1, 1000)
return rows, err
}
// ListInspectionsPaged 分页查询巡检记录,返回 {rows, total};排序 id desc 最新置顶
// orderNo/stationNo:2026-09-08 补充筛选(大小写不敏感)
// materialCode/materialName/reportNo:质量检验模糊查询(Item H,每框内模糊、多框取交集)
func (s *Service) ListInspectionsPaged(ctx context.Context, category, operator, from, to, orderNo, stationNo, materialCode, materialName, reportNo string, page, pageSize int) ([]*ent.InspectionRecord, int, error) {
q := s.ctx.EntClient.InspectionRecord.Query()
if category != "" {
q = q.Where(inspectionrecord.Category(category))
}
if orderNo != "" {
q = q.Where(inspectionrecord.OrderNoEqualFold(orderNo))
}
if stationNo != "" {
q = q.Where(inspectionrecord.StationNoEqualFold(stationNo))
}
if materialCode != "" {
q = q.Where(inspectionrecord.MaterialCodeContainsFold(materialCode))
}
if materialName != "" {
q = q.Where(inspectionrecord.MaterialNameContainsFold(materialName))
}
if reportNo != "" {
q = q.Where(inspectionrecord.ReportNoContainsFold(reportNo))
}
if operator != "" {
q = q.Where(inspectionrecord.Operator(operator))
}
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)))
}
}
total, err := q.Count(ctx)
if err != nil {
return nil, 0, err
}
rows, err := q.Order(ent.Desc(inspectionrecord.FieldID)).
Offset((page - 1) * pageSize).Limit(pageSize).All(ctx)
return rows, total, err
}
func oneOf(v string, items ...string) bool {
for _, it := range items {
if v == it {
return true
}
}
return false
}
// GetInspectionRecord 按 id 查询一条检验记录(质量检验处置/不合格单用)
func (s *Service) GetInspectionRecord(ctx context.Context, id int) (*ent.InspectionRecord, error) {
if id <= 0 {
return nil, errors.New("缺少 id")
}
rec, err := s.ctx.EntClient.InspectionRecord.Get(ctx, id)
if err != nil {
return nil, errors.New("检验记录不存在")
}
return rec, nil
}
// SetInspectionDisposal 质量检验处置:区分 退货/返修/退换/报废,写处置说明。
func (s *Service) SetInspectionDisposal(ctx context.Context, id int, disposalType, disposalRemark, operator string) (string, error) {
if id <= 0 {
return "", errors.New("缺少 id")
}
if !oneOf(disposalType, "退货", "返修", "退换", "报废") {
return "", errors.New("处置类型仅支持 退货/返修/退换/报废")
}
rec, err := s.ctx.EntClient.InspectionRecord.Get(ctx, id)
if err != nil {
return "", errors.New("检验记录不存在")
}
_, err = s.ctx.EntClient.InspectionRecord.UpdateOneID(id).
SetDisposalType(disposalType).SetDisposalRemark(disposalRemark).Save(ctx)
if err != nil {
return "", err
}
s.ctx.EventLog.Write(ctx, "inspection.disposal", rec.OrderNo, operator, "inspection_record", rec.Sn,
"质量检验处置 "+disposalType, map[string]any{"id": id, "remark": disposalRemark})
return "处置已记录", nil
}
// finishedInspectionInbound 完工检记录保存后按结论触发成品回流入库(方案A定稿)。
// 结论映射:OK=已通过→入库(qualityStatus=合格);PARTIAL=部分通过→入库(qualityStatus=合格,
// 由 WMS 侧按 productStatus 映射);NG(含报废处置)→不入库,仅记事件日志待返修/报废。
// 归属三字段照 semi.go workpieceWorkOrder 继承模式取自工单;
// relatedStandard/testRecordNo:取自完工检记录(录入弹窗选填),随成品回流 WMS。
// WMS 409(SN 防重,返修后复检重复入库)转成「已入库勿重复」友好提示;其余失败仅提示不阻断留痕。
func (s *Service) finishedInspectionInbound(ctx context.Context, rec *ent.InspectionRecord, req InspectionReq, result, msg string) string {
productStatus := ""
switch result {
case "OK":
productStatus = "已通过"
case "PARTIAL":
productStatus = "部分通过"
}
if productStatus == "" {
// 不合格(含处置=报废/退货/退换):不入库,留痕待返修/报废
note := "成品" + rec.Sn + "完工检不合格,未入库,待返修/报废"
if req.DisposalType == "报废" {
note = "成品" + rec.Sn + "完工检报废,未入库"
}
s.ctx.EventLog.Write(ctx, "wms.finished.not_inbound", rec.OrderNo, rec.Operator, "inspection_record", rec.Sn,
note, map[string]any{"reportNo": rec.ReportNo, "result": result, "disposalType": req.DisposalType})
return msg
}
// 成品 SN:优先工件SN栏,缺省回退批次号/SN 栏(序列号=是该栏填的即 SN)
sn := strings.TrimSpace(req.Sn)
if sn == "" {
sn = strings.TrimSpace(req.BatchSn)
}
if sn == "" {
s.ctx.EventLog.Write(ctx, "wms.finished.inbound_skipped", rec.OrderNo, rec.Operator, "inspection_record", "",
"完工检合格但未填成品SN,未触发WMS入库,请人工补录", map[string]any{"reportNo": rec.ReportNo, "productStatus": productStatus})
return "检验记录已保存;未填成品SN,未自动入WMS库"
}
wp, err := s.ctx.EntClient.Workpiece.Query().Where(workpiece.Sn(sn)).First(ctx)
if err != nil {
s.ctx.EventLog.Write(ctx, "wms.finished.inbound_skipped", rec.OrderNo, rec.Operator, "inspection_record", sn,
"完工检合格但成品SN未匹配到工件,未触发WMS入库,请人工核查", map[string]any{"reportNo": rec.ReportNo, "productStatus": productStatus})
return "检验记录已保存;成品SN未匹配到工件,未自动入WMS库"
}
wo := s.workpieceWorkOrder(ctx, wp)
if wo == nil {
s.ctx.EventLog.Write(ctx, "wms.finished.inbound_failed", wp.OrderNo, rec.Operator, "workpiece", wp.Sn,
"完工检合格但成品回流WMS入库失败:工单不存在", map[string]any{"error": "work order not found"})
return "检验记录已保存;WMS 入库失败:工件所属工单不存在"
}
// 质量状态落库值:合格类(已通过/部分通过)统一传「合格」。
// 不传「已通过/部分通过」等非库存枚举值(WMS 库存质量状态仅认 合格/不合格/未检/待退)。
qualityStatusForWMS := "合格"
if wmsErr := s.ctx.Wms.FinishedInbound(ctx, wmsclient.FinishedPayload{
ProductCode: wo.ProductCode, ProductName: wo.ProductName, Sn: wp.Sn, OrderNo: wp.OrderNo,
Operator: rec.Operator, ProductStatus: productStatus, QualityStatus: qualityStatusForWMS,
RelatedStandard: rec.RelatedStandard, TestRecordNo: rec.TestRecordNo,
OwnershipType: wo.OwnershipType, OwnershipNo: wo.ContractNo, ProductWorkNo: wo.WorkOrderNo,
}); wmsErr != nil {
var re *wmsclient.RespError
if errors.As(wmsErr, &re) && re.Status == http.StatusConflict {
s.ctx.EventLog.Write(ctx, "wms.finished.duplicate", wp.OrderNo, rec.Operator, "workpiece", wp.Sn,
"完工检合格,但WMS提示成品SN已入库(防重拦截),请勿重复入库", map[string]any{"productCode": wo.ProductCode, "productStatus": productStatus})
return "检验记录已保存;该成品已入WMS库,请勿重复入库"
}
s.recordSyncFailure("finished.inbound", wp.Sn, "/api/internal/finished/inbound",
map[string]any{
"productCode": wo.ProductCode, "productName": wo.ProductName, "sn": wp.Sn,
"orderNo": wp.OrderNo, "snSource": "AUTO", "operator": rec.Operator,
"productStatus": productStatus, "qualityStatus": qualityStatusForWMS,
"relatedStandard": rec.RelatedStandard, "testRecordNo": rec.TestRecordNo,
"ownershipType": wo.OwnershipType, "ownershipNo": wo.ContractNo,
"productWorkNo": wo.WorkOrderNo,
}, wmsErr)
s.ctx.EventLog.Write(ctx, "wms.finished.inbound_failed", wp.OrderNo, rec.Operator, "workpiece", wp.Sn,
"完工检合格但成品回流WMS入库失败(库存未入,请人工补录)",
map[string]any{"error": wmsErr.Error(), "productCode": wo.ProductCode, "productStatus": productStatus})
return "检验记录已保存;WMS 入库失败: " + wmsErr.Error()
}
s.ctx.EventLog.Write(ctx, "wms.finished.inbound", wp.OrderNo, rec.Operator, "workpiece", wp.Sn,
"完工检"+productStatus+",成品已回流WMS入库", map[string]any{
"reportNo": rec.ReportNo, "productCode": wo.ProductCode, "productStatus": productStatus,
"relatedStandard": rec.RelatedStandard, "testRecordNo": rec.TestRecordNo,
"ownershipType": wo.OwnershipType, "ownershipNo": wo.ContractNo, "productWorkNo": wo.WorkOrderNo})
return msg + ";成品已回流WMS入库(" + productStatus + ")"
}
// FinishedPendingItem 待完工检成品行(完工确认后尚无对应完工检记录的成品 SN)
type FinishedPendingItem struct {
Sn string `json:"sn"`
OrderNo string `json:"orderNo"`
ProductCode string `json:"productCode"`
ProductName string `json:"productName"`
DoneAt string `json:"doneAt"`
}
// FinishedPendingList 待完工检成品:workpiece status=DONE 且 inspection_record(category=FINAL)
// 中无以该 SN 为工件SN 的记录,按完工时间倒序只读分页,供质检页完工检页签查看待检清单。
// 依据检验记录的 sn 字段排除(完工检录入必须填成品SN);历史 sn 为空的记录不参与排除。
func (s *Service) FinishedPendingList(ctx context.Context, page, pageSize int) ([]FinishedPendingItem, int, error) {
inspected, err := s.ctx.EntClient.InspectionRecord.Query().
Where(inspectionrecord.Category("FINAL"), inspectionrecord.SnNEQ("")).
Select(inspectionrecord.FieldSn).Strings(ctx)
if err != nil {
return nil, 0, err
}
q := s.ctx.EntClient.Workpiece.Query().Where(workpiece.Status("DONE"))
if len(inspected) > 0 {
q = q.Where(workpiece.Not(workpiece.SnIn(inspected...)))
}
if page < 1 {
page = 1
}
if pageSize < 1 {
pageSize = 20
}
total, err := q.Count(ctx)
if err != nil {
return nil, 0, err
}
list, err := q.Order(ent.Desc(workpiece.FieldDoneAt)).
Offset((page - 1) * pageSize).Limit(pageSize).All(ctx)
if err != nil {
return nil, 0, err
}
out := make([]FinishedPendingItem, 0, len(list))
for _, wp := range list {
code, name := "", ""
if wo := s.workpieceWorkOrder(ctx, wp); wo != nil {
code, name = wo.ProductCode, wo.ProductName
}
doneAt := ""
if wp.DoneAt != nil {
doneAt = wp.DoneAt.Format("2006-01-02 15:04:05")
}
out = append(out, FinishedPendingItem{
Sn: wp.Sn, OrderNo: wp.OrderNo, ProductCode: code, ProductName: name, DoneAt: doneAt,
})
}
return out, total, nil
}