Files
bj_power/bj_power_wms/internal/handler/alert.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

434 lines
12 KiB
Go

package handler
import (
"fmt"
"net/http"
"strconv"
"time"
"bj_power_wms/ent/alert"
"bj_power_wms/ent/alertrule"
"bj_power_wms/ent/inventory"
"bj_power_wms/ent/inspectionrecord"
"bj_power_wms/ent/material"
"bj_power_wms/internal/svc"
"entgo.io/ent/dialect/sql"
"github.com/zeromicro/go-zero/rest/pathvar"
)
// 六类预警的固定 rule_code(与 alert_rules.code 一一对应;2026-11-02 条目15 新增 negative_stock)。
const (
ruleInventoryLow = "inventory_low"
ruleInspectionOver = "inspection_overdue"
ruleBackupOverdue = "backup_overdue"
ruleSyncFailed = "sync_failed"
ruleInventoryAge = "inventory_age"
ruleNegativeStock = "negative_stock"
)
// 扫描默认阈值(仅在规则未配置时使用)。
const (
defaultInspectionOverdueHours = 48 // 来料检超期小时
defaultInventoryAgeDays = 180 // 库龄超档天
alertDedupHours = 24 // 同一 rule_code+target 防刷窗口(小时)
)
// alertRuleDef 默认规则定义(扫描器启动时确保存在)。
var alertRuleDefs = []struct {
code string
name string
threshold int
}{
{ruleInventoryLow, "库存阈值/缺货预警", 0},
{ruleInspectionOver, "来料检超期未检预警", defaultInspectionOverdueHours},
{ruleBackupOverdue, "备份超期预警", 0},
{ruleSyncFailed, "物料同步失败预警", 0},
{ruleInventoryAge, "库龄超档预警", defaultInventoryAgeDays},
{ruleNegativeStock, "库存负数异常预警", 0},
}
// ensureAlertRules 确保五类规则存在(缺则插入,已存在不覆盖用户修改)。
func ensureAlertRules(ctx *svc.ServiceContext) {
for _, d := range alertRuleDefs {
exist, err := ctx.EntClient.AlertRule.Query().Where(alertrule.CodeEQ(d.code)).Exist(ctx0())
if err != nil || exist {
continue
}
_, _ = ctx.EntClient.AlertRule.Create().
SetCode(d.code).
SetName(d.name).
SetEnabled(true).
SetThreshold(d.threshold).
Save(ctx0())
}
}
// getAlertRule 读取规则启用状态与阈值。
func getAlertRule(ctx *svc.ServiceContext, code string) (enabled bool, threshold int) {
r, err := ctx.EntClient.AlertRule.Query().Where(alertrule.CodeEQ(code)).Only(ctx0())
if err != nil {
return false, 0
}
return r.Enabled, r.Threshold
}
// alertExistsRecent 同一 rule_code+target 是否已有「未读」且较新(窗口内)的预警(防刷)。
func alertExistsRecent(ctx *svc.ServiceContext, ruleCode, target string) (bool, error) {
cutoff := time.Now().Unix() - int64(alertDedupHours)*3600
return ctx.EntClient.Alert.Query().
Where(
alert.And(
alert.RuleCodeEQ(ruleCode),
alert.TargetEQ(target),
alert.StatusEQ("unread"),
alert.CreatedAtGT(cutoff),
),
).
Exist(ctx0())
}
// upsertAlert 防刷写入预警:窗口内已存在相同未读预警则跳过。
func upsertAlert(ctx *svc.ServiceContext, ruleCode, level, title, content, target string) {
exists, err := alertExistsRecent(ctx, ruleCode, target)
if err != nil || exists {
return
}
_, _ = ctx.EntClient.Alert.Create().
SetRuleCode(ruleCode).
SetLevel(level).
SetTitle(title).
SetContent(content).
SetTarget(target).
Save(ctx0())
}
// scanInventoryLow 库存阈值/缺货:materials.safety_stock>0 的物料,合格可用量低于安全库存则预警。
func scanInventoryLow(ctx *svc.ServiceContext) {
enabled, _ := getAlertRule(ctx, ruleInventoryLow)
if !enabled {
return
}
mats, err := ctx.EntClient.Material.Query().Where(material.SafetyStockGT(0)).All(ctx0())
if err != nil {
return
}
for _, m := range mats {
rows, e := ctx.EntClient.Inventory.Query().
Where(
inventory.And(
inventory.MaterialCodeEQ(m.Code),
inventory.QualityStatusEQ("合格"),
),
).
All(ctx0())
if e != nil {
continue
}
avail := 0
for _, inv := range rows {
q := inv.Quantity - inv.LockedQty
if q < 0 {
q = 0
}
avail += q
}
if avail < m.SafetyStock {
upsertAlert(ctx, ruleInventoryLow, "warning",
"库存偏低:"+m.Name,
fmt.Sprintf("物料 %s(%s) 合格可用量 %d 低于安全库存 %d,请及时补货", m.Code, m.Name, avail, m.SafetyStock),
m.Code)
}
}
}
// scanInspectionOverdue 来料检超期未检:inspection_records 仍「未检」且创建距今超阈值小时。
func scanInspectionOverdue(ctx *svc.ServiceContext) {
enabled, threshold := getAlertRule(ctx, ruleInspectionOver)
if !enabled {
return
}
if threshold <= 0 {
threshold = defaultInspectionOverdueHours
}
cutoff := time.Now().Unix() - int64(threshold)*3600
recs, err := ctx.EntClient.InspectionRecord.Query().
Where(
inspectionrecord.And(
inspectionrecord.StatusEQ("未检"),
inspectionrecord.CreatedAtLT(cutoff),
),
).
All(ctx0())
if err != nil {
return
}
for _, r := range recs {
name := r.MaterialName
if name == "" {
name = r.MaterialCode
}
upsertAlert(ctx, ruleInspectionOver, "warning",
"来料检超期未检:"+name,
fmt.Sprintf("物料 %s(%s) 检验记录 %s 已超 %d 小时未检,请尽快安排检验", r.MaterialCode, name, r.TargetID, threshold),
r.TargetID)
}
}
// scanBackupOverdue 备份超期:复用 backup 服务的 Reminder 计算,超期则产生一条预警。
func scanBackupOverdue(ctx *svc.ServiceContext) {
enabled, _ := getAlertRule(ctx, ruleBackupOverdue)
if !enabled {
return
}
days := CfgIntFromSysConfig(ctx, CfgArchiveRemindDays, 7)
res, err := ctx.Backup.Reminder(days)
if err != nil {
return
}
if res.Overdue {
upsertAlert(ctx, ruleBackupOverdue, "warning",
"备份超期提醒",
fmt.Sprintf("距上次成功备份已超 %d 天,请及时进行数据归档备份", days),
"backup")
}
}
// scanSyncFailed 物料同步失败:materials.sync_pending=true。
func scanSyncFailed(ctx *svc.ServiceContext) {
enabled, _ := getAlertRule(ctx, ruleSyncFailed)
if !enabled {
return
}
mats, err := ctx.EntClient.Material.Query().Where(material.SyncPendingEQ(true)).All(ctx0())
if err != nil {
return
}
for _, m := range mats {
upsertAlert(ctx, ruleSyncFailed, "error",
"物料同步失败:"+m.Name,
fmt.Sprintf("物料 %s(%s) 推送 MES 失败,请手动重试同步", m.Code, m.Name),
m.Code)
}
}
// scanInventoryAge 库龄超档:inventories qty>0 且创建距今超阈值天的库存行。
func scanInventoryAge(ctx *svc.ServiceContext) {
enabled, threshold := getAlertRule(ctx, ruleInventoryAge)
if !enabled {
return
}
if threshold <= 0 {
threshold = defaultInventoryAgeDays
}
cutoff := time.Now().Unix() - int64(threshold)*86400
rows, err := ctx.EntClient.Inventory.Query().
Where(
inventory.And(
inventory.QuantityGT(0),
inventory.CreatedAtLT(cutoff),
),
).
All(ctx0())
if err != nil {
return
}
for _, inv := range rows {
target := "inv:" + strconv.Itoa(inv.ID)
name := inv.MaterialName
if name == "" {
name = inv.MaterialCode
}
upsertAlert(ctx, ruleInventoryAge, "info",
"库龄超档:"+name,
fmt.Sprintf("物料 %s(%s) 库存行入库已超 %d 天,库龄超档请关注", inv.MaterialCode, name, threshold),
target)
}
}
// scanNegativeStock 库存负数异常:inventories quantity<0 的库存行(数据异常,需人工核对出入库流水)。
func scanNegativeStock(ctx *svc.ServiceContext) {
enabled, _ := getAlertRule(ctx, ruleNegativeStock)
if !enabled {
return
}
rows, err := ctx.EntClient.Inventory.Query().
Where(inventory.QuantityLT(0)).All(ctx0())
if err != nil {
return
}
for _, inv := range rows {
target := "neg:" + strconv.Itoa(inv.ID)
name := inv.MaterialName
if name == "" {
name = inv.MaterialCode
}
upsertAlert(ctx, ruleNegativeStock, "error",
"库存负数异常:"+name,
fmt.Sprintf("物料 %s(%s) 在 %s/%s 库存数量为 %d(负数),数据异常,请核对出入库流水并做盘点纠正",
inv.MaterialCode, name, inv.ZoneCode, inv.ShelfNo, inv.Quantity),
target)
}
}
// runAlertScan 执行一轮全量扫描(先确保规则存在)。
func runAlertScan(ctx *svc.ServiceContext) {
ensureAlertRules(ctx)
scanInventoryLow(ctx)
scanInspectionOverdue(ctx)
scanBackupOverdue(ctx)
scanSyncFailed(ctx)
scanInventoryAge(ctx)
scanNegativeStock(ctx)
}
// StartAlertScanner 启动后台扫描协程:立即跑一次,之后每 5 分钟一轮。
// 仅在服务启动期调用一次(见 bj_power_wms.go)。
func StartAlertScanner(ctx *svc.ServiceContext) {
go func() {
runAlertScan(ctx)
ticker := time.NewTicker(5 * time.Minute)
defer ticker.Stop()
for range ticker.C {
runAlertScan(ctx)
}
}()
}
// ===== API =====
// listAlertsHandler GET /api/alerts 列表(可按 status / rule_code 过滤)+ 未读总数。
func listAlertsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
status := q.Get("status")
ruleCode := q.Get("rule_code")
page := atoi(q.Get("page"), 1)
pageSize := atoi(q.Get("pageSize"), 20)
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 200 {
pageSize = 20
}
builder := ctx.EntClient.Alert.Query()
if status != "" {
builder = builder.Where(alert.StatusEQ(status))
}
if ruleCode != "" {
builder = builder.Where(alert.RuleCodeEQ(ruleCode))
}
total, err := builder.Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
list, err := builder.
Order(alert.ByCreatedAt(sql.OrderDesc())).
Offset((page - 1) * pageSize).
Limit(pageSize).
All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
unread, err := ctx.EntClient.Alert.Query().Where(alert.StatusEQ("unread")).Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, map[string]any{
"list": list,
"total": total,
"unreadCount": unread,
"page": page,
"pageSize": pageSize,
})
}
}
// readAlertHandler POST /api/alerts/:id/read 标记单条已读。
func readAlertHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
id, err := strconv.Atoi(pathvar.Vars(r)["id"])
if err != nil {
fail(w, http.StatusBadRequest, "无效的预警ID")
return
}
_, err = ctx.EntClient.Alert.UpdateOneID(id).SetStatus("read").Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, nil)
}
}
// readAllAlertsHandler POST /api/alerts/read-all 全部已读。
func readAllAlertsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
_, err := ctx.EntClient.Alert.Update().
Where(alert.StatusEQ("unread")).
SetStatus("read").
Save(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, nil)
}
}
// listAlertRulesHandler GET /api/alert-rules 列出规则(含启用/阈值)。
func listAlertRulesHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
rules, err := ctx.EntClient.AlertRule.Query().Order(alertrule.ByCode()).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, rules)
}
}
// updateAlertRuleHandler POST /api/alert-rules/update 按 code 更新 enabled/threshold/remark。
func updateAlertRuleHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
Code string `json:"code"`
Enabled *bool `json:"enabled"`
Threshold *int `json:"threshold"`
Remark *string `json:"remark"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "请求体解析失败:"+err.Error())
return
}
if req.Code == "" {
fail(w, http.StatusBadRequest, "规则编码不能为空")
return
}
upd := ctx.EntClient.AlertRule.Update().Where(alertrule.CodeEQ(req.Code))
if req.Enabled != nil {
upd = upd.SetEnabled(*req.Enabled)
}
if req.Threshold != nil {
upd = upd.SetThreshold(*req.Threshold)
}
if req.Remark != nil {
upd = upd.SetRemark(*req.Remark)
}
upd = upd.SetUpdatedAt(time.Now().Unix())
if _, err := upd.Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
ok(w, nil)
}
}