Files
bj_power/bj_power_wms/internal/ws/todo_hub.go
T
SunYF 619fc8983d feat: 全端体验与稳定性整改(帮助文档清理/收集式报错/操作列统一/托盘与WS通知/物料同步重推)
- 移除 bj_power_dashboard 旧 React 大屏源码(迁移至 2D SVG 方案)
- MES/WMS/工位终端前端:清理 help.js 与 PageHelp 帮助文档,统一操作列与布局,接入请求拦截器
- 新增收集式校验错误弹窗(ErrorListDialog 统一拦截 3015,逐条列现象+建议)
- 新增托盘程序(tray)与 WebSocket(ws) 实时通知模块(三端共用)
- MES/WMS 物料档案新增同步状态字段,补齐双向失败重推与默认角色 seed
- 工单/产能/产品工艺/日排产逻辑调整;拧紧枪按工位配置
- 新增迁移 SQL:扭矩按工位、sysconfig 序列修复
- 更新 技术约束/案例/部署手册/项目说明 等文档
2026-11-10 23:42:50 +08:00

255 lines
6.3 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 ws 待办统计 WebSocket 推送中心(问题8)。
// 每 5 秒轮询 6 类待办数量,与上次不同才广播;连接建立先推一次全量。
// 统计一律用 WMS 现有表/接口,缺失的类别固定 0,不编造表。
package ws
import (
"context"
"encoding/json"
"net/http"
"net/url"
"strings"
"sync"
"time"
"bj_power_wms/ent/alert"
"bj_power_wms/ent/returnorder"
"bj_power_wms/internal/svc"
"github.com/gorilla/websocket"
)
// 6 类待办固定 menuCode(与前端菜单角标、语音播报映射一一对应)
const (
MenuCall = "wms.call" // 叫料待处理
MenuReturn = "wms.return" // 退料待确认
MenuRefill = "wms.refill" // 补料待审批
MenuQty = "wms.qty" // 数量不符待处理
MenuSign = "wms.sign" // 待审核签字
MenuAlert = "wms.alert" // 异常预警
)
var menuOrder = []string{MenuCall, MenuReturn, MenuRefill, MenuQty, MenuSign, MenuAlert}
// TodoItem 单类待办数量
type TodoItem struct {
MenuCode string `json:"menuCode"`
Count int `json:"count"`
}
// TodoPayload 推送/接口统一结构:{"items":[{"menuCode":"...","count":N}],"total":N}
type TodoPayload struct {
Items []TodoItem `json:"items"`
Total int `json:"total"`
}
// client 单个连接;每个连接独立写锁(gorilla 不允许并发 WriteMessage)
type client struct {
conn *websocket.Conn
writeMu sync.Mutex
}
func (c *client) write(msgType int, data []byte) error {
c.writeMu.Lock()
defer c.writeMu.Unlock()
_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
return c.conn.WriteMessage(msgType, data)
}
// Hub 待办推送中心
type Hub struct {
ctx *svc.ServiceContext
mu sync.Mutex
clients map[*client]struct{}
last TodoPayload
upgrader websocket.Upgrader
}
// NewTodoHub 构造 Hub
func NewTodoHub(ctx *svc.ServiceContext) *Hub {
return &Hub{
ctx: ctx,
clients: make(map[*client]struct{}),
upgrader: websocket.Upgrader{
// 允许同源;无 Origin(非浏览器客户端)放行。禁正则,用 url.Parse + EqualFold。
CheckOrigin: sameOrigin,
},
}
}
// sameOrigin 同源校验:Origin 的 host 与请求 Host 一致即放行
func sameOrigin(r *http.Request) bool {
origin := r.Header.Get("Origin")
if origin == "" {
return true
}
u, err := url.Parse(origin)
if err != nil {
return false
}
return strings.EqualFold(u.Host, r.Host)
}
// Start 计算一次全量并启动 5 秒轮询
func (h *Hub) Start() {
h.mu.Lock()
h.last = h.compute()
h.mu.Unlock()
go func() {
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for range ticker.C {
h.pollAndBroadcast()
}
}()
}
// Snapshot 返回当前统计快照(供 GET /api/todos/stats 与连接首推复用)
func (h *Hub) Snapshot() TodoPayload {
h.mu.Lock()
defer h.mu.Unlock()
p := TodoPayload{Items: make([]TodoItem, len(h.last.Items)), Total: h.last.Total}
copy(p.Items, h.last.Items)
return p
}
// compute 统计 6 类待办数量:
// - wms.call 叫料待处理:复用 /api/call/pending 同数据源(MES PENDING 叫料单)
// - wms.return 退料待确认:return_orders.status = PENDING
// - wms.qty 数量不符待处理:return_orders.receive_diff > 0(库管收货差异待核)
// - wms.alert 异常预警:alerts.status = unread(与顶栏 pollAlerts 同数据源)
// - wms.refill 补料待审批 / wms.sign 待审核签字:WMS 无对应待审批单据表,固定 0(不编造表)
func (h *Hub) compute() TodoPayload {
counts := map[string]int{
MenuCall: 0, MenuReturn: 0, MenuRefill: 0,
MenuQty: 0, MenuSign: 0, MenuAlert: 0,
}
bg := context.Background()
if h.ctx.Mes != nil {
if list, err := h.ctx.Mes.ListMaterialRequests(bg, "PENDING"); err == nil {
counts[MenuCall] = len(list)
}
}
if n, err := h.ctx.EntClient.ReturnOrder.Query().
Where(returnorder.StatusEQ("PENDING")).Count(bg); err == nil {
counts[MenuReturn] = n
}
if n, err := h.ctx.EntClient.ReturnOrder.Query().
Where(returnorder.ReceiveDiffGT(0)).Count(bg); err == nil {
counts[MenuQty] = n
}
if n, err := h.ctx.EntClient.Alert.Query().
Where(alert.StatusEQ("unread")).Count(bg); err == nil {
counts[MenuAlert] = n
}
items := make([]TodoItem, 0, len(menuOrder))
total := 0
for _, code := range menuOrder {
n := counts[code]
items = append(items, TodoItem{MenuCode: code, Count: n})
total += n
}
return TodoPayload{Items: items, Total: total}
}
func samePayload(a, b TodoPayload) bool {
if a.Total != b.Total || len(a.Items) != len(b.Items) {
return false
}
for i := range a.Items {
if a.Items[i] != b.Items[i] {
return false
}
}
return true
}
// pollAndBroadcast 与上次不同才推
func (h *Hub) pollAndBroadcast() {
cur := h.compute()
h.mu.Lock()
if samePayload(h.last, cur) {
h.mu.Unlock()
return
}
h.last = cur
h.mu.Unlock()
h.Broadcast(cur)
}
// Broadcast 向全部连接推送
func (h *Hub) Broadcast(p TodoPayload) {
data, _ := json.Marshal(p)
h.mu.Lock()
list := make([]*client, 0, len(h.clients))
for cl := range h.clients {
list = append(list, cl)
}
h.mu.Unlock()
for _, cl := range list {
if err := cl.write(websocket.TextMessage, data); err != nil {
h.remove(cl)
}
}
}
func (h *Hub) add(cl *client) {
h.mu.Lock()
h.clients[cl] = struct{}{}
h.mu.Unlock()
}
func (h *Hub) remove(cl *client) {
h.mu.Lock()
if _, ok := h.clients[cl]; ok {
delete(h.clients, cl)
_ = cl.conn.Close()
}
h.mu.Unlock()
}
// Serve WebSocket 端点:升级 → 先推一次全量 → ping/超时与读循环检测断线
func (h *Hub) Serve(w http.ResponseWriter, r *http.Request) {
conn, err := h.upgrader.Upgrade(w, r, nil)
if err != nil {
return
}
cl := &client{conn: conn}
conn.SetReadLimit(512)
_ = conn.SetReadDeadline(time.Now().Add(90 * time.Second))
conn.SetPongHandler(func(string) error {
return conn.SetReadDeadline(time.Now().Add(90 * time.Second))
})
h.add(cl)
defer h.remove(cl)
data, _ := json.Marshal(h.Snapshot())
if err := cl.write(websocket.TextMessage, data); err != nil {
return
}
done := make(chan struct{})
defer close(done)
go func() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
if err := cl.write(websocket.PingMessage, nil); err != nil {
return
}
case <-done:
return
}
}
}()
for {
if _, _, err := conn.ReadMessage(); err != nil {
return
}
}
}