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 库存数量为 %.2f(负数),数据异常,请核对出入库流水并做盘点纠正", 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) } }