物料 / 叫料
{{ badgeCount.material }}
@@ -373,7 +375,9 @@ function connectAlertStream() {
if (!stationNo.value || alertES) return
let everFailed = false // 断过线才在重连成功后补拉,平时事件即实时
try {
- alertES = new EventSource('/api/alerts/stream')
+ // 多会话版(2026-11-11):query 带本页登录的工位号,后端按工位过滤分发,
+ // 同一终端实例登录多个虚拟工位时各页面只收到自己工位的报警
+ alertES = new EventSource('/api/alerts/stream?stationNo=' + encodeURIComponent(stationNo.value))
alertES.addEventListener('station.alert', (e) => {
try {
handleAlerts([JSON.parse(e.data)])
diff --git a/bj_power_workstation/frontend/src/views/panels/InspectPanel.vue b/bj_power_workstation/frontend/src/views/panels/InspectPanel.vue
index 1441778..702e8ae 100644
--- a/bj_power_workstation/frontend/src/views/panels/InspectPanel.vue
+++ b/bj_power_workstation/frontend/src/views/panels/InspectPanel.vue
@@ -69,8 +69,16 @@
-
-
+
+
+
+
+ ④ 完工确认(扫序列号)
+
+ {{ missingChecks.length }}
+
+
+
@@ -86,8 +94,14 @@
-
-
+
+
+
+
+ ⑤ 应急呼叫
+ 1
+
+
@@ -204,11 +218,10 @@ import { computed, onMounted, ref, watch } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import PhotoField from './PhotoField.vue'
import { emergencyCall, listDocks, qtyReport, returnCancel, returnList, returnMaterial, returnReference, submitInspection } from '../../api'
-import { orderNo, sn as snState, stationNo, taskSteps, canReport } from '../../store/station'
+import { orderNo, sn as snState, stationNo, taskSteps, canReport, missingChecks, hasNg } from '../../store/station'
import { useScrollPaging } from '../../utils/scrollPaging'
const docks = ref([])
-
const active = ref(['checkin', 'point', 'process', 'done'])
const checkin = ref({ shift: '早', photo: '', remark: '' })
@@ -433,4 +446,12 @@ async function submitReturn() {
diff --git a/bj_power_workstation/frontend/src/views/panels/MaterialPanel.vue b/bj_power_workstation/frontend/src/views/panels/MaterialPanel.vue
index 2652ea9..084979a 100644
--- a/bj_power_workstation/frontend/src/views/panels/MaterialPanel.vue
+++ b/bj_power_workstation/frontend/src/views/panels/MaterialPanel.vue
@@ -86,10 +86,13 @@
叫料(一次提交=一个叫料包)
刷新池子
- 托盘回库
+ 托盘回库
+
+
@@ -234,7 +237,7 @@
diff --git a/bj_power_workstation/frontend/src/views/panels/WorkPanel.vue b/bj_power_workstation/frontend/src/views/panels/WorkPanel.vue
index 8f4a8ab..4605da1 100644
--- a/bj_power_workstation/frontend/src/views/panels/WorkPanel.vue
+++ b/bj_power_workstation/frontend/src/views/panels/WorkPanel.vue
@@ -191,7 +191,9 @@
- 检测确认(合格)
+
+ 检测确认(合格)
diff --git a/bj_power_workstation/internal/alertstream/alertstream.go b/bj_power_workstation/internal/alertstream/alertstream.go
index f24eaef..c7d6654 100644
--- a/bj_power_workstation/internal/alertstream/alertstream.go
+++ b/bj_power_workstation/internal/alertstream/alertstream.go
@@ -16,32 +16,32 @@ import (
"github.com/zeromicro/go-zero/core/logx"
)
-// Manager 工位报警事件流(谁受影响谁播报,2026-10-20 轮询改事件驱动):
+// Manager 工位报警事件流(谁受影响谁播报,2026-10-20 轮询改事件驱动;多会话版 2026-11-11):
// 后台长连接 MES GET /api/internal/station/alerts/stream(SSE,X-API-TOKEN 鉴权),
-// 只认 station.alert 事件;按本机固定工位号过滤「工位N」相关报警后,广播给本机前端订阅者。
+// 只认 station.alert 事件;按每个前端订阅方自带的工位号过滤「工位N」相关报警后分发
+// (一台终端实例可同时登录多个虚拟工位,各订阅方只收到自己工位的报警)。
// 断线自动重连(3 秒退避);前端断线重连后的一次性补拉走 GET /api/alerts/station(前端自己调)。
type Manager struct {
- mc *mes.Client
- stationNo int
+ mc *mes.Client
mu sync.Mutex
- clients map[chan string]struct{}
+ clients map[chan string]int // channel → 订阅方工位号(<=0 表示不过滤,全收)
}
-// New 新建报警流管理器。
-func New(mc *mes.Client, stationNo int) *Manager {
+// New 新建报警流管理器(多会话版:不再绑定单一固定工位)。
+func New(mc *mes.Client) *Manager {
return &Manager{
- mc: mc,
- stationNo: stationNo,
- clients: make(map[chan string]struct{}),
+ mc: mc,
+ clients: make(map[chan string]int),
}
}
-// Subscribe 本机前端订阅(每个 EventSource 连接一个 channel)。
-func (m *Manager) Subscribe() chan string {
+// Subscribe 本机前端订阅(每个 EventSource 连接一个 channel),stationNo 为订阅方工位号;
+// <=0 时不按工位过滤(兼容固定工位模式/未知来源),全部转发。
+func (m *Manager) Subscribe(stationNo int) chan string {
ch := make(chan string, 32)
m.mu.Lock()
- m.clients[ch] = struct{}{}
+ m.clients[ch] = stationNo
m.mu.Unlock()
return ch
}
@@ -59,7 +59,10 @@ func (m *Manager) Unsubscribe(ch chan string) {
func (m *Manager) broadcast(data string) {
m.mu.Lock()
defer m.mu.Unlock()
- for ch := range m.clients {
+ for ch, st := range m.clients {
+ if st > 0 && !mentionStation(data, st) {
+ continue // 只推给「工位N」相关订阅方(多会话:一台实例服务多工位互不串音)
+ }
select {
case ch <- data:
default: // 订阅者堆积(前端卡死)直接丢帧,下一条报警自然追上
@@ -67,12 +70,21 @@ func (m *Manager) broadcast(data string) {
}
}
-// Run 主循环:连 MES SSE → 解析分发 → 断线 3 秒重连,直到 ctx 取消。
-func (m *Manager) Run(ctx context.Context) {
- if m.stationNo <= 0 {
- logx.Errorf("报警事件流未启动:Station.StationNo=%d 无效", m.stationNo)
- return
+// mentionStation 判断报警 JSON 文本是否提及指定工位(target/content/title 含「工位N」)。
+func mentionStation(data string, stationNo int) bool {
+ var a alertPayload
+ if err := json.Unmarshal([]byte(data), &a); err != nil {
+ return false
}
+ tag := "工位" + strconv.Itoa(stationNo)
+ return strings.Contains(a.Target, tag) ||
+ strings.Contains(a.Content, tag) ||
+ strings.Contains(a.Title, tag)
+}
+
+// Run 主循环:连 MES SSE → 解析分发 → 断线 3 秒重连,直到 ctx 取消。
+// 多会话版:不再依赖固定工位号配置,未配置工位的终端(虚拟工位实例)也保持连接。
+func (m *Manager) Run(ctx context.Context) {
for {
select {
case <-ctx.Done():
@@ -96,8 +108,8 @@ func (m *Manager) runOnce(ctx context.Context) error {
return err
}
defer body.Close()
- logx.Infof("工位报警事件流已连接 MES(工位%d)", m.stationNo)
- defer logx.Infof("工位报警事件流连接关闭(工位%d)", m.stationNo)
+ logx.Infof("工位报警事件流已连接 MES")
+ defer logx.Infof("工位报警事件流连接关闭")
rd := bufio.NewReader(body)
event := ""
@@ -130,7 +142,7 @@ func (m *Manager) runOnce(ctx context.Context) error {
}
}
-// dispatch 解析报警 JSON,命中本工位(target/content/title 含「工位N」)才广播。
+// dispatch 解析 MES 报警事件(station.alert),交给 broadcast 按订阅方工位分发。
type alertPayload struct {
ID int `json:"id"`
Type string `json:"type"`
@@ -145,11 +157,5 @@ func (m *Manager) dispatch(data string) {
if err := json.Unmarshal([]byte(data), &a); err != nil {
return
}
- hit := strings.Contains(a.Target, "工位"+strconv.Itoa(m.stationNo)) ||
- strings.Contains(a.Content, "工位"+strconv.Itoa(m.stationNo)) ||
- strings.Contains(a.Title, "工位"+strconv.Itoa(m.stationNo))
- if !hit {
- return
- }
m.broadcast(data)
}
diff --git a/bj_power_workstation/internal/auth/jwt.go b/bj_power_workstation/internal/auth/jwt.go
index d0065f8..2bd41d9 100644
--- a/bj_power_workstation/internal/auth/jwt.go
+++ b/bj_power_workstation/internal/auth/jwt.go
@@ -11,31 +11,35 @@ import (
)
// Claims 自定义 JWT 声明
+// StationNo 与 MES tokenx.Claims 同名同 tag(stationNo):终端解析 MES 签发的工位登录 JWT
+// 时带出工位号,滑动续签本地重签时原样保留(MES StationSessionAuth 据此取工位)。
type Claims struct {
- UserID int64 `json:"userId"`
- Username string `json:"username"`
- RealName string `json:"realName"`
- Role string `json:"role"`
+ UserID int64 `json:"userId"`
+ Username string `json:"username"`
+ RealName string `json:"realName"`
+ Role string `json:"role"`
+ StationNo int `json:"stationNo,omitempty"`
jwt.RegisteredClaims
}
// TokenInfo 签发 token 所需的用户信息
type TokenInfo struct {
- UserID int64
- Username string
- RealName string
- Role string
+ UserID int64
+ Username string
+ RealName string
+ Role string
+ StationNo int
}
const issuer = "bj_power_workstation"
-// SessionValidator 由 main 注入:校验请求 token 是否仍是当前有效登录会话
-// (与 station_session.token 比对,实现「后登录踢前一个」)。nil 时跳过该校验。
+// SessionValidator 由 main 注入:校验请求 token 是否存在于任一有效登录会话
+// (多会话版:同工位互踢后旧 token 不再命中任何会话,即被判为已下线)。nil 时跳过该校验。
var SessionValidator func(token string) bool
-// SessionTokenSync 由 main 注入:滑动续签重签出新 token 时同步写回当前登录会话,
+// SessionTokenSync 由 main 注入:滑动续签重签出新 token 时按旧 token 定位会话同步写回,
// 保证前端 token 与会话 token 始终一致,避免续签后被误判为旧会话。
-var SessionTokenSync func(token string)
+var SessionTokenSync func(oldToken, newToken string)
func defaultExpire(expire int64) int64 {
if expire <= 0 {
@@ -48,10 +52,11 @@ func defaultExpire(expire int64) int64 {
func SignToken(secret string, expire int64, info TokenInfo) (string, int64, error) {
exp := time.Now().Add(time.Duration(defaultExpire(expire)) * time.Second)
claims := &Claims{
- UserID: info.UserID,
- Username: info.Username,
- RealName: info.RealName,
- Role: info.Role,
+ UserID: info.UserID,
+ Username: info.Username,
+ RealName: info.RealName,
+ Role: info.Role,
+ StationNo: info.StationNo,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(exp),
IssuedAt: jwt.NewNumericDate(time.Now()),
@@ -81,20 +86,22 @@ func ParseToken(secret, tokenStr string) (*Claims, error) {
return claims, nil
}
-// renewIfNearExpiry 滑动续签:剩余有效期不足一半时重签,写入响应头 X-Renewed-Token
-func renewIfNearExpiry(secret string, expire int64, w http.ResponseWriter, claims *Claims) {
+// renewIfNearExpiry 滑动续签:剩余有效期不足一半时重签,写入响应头 X-Renewed-Token。
+// 多会话版:按请求旧 token 定位会话同步更新(SessionTokenSync(old, new))。
+func renewIfNearExpiry(secret string, expire int64, w http.ResponseWriter, claims *Claims, oldToken string) {
remaining := time.Until(claims.ExpiresAt.Time)
if remaining > 0 && remaining < time.Duration(defaultExpire(expire))*time.Second/2 {
if newToken, _, err := SignToken(secret, expire, TokenInfo{
- UserID: claims.UserID,
- Username: claims.Username,
- RealName: claims.RealName,
- Role: claims.Role,
+ UserID: claims.UserID,
+ Username: claims.Username,
+ RealName: claims.RealName,
+ Role: claims.Role,
+ StationNo: claims.StationNo,
}); err == nil {
w.Header().Set("X-Renewed-Token", newToken)
- // 前端会据此更新本地 token,同步写回会话,保证两者始终一致。
+ // 前端会据此更新本地 token,同步写回对应会话,保证两者始终一致。
if SessionTokenSync != nil {
- SessionTokenSync(newToken)
+ SessionTokenSync(oldToken, newToken)
}
}
}
@@ -108,8 +115,10 @@ func unauthorized(w http.ResponseWriter, msg string) {
}
// Interceptor 登录鉴权中间件。
-// 白名单:/api/health、/api/auth/login、/pdfopen/*。
+// 白名单:/api/health、/api/auth/login、/api/alerts/stream、/pdfopen/*。
// 非 /api/ 且非 /pdfopen/ 的路径为前端静态资源,直接放行。
+// 2026-11-11 修复:补上 /api/alerts/stream(工位报警 SSE)——EventSource 无法携带 JWT,
+// 此前中间件白名单缺这一条,SSE 一直被 401 拦截(与 routes.go 注册白名单不一致)。
func Interceptor(secret string, accessExpire int64) func(next http.HandlerFunc) http.HandlerFunc {
return func(next http.HandlerFunc) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -120,6 +129,7 @@ func Interceptor(secret string, accessExpire int64) func(next http.HandlerFunc)
path == "/api/auth/login" ||
path == "/api/config" ||
path == "/api/station-options" ||
+ path == "/api/alerts/stream" ||
strings.HasPrefix(path, "/pdfopen/")
if notAPI || whitelisted {
next.ServeHTTP(w, r)
@@ -137,13 +147,14 @@ func Interceptor(secret string, accessExpire int64) func(next http.HandlerFunc)
unauthorized(w, "登录已失效")
return
}
- // 在线态校验(后登录踢前一个):请求 token 必须与当前登录会话一致。
+ // 在线态校验(多会话版):请求 token 必须存在于任一登录会话;
+ // 同工位被新登录踢掉后旧 token 不再命中任何会话,即被判为已下线。
// 白名单与静态资源已在上方放行,不会被此处拦截。
if SessionValidator != nil && !SessionValidator(tokenStr) {
- unauthorized(w, "已在其他设备登录,请重新登录")
+ unauthorized(w, "登录已失效或工位已被其他人员登录,请重新登录")
return
}
- renewIfNearExpiry(secret, accessExpire, w, claims)
+ renewIfNearExpiry(secret, accessExpire, w, claims, tokenStr)
r.Header.Set("X-Username", claims.Username)
next.ServeHTTP(w, r)
})
diff --git a/bj_power_workstation/internal/handler/alerts_stream.go b/bj_power_workstation/internal/handler/alerts_stream.go
index 4a761b0..afe5b2c 100644
--- a/bj_power_workstation/internal/handler/alerts_stream.go
+++ b/bj_power_workstation/internal/handler/alerts_stream.go
@@ -3,14 +3,16 @@ package handler
import (
"fmt"
"net/http"
+ "strings"
"time"
"bj_power_workstation/internal/svc"
)
-// alertsStreamHandler GET /api/alerts/stream(本机 SSE,免鉴权)
+// alertsStreamHandler GET /api/alerts/stream?stationNo=N(本机 SSE,免鉴权)
// 终端前端 EventSource 订阅本端点(同源、EventSource 无法携带 JWT,故走免鉴权组;
-// 数据已经 alertstream.Manager 按本机固定工位号过滤,仅本机 LAN 可达,敏感度低)。
+// 仅本机 LAN 可达,敏感度低)。多会话版(2026-11-11):query 带订阅方工位号,
+// 后端按工位过滤后分发——同一终端实例登录多个虚拟工位时,各页面只收到自己工位的报警。
// 收到 MES station.alert 即转发;15 秒心跳注释行防空闲断链;前端断开由 r.Context().Done() 感知。
func alertsStreamHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
@@ -22,7 +24,8 @@ func alertsStreamHandler(ctx *svc.ServiceContext) http.HandlerFunc {
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Connection", "keep-alive")
- ch := ctx.AlertStream.Subscribe()
+ stationNo := atoi(strings.TrimSpace(r.URL.Query().Get("stationNo")), 0)
+ ch := ctx.AlertStream.Subscribe(stationNo)
defer ctx.AlertStream.Unsubscribe(ch)
fl.Flush()
ticker := time.NewTicker(15 * time.Second)
diff --git a/bj_power_workstation/internal/handler/auth.go b/bj_power_workstation/internal/handler/auth.go
index 7da3329..d1018ec 100644
--- a/bj_power_workstation/internal/handler/auth.go
+++ b/bj_power_workstation/internal/handler/auth.go
@@ -46,10 +46,18 @@ func loginHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "用户名和密码必填")
return
}
- // 2026-11-09 拍板:配置固定工位(>0)时忽略前端传值、强制用配置工位(防串位);
- // 未配置(<=0)时接受前端选择的工位(实体+虚拟 0/13 都可选,MES 端对 <=0 免工位权限校验)。
+ // 2026-11-09 拍板:配置固定工位(>0)时忽略前端传值、强制用配置工位(防串位)。
+ // 2026-11-11 多会话拍板:未配置(<=0)的终端实例(虚拟工位专用机)只允许登录虚拟工位,
+ // 拒绝实体工位(后端硬校验防前端绕过;校验依据 MES 工位清单 stationType=OFFLINE)。
if ctx.Config.Station.StationNo > 0 {
req.StationNo = ctx.Config.Station.StationNo
+ } else {
+ virtual, vErr := isVirtualStation(ctx, req.StationNo)
+ if vErr == nil && !virtual {
+ fail(w, http.StatusForbidden, "本终端未配置固定工位,仅允许登录虚拟工位")
+ return
+ }
+ // vErr != nil:工位清单拉取失败,放行走登录链路(登录本身也依赖 MES,不可达时自然失败)
}
body, _, err := ctx.Mes.Post("/api/internal/station/login", map[string]any{
@@ -84,22 +92,17 @@ func loginHandler(ctx *svc.ServiceContext) http.HandlerFunc {
} `json:"data"`
}
if err := json.Unmarshal(body, &loginResp); err == nil && loginResp.Data.AccessToken != "" {
- // 后登录踢前一个:若已存在不同 token 的旧会话,先通知 MES 记录旧会话登出(尽力而为),
- // 随后用新会话覆盖本地单行登录态;旧端下一次请求因 token 与会话不一致被 401 踢下线。
- if old, oerr := ctx.Store.GetStationSession(); oerr == nil && old != nil &&
- old.Token != "" && old.Token != loginResp.Data.AccessToken {
+ // 多会话(2026-11-11):同工位只允许一个会话——该工位已有会话则先踢旧会话
+ //(ReplaceStationSession 返回被踢者),通知 MES 记录旧会话登出(尽力而为);
+ // 不同工位会话互不影响。被踢端下一次请求因 token 不在会话表中被 401 踢下线,
+ // 其本地记录随会话删除;工位物料/工件信息在 MES 侧按工位号存,不随会话删除。
+ kicked, serr := ctx.Store.SaveStationSession(loginResp.Data.AccessToken, loginResp.Data.User.Username,
+ loginResp.Data.User.Name, loginResp.Data.StationNo, loginResp.Data.ExpireAt, userIDOf(ctx, loginResp.Data.AccessToken))
+ if serr == nil && kicked != nil && kicked.Token != "" {
go func(u string, n int) {
_, _, _ = ctx.Mes.Post("/api/internal/station/logout", map[string]any{"username": u, "stationNo": n})
- }(old.Username, old.StationNo)
+ }(kicked.Username, kicked.StationNo)
}
- // 解析 MES JWT 取出用户 ID,随登录态保存:离线数据落库 operator_id(按操作人隔离发送)
- userID := int64(0)
- if claims, perr := auth.ParseToken(ctx.Config.Auth.AccessSecret, loginResp.Data.AccessToken); perr == nil {
- userID = claims.UserID
- }
- _ = ctx.Store.SaveStationSession(loginResp.Data.AccessToken, loginResp.Data.User.Username,
- loginResp.Data.User.Name, loginResp.Data.StationNo, loginResp.Data.ExpireAt, userID)
- ctx.Mes.SetStationToken(loginResp.Data.AccessToken)
// 拧紧枪配置快照补报(2026-11-09):仅 MES 展示记录,不参与数据收集;
// 启动时若 MES 未就绪,登录这一刻补上,失败只记日志不影响登录。
go func(no int) {
@@ -117,6 +120,43 @@ func loginHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
+// isVirtualStation 查询 MES 工位清单判断工位号是否虚拟工位(stationType=OFFLINE)。
+// 多会话拍板(2026-11-11):未配置固定工位的终端实例只允许登录虚拟工位。
+func isVirtualStation(ctx *svc.ServiceContext, stationNo int) (bool, error) {
+ if stationNo <= 0 {
+ return false, nil // 0/负数不是合法工位(原 0 号上线位已废弃)
+ }
+ body, _, err := ctx.Mes.Get("/api/internal/station/options", nil)
+ if err != nil {
+ return false, err
+ }
+ var opts struct {
+ Code int `json:"code"`
+ Data []struct {
+ StationNo int `json:"stationNo"`
+ Name string `json:"name"`
+ StationType string `json:"stationType"`
+ } `json:"data"`
+ }
+ if err := json.Unmarshal(body, &opts); err != nil {
+ return false, err
+ }
+ for _, o := range opts.Data {
+ if o.StationNo == stationNo {
+ return o.StationType == "OFFLINE", nil
+ }
+ }
+ return false, nil
+}
+
+// userIDOf 解析 MES JWT 取用户 ID(随登录态保存,离线数据落库 operator_id)。
+func userIDOf(ctx *svc.ServiceContext, token string) int64 {
+ if claims, err := auth.ParseToken(ctx.Config.Auth.AccessSecret, token); err == nil {
+ return claims.UserID
+ }
+ return 0
+}
+
// logoutHandler POST /api/station/logout 退出登录:转发 MES 记录"工位终端退出"操作日志。
// MES 不可达时静默忽略(日志不阻塞本地退出)。
func logoutHandler(ctx *svc.ServiceContext) http.HandlerFunc {
@@ -126,9 +166,16 @@ func logoutHandler(ctx *svc.ServiceContext) http.HandlerFunc {
StationNo int `json:"stationNo"`
}
_ = parseJSON(r, &req)
+ // 多会话版(2026-11-11):按请求 Bearer 定位自己的会话,只删自己那一行,不影响其他工位会话。
+ token := bearerOf(r)
+ ss, _ := ctx.Store.GetStationSessionByToken(token)
username := strings.TrimSpace(req.Username)
+ no := req.StationNo
+ if ss != nil {
+ username = ss.Username
+ no = ss.StationNo
+ }
if username != "" {
- no := req.StationNo
if no <= 0 {
no = ctx.Config.Station.StationNo
}
@@ -136,9 +183,8 @@ func logoutHandler(ctx *svc.ServiceContext) http.HandlerFunc {
_, _, _ = ctx.Mes.Post("/api/internal/station/logout", map[string]any{"username": u, "stationNo": n})
}(username, no)
}
- // 方案 B:退出即清除本地登录态与 Bearer 凭证
- _ = ctx.Store.ClearStationSession()
- ctx.Mes.SetStationToken("")
+ // 方案 B:退出即清除自己的本地登录态(多会话:仅本会话行)
+ _ = ctx.Store.ClearSessionByToken(token)
ok(w, map[string]any{"ok": true})
}
}
@@ -148,7 +194,8 @@ func logoutHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// 由前端根组件全局事件监听(click/touchstart/keydown/scroll 捕获阶段)调用,节流由前端控制。
func touchHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- if err := ctx.Store.TouchStationSession(); err != nil {
+ // 多会话版:按请求 Bearer 只刷当前会话的空闲计时
+ if err := ctx.Store.TouchSessionByToken(bearerOf(r)); err != nil {
fail(w, http.StatusInternalServerError, "刷新登录态失败:"+err.Error())
return
}
@@ -158,15 +205,17 @@ func touchHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// refreshTokenHandler POST /api/auth/refresh-token 滑动续签 Bearer:
// 用当前有效 MES JWT 向 MES 换取新签发的 JWT(延长有效期),避免作业中令牌过期被登出。
-// 前置 Interceptor 已校验前端登录态;此处再代理 MES 刷新并回写本地 Bearer。
+// 前置 Interceptor 已校验前端登录态;此处再代理 MES 刷新。
+// 多会话版(2026-11-11):按请求 Bearer 只续签本会话。
func refreshTokenHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- ss, err := ctx.Store.GetStationSession()
+ token := bearerOf(r)
+ ss, err := ctx.Store.GetStationSessionByToken(token)
if err != nil || ss == nil || ss.Token == "" {
fail(w, http.StatusUnauthorized, "未登录或登录态已失效")
return
}
- respBody, _, err := ctx.Mes.Post("/api/internal/station/refresh-token", nil)
+ respBody, _, err := ctx.Mes.Post("/api/internal/station/refresh-token", nil, token)
if err != nil {
fail(w, http.StatusUnauthorized, "MES 续签失败:"+errString(err))
return
@@ -175,13 +224,12 @@ func refreshTokenHandler(ctx *svc.ServiceContext) http.HandlerFunc {
Code int `json:"code"`
Data struct {
AccessToken string `json:"accessToken"`
- ExpireAt int64 `json:"expireAt"`
+ ExpireAt int64 `json:"expireAt"`
} `json:"data"`
}
if err := json.Unmarshal(respBody, &rr); err == nil && rr.Data.AccessToken != "" {
- // 只更新转发 MES 用的 Bearer;本地会话 token 保持与前端一致,
- // 由滑动续签的 X-Renewed-Token + SessionTokenSync 同步,避免前后端 token 不一致被误判为旧会话。
- ctx.Mes.SetStationToken(rr.Data.AccessToken)
+ // MES 重签 token 仅作响应回执(前端当前不消费);本地会话 token 与前端保持一致,
+ // 由滑动续签的 X-Renewed-Token + SessionTokenSync(old,new) 同步,避免前后端 token 不一致被误判。
ok(w, map[string]any{"accessToken": rr.Data.AccessToken, "expireAt": rr.Data.ExpireAt})
return
}
diff --git a/bj_power_workstation/internal/handler/bind.go b/bj_power_workstation/internal/handler/bind.go
index 8f03e4c..e0673e9 100644
--- a/bj_power_workstation/internal/handler/bind.go
+++ b/bj_power_workstation/internal/handler/bind.go
@@ -51,7 +51,7 @@ func bindRecordHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "sn / flowId 必填")
return
}
- body, _, err := ctx.Mes.Post("/api/internal/workpiece/binds", json.RawMessage(payload))
+ body, _, err := ctx.Mes.Post("/api/internal/workpiece/binds", json.RawMessage(payload), bearerOf(r))
if err != nil {
fail(w, http.StatusBadGateway, "MES 服务不可达:"+errString(err))
return
@@ -70,7 +70,7 @@ func bindRemoveHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "请求体读取失败")
return
}
- body, _, err := ctx.Mes.Post("/api/internal/workpiece/binds/remove", json.RawMessage(payload))
+ body, _, err := ctx.Mes.Post("/api/internal/workpiece/binds/remove", json.RawMessage(payload), bearerOf(r))
if err != nil {
fail(w, http.StatusBadGateway, "MES 服务不可达:"+errString(err))
return
diff --git a/bj_power_workstation/internal/handler/common.go b/bj_power_workstation/internal/handler/common.go
index 8cab7de..a13d48e 100644
--- a/bj_power_workstation/internal/handler/common.go
+++ b/bj_power_workstation/internal/handler/common.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"net/http"
"strconv"
+ "strings"
)
// parseJSON 解析请求体 JSON,失败返回错误。
@@ -32,6 +33,13 @@ func currentUsername(r *http.Request) string {
return r.Header.Get("X-Username")
}
+// bearerOf 取当前请求的工位登录 JWT(多会话版,2026-11-11):
+// token 即会话身份——转发 MES 时透传该 JWT(Bearer),MES 据 claims 认操作人/工位;
+// 终端本地也据此定位该请求对应的登录会话(操作人/工位号)。
+func bearerOf(r *http.Request) string {
+ return strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+}
+
// errString 压缩错误信息长度便于前端展示。
func errString(err error) string {
s := err.Error()
diff --git a/bj_power_workstation/internal/handler/line.go b/bj_power_workstation/internal/handler/line.go
index a00445b..ccbceec 100644
--- a/bj_power_workstation/internal/handler/line.go
+++ b/bj_power_workstation/internal/handler/line.go
@@ -54,7 +54,7 @@ func lineOccupyHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
body, _ := json.Marshal(req)
- resp, _, err := ctx.Mes.Post("/api/internal/line/occupy", json.RawMessage(body))
+ resp, _, err := ctx.Mes.Post("/api/internal/line/occupy", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, err)
}
}
@@ -96,7 +96,7 @@ func callCreateHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
body, _ := json.Marshal(req)
- resp, _, err := ctx.Mes.Post("/api/internal/call/create", json.RawMessage(body))
+ resp, _, err := ctx.Mes.Post("/api/internal/call/create", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, err)
}
}
@@ -163,7 +163,7 @@ func palletReturnHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
}
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/dock/pallet-return", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/dock/pallet-return", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -219,7 +219,7 @@ func callStateHandler(ctx *svc.ServiceContext, mesPath, action string) http.Hand
}
}
body, _ := json.Marshal(req)
- resp, _, err := ctx.Mes.Post(mesPath, json.RawMessage(body))
+ resp, _, err := ctx.Mes.Post(mesPath, json.RawMessage(body), bearerOf(r))
if err != nil {
fail(w, http.StatusBadGateway, action+"失败:MES 不可达")
return
diff --git a/bj_power_workstation/internal/handler/plc_mismatch.go b/bj_power_workstation/internal/handler/plc_mismatch.go
index 0b4d3c6..ce1def0 100644
--- a/bj_power_workstation/internal/handler/plc_mismatch.go
+++ b/bj_power_workstation/internal/handler/plc_mismatch.go
@@ -20,7 +20,7 @@ func plcMismatchCheckHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "请求体读取失败")
return
}
- respBody, _, err := ctx.Mes.Post("/api/internal/plc/mismatch/check", json.RawMessage(payload))
+ respBody, _, err := ctx.Mes.Post("/api/internal/plc/mismatch/check", json.RawMessage(payload), bearerOf(r))
if err != nil {
// 查询类静默降级(2026-11-08):仍不拦作业,但必须落本地操作日志留痕
logx.Errorf("PLC↔MES 对账检查 MES 不可达,静默跳过: %v", err)
diff --git a/bj_power_workstation/internal/handler/proxy.go b/bj_power_workstation/internal/handler/proxy.go
index dba7897..640993f 100644
--- a/bj_power_workstation/internal/handler/proxy.go
+++ b/bj_power_workstation/internal/handler/proxy.go
@@ -107,7 +107,7 @@ func stationPauseHandler(ctx *svc.ServiceContext) http.HandlerFunc {
_ = json.Unmarshal(payload, &req)
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/pause", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/pause", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
diff --git a/bj_power_workstation/internal/handler/report.go b/bj_power_workstation/internal/handler/report.go
index 08c0fae..e888dc1 100644
--- a/bj_power_workstation/internal/handler/report.go
+++ b/bj_power_workstation/internal/handler/report.go
@@ -84,9 +84,10 @@ func processDoneHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return
}
- // 方案 B:操作人取自工位登录态可信身份,忽略浏览器请求体里的 operator(防冒名)
+ // 方案 B(多会话版):操作人取自当前请求 Bearer 对应的登录会话(token 即身份),
+ // 忽略浏览器请求体里的 operator(防冒名)
op := req.Operator
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.Name != "" {
+ if ss, sErr := ctx.Store.GetStationSessionByToken(bearerOf(r)); sErr == nil && ss != nil && ss.Name != "" {
op = ss.Name
}
@@ -111,7 +112,7 @@ func processDoneHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
payloadBytes, _ := json.Marshal(body)
- respBody, _, err := ctx.Mes.Post("/api/internal/station/report", json.RawMessage(payloadBytes))
+ respBody, _, err := ctx.Mes.Post("/api/internal/station/report", json.RawMessage(payloadBytes), bearerOf(r))
if err != nil {
// MES 业务拒绝(HTTP200+code≠0,如装配物料未绑齐/需签字确认/不可倒序报工):
// 数据本身不合法,原样重传不可能成功——直接失败回前端,绝不入离线队。
@@ -171,9 +172,9 @@ func tempStoreHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return
}
- // 方案 B:操作人取自工位登录态可信身份,忽略浏览器请求体里的 operator(防冒名)
+ // 方案 B(多会话版):操作人取自当前请求 Bearer 对应的登录会话(token 即身份,防冒名)
op := req.Operator
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.Name != "" {
+ if ss, sErr := ctx.Store.GetStationSessionByToken(bearerOf(r)); sErr == nil && ss != nil && ss.Name != "" {
op = ss.Name
}
@@ -186,7 +187,7 @@ func tempStoreHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
payloadBytes, _ := json.Marshal(body)
- respBody, _, err := ctx.Mes.Post("/api/internal/station/checkin", json.RawMessage(payloadBytes))
+ respBody, _, err := ctx.Mes.Post("/api/internal/station/checkin", json.RawMessage(payloadBytes), bearerOf(r))
if err != nil {
// MES 业务拒绝(HTTP200+code≠0):数据不合法重传不可能成功,直接失败回前端不入队
var bizErr *mes.BizError
@@ -247,14 +248,14 @@ func scrapHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "报废/取走原因必填")
return
}
- // 操作人取工位登录态可信身份(防冒名),与暂存退库同口径
+ // 操作人取当前请求 Bearer 对应登录会话的可信身份(防冒名),与暂存退库同口径
op := req.Operator
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.Name != "" {
+ if ss, sErr := ctx.Store.GetStationSessionByToken(bearerOf(r)); sErr == nil && ss != nil && ss.Name != "" {
op = ss.Name
}
body := map[string]any{"sn": req.Sn, "reason": req.Reason}
payloadBytes, _ := json.Marshal(body)
- respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/scrap?operator="+url.QueryEscape(op), json.RawMessage(payloadBytes))
+ respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/scrap?operator="+url.QueryEscape(op), json.RawMessage(payloadBytes), bearerOf(r))
if err != nil {
var bizErr *mes.BizError
if errors.As(err, &bizErr) {
@@ -285,12 +286,9 @@ func scrapHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// 工位号来源:登录会话优先(登录页可选工位),否则取 yaml 固定工位号。
func mesConfigHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- stationNo := ctx.Config.Station.StationNo
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.StationNo > 0 {
- stationNo = ss.StationNo
- }
+ stationNo := stationNoOf(ctx, r)
q := url.Values{"stationNo": {strconv.Itoa(stationNo)}}
- b, _, err := ctx.Mes.Get("/api/internal/public-config", q)
+ b, _, err := ctx.Mes.Get("/api/internal/public-config", q, bearerOf(r))
if err != nil {
fail(w, http.StatusBadGateway, "MES 不可达,配置获取失败")
return
diff --git a/bj_power_workstation/internal/handler/station_alerts.go b/bj_power_workstation/internal/handler/station_alerts.go
index 611a951..66d9b9f 100644
--- a/bj_power_workstation/internal/handler/station_alerts.go
+++ b/bj_power_workstation/internal/handler/station_alerts.go
@@ -25,7 +25,7 @@ func stationAlertsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
body, _, err := ctx.Mes.Get("/api/internal/station/alerts", url.Values{
"stationNo": {strconv.Itoa(stationNo)},
"minutes": {strconv.Itoa(minutes)},
- })
+ }, bearerOf(r))
if err != nil {
// 查询类静默降级(2026-11-08):仍返回空不刷屏,但必须落本地操作日志留痕,不再无声吞掉
logx.Errorf("工位报警查询 MES 不可达,静默跳过: %v", err)
diff --git a/bj_power_workstation/internal/handler/station_ops.go b/bj_power_workstation/internal/handler/station_ops.go
index d26d349..43fc760 100644
--- a/bj_power_workstation/internal/handler/station_ops.go
+++ b/bj_power_workstation/internal/handler/station_ops.go
@@ -33,7 +33,7 @@ func inspectionSubmitHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/inspection", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/inspection", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -54,7 +54,7 @@ func emergencyCallHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/emergency", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/emergency", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -79,7 +79,7 @@ func qtyReportHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/qty-report", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/qty-report", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -108,7 +108,7 @@ func returnMaterialHandler(ctx *svc.ServiceContext) http.HandlerFunc {
}
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/return-material", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/return-material", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -116,8 +116,8 @@ func returnMaterialHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// stationReturnListHandler GET /api/return-list —— 工位终端「我的退料单」列表(PENDING 可取消)。
func stationReturnListHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- stationNo := stationNoFromRequest(ctx)
- resp, _, perr := ctx.Mes.Get("/api/internal/station/return-list?stationNo="+strconv.Itoa(stationNo), nil)
+ stationNo := stationNoOf(ctx, r)
+ resp, _, perr := ctx.Mes.Get("/api/internal/station/return-list?stationNo="+strconv.Itoa(stationNo), nil, bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -140,10 +140,10 @@ func stationReturnCancelHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "returnNo 必填")
return
}
- req["stationNo"] = stationNoFromRequest(ctx)
+ req["stationNo"] = stationNoOf(ctx, r)
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/return-cancel", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/return-cancel", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -152,8 +152,8 @@ func stationReturnCancelHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// 工位终端余量参考值(剩余余量=应剩余量−已退余量−已损耗;仅展示不阻断提交)。
func stationReturnReferenceHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- stationNo := stationNoFromRequest(ctx)
- resp, _, perr := ctx.Mes.Get("/api/internal/station/return-reference?stationNo="+strconv.Itoa(stationNo), nil)
+ stationNo := stationNoOf(ctx, r)
+ resp, _, perr := ctx.Mes.Get("/api/internal/station/return-reference?stationNo="+strconv.Itoa(stationNo), nil, bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -161,8 +161,8 @@ func stationReturnReferenceHandler(ctx *svc.ServiceContext) http.HandlerFunc {
// shiftGetHandler GET /api/shift —— 当前班次状态(退出登录前提示「未下班」用,2026-11-03 下班闭环)。
func shiftGetHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
- stationNo := stationNoFromRequest(ctx)
- resp, _, perr := ctx.Mes.Get("/api/internal/station/shift?stationNo="+strconv.Itoa(stationNo), nil)
+ stationNo := stationNoOf(ctx, r)
+ resp, _, perr := ctx.Mes.Get("/api/internal/station/shift?stationNo="+strconv.Itoa(stationNo), nil, bearerOf(r))
mesJSON(w, resp, perr)
}
}
@@ -181,21 +181,23 @@ func offDutyHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "请求体解析失败")
return
}
- req["stationNo"] = stationNoFromRequest(ctx)
+ req["stationNo"] = stationNoOf(ctx, r)
injectOperator(req, r)
body, _ := json.Marshal(req)
- resp, _, perr := ctx.Mes.Post("/api/internal/station/off-duty", json.RawMessage(body))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/off-duty", json.RawMessage(body), bearerOf(r))
mesJSON(w, resp, perr)
}
}
-// stationNoFromRequest 业务工位号(2026-11-09 拍板):配置固定工位(>0)直接用配置;
-// 未配置(<=0,登录页选择)时回退登录会话保存的实际工位号(登录响应 stationNo 落 SQLite session)。
-func stationNoFromRequest(ctx *svc.ServiceContext) int {
+// stationNoOf 业务工位号(2026-11-09 拍板;多会话版 2026-11-11 改按请求定位):
+// 配置固定工位(>0)直接用配置;未配置(<=0,登录页选择)时按请求 Bearer 定位登录会话,
+// 取该会话绑定的实际工位号(登录响应 stationNo 落 SQLite session)。
+// 多会话下同一实例可同时登录多个工位,工位号必须随请求走,不能再用全局会话。
+func stationNoOf(ctx *svc.ServiceContext, r *http.Request) int {
if ctx.Config.Station.StationNo > 0 {
return ctx.Config.Station.StationNo
}
- if ss, err := ctx.Store.GetStationSession(); err == nil && ss != nil {
+ if ss, err := ctx.Store.GetStationSessionByToken(bearerOf(r)); err == nil && ss != nil {
return ss.StationNo
}
return 0
@@ -210,7 +212,7 @@ func inspectionUploadHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "请求体读取失败")
return
}
- resp, _, perr := ctx.Mes.Post("/api/internal/station/inspection-upload", json.RawMessage(payload))
+ resp, _, perr := ctx.Mes.Post("/api/internal/station/inspection-upload", json.RawMessage(payload), bearerOf(r))
mesJSON(w, resp, perr)
}
}
diff --git a/bj_power_workstation/internal/handler/tightening.go b/bj_power_workstation/internal/handler/tightening.go
index 6fdf668..40768aa 100644
--- a/bj_power_workstation/internal/handler/tightening.go
+++ b/bj_power_workstation/internal/handler/tightening.go
@@ -55,16 +55,16 @@ func tighteningRecordHandler(ctx *svc.ServiceContext) http.HandlerFunc {
if req.Result != "NG" {
req.Result = "OK"
}
- // 方案 B:操作人取自工位登录态可信身份,忽略浏览器请求体里的 operator(防冒名)
- ss, _ := ctx.Store.GetStationSession()
+ // 方案 B(多会话版):操作人取自当前请求 Bearer 对应的登录会话(token 即身份,防冒名)
+ ss, _ := ctx.Store.GetStationSessionByToken(bearerOf(r))
op := req.Operator
if ss != nil && ss.Name != "" {
op = ss.Name
}
// 拧紧域工位标签载体:DOCK%02d 由业务工位号生成(与接驳台 dock 表编码无关),
// MES 侧按 stationNo(数字工位号)落库并做应拧/实拧分组统计。
- // 2026-11-09:选择模式(配置<=0)用登录会话工位(stationNoFromRequest 统一口径)。
- bizStationNo := stationNoFromRequest(ctx)
+ // 2026-11-09:选择模式(配置<=0)用登录会话工位;2026-11-11 多会话:按请求定位。
+ bizStationNo := stationNoOf(ctx, r)
dockCode := fmt.Sprintf("DOCK%02d", bizStationNo)
body := map[string]any{
"workOrderNo": req.WorkOrderNo,
@@ -79,7 +79,7 @@ func tighteningRecordHandler(ctx *svc.ServiceContext) http.HandlerFunc {
"result": req.Result,
"operator": op,
}
- if _, _, err := ctx.Mes.Post("/api/internal/torque/report", body); err != nil {
+ if _, _, err := ctx.Mes.Post("/api/internal/torque/report", body, bearerOf(r)); err != nil {
var bizErr *mes.BizError
if errors.As(err, &bizErr) {
msg := mesRespCode(bizErr.Body)
diff --git a/bj_power_workstation/internal/handler/workpiece.go b/bj_power_workstation/internal/handler/workpiece.go
index cab73f3..949df26 100644
--- a/bj_power_workstation/internal/handler/workpiece.go
+++ b/bj_power_workstation/internal/handler/workpiece.go
@@ -119,16 +119,16 @@ func onlineHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "缺少 sn")
return
}
- // 操作人取工位登录态可信身份(防冒名),仅用于本地操作日志落痕
+ // 操作人取当前请求 Bearer 对应登录会话的可信身份(防冒名 · 多会话版),仅用于本地操作日志落痕
opName := req.Operator
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.Name != "" {
+ if ss, sErr := ctx.Store.GetStationSessionByToken(bearerOf(r)); sErr == nil && ss != nil && ss.Name != "" {
opName = ss.Name
}
q := url.Values{}
if req.Operator != "" {
q.Set("operator", req.Operator)
}
- respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/online?"+q.Encode(), json.RawMessage(payload))
+ respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/online?"+q.Encode(), json.RawMessage(payload), bearerOf(r))
if err != nil {
// MES 业务拒绝(HTTP200+code≠0):数据不合法,直接失败回前端
var bizErr *mes.BizError
@@ -181,16 +181,16 @@ func doneHandler(ctx *svc.ServiceContext) http.HandlerFunc {
fail(w, http.StatusBadRequest, "缺少 sn")
return
}
- // 操作人取工位登录态可信身份(防冒名),仅用于本地操作日志落痕
+ // 操作人取当前请求 Bearer 对应登录会话的可信身份(防冒名 · 多会话版),仅用于本地操作日志落痕
opName := req.Operator
- if ss, sErr := ctx.Store.GetStationSession(); sErr == nil && ss != nil && ss.Name != "" {
+ if ss, sErr := ctx.Store.GetStationSessionByToken(bearerOf(r)); sErr == nil && ss != nil && ss.Name != "" {
opName = ss.Name
}
q := url.Values{}
if req.Operator != "" {
q.Set("operator", req.Operator)
}
- respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/done?"+q.Encode(), json.RawMessage(payload))
+ respBody, _, err := ctx.Mes.Post("/api/internal/workpiece/done?"+q.Encode(), json.RawMessage(payload), bearerOf(r))
if err != nil {
// MES 业务拒绝(HTTP200+code≠0):数据不合法,直接失败回前端
var bizErr *mes.BizError
diff --git a/bj_power_workstation/internal/mes/client.go b/bj_power_workstation/internal/mes/client.go
index 9304ce0..864793f 100644
--- a/bj_power_workstation/internal/mes/client.go
+++ b/bj_power_workstation/internal/mes/client.go
@@ -34,15 +34,17 @@ func (e *BizError) Error() string {
// Client MES 内部 API HTTP 客户端。
// 自动携带请求头:X-API-TOKEN(项目间 token)、Content-Type: application/json。
// 任何非 2xx 状态返回包含响应体的错误信息。
+// 多会话版(2026-11-11):Bearer 不再是单一全局登录态,Get/Post 支持可选 bearer 参数——
+// 终端 handler 把「当前请求的 JWT」透传给 MES(token 即会话身份),多个会话互不串身份;
+// 不传 bearer 的调用(登录/内部通知等)只带 X-API-TOKEN。
type Client struct {
baseURL string
token string // X-API-TOKEN 共享内部 token(项目间)
- stationToken string // 工位登录态 JWT(Bearer):方案 B 报工链路可信身份凭证
httpClient *http.Client
streamClient *http.Client // SSE 长连接专用(无总超时)
mu sync.Mutex
- Touch func() // 每次以「当前有效登录态」发起的调用触发,用于刷新工位空闲计时(核实4)
+ Touch func(bearer string) // 每次以有效登录态(bearer 非空)发起的调用触发,刷新该会话空闲计时(核实4)
}
func New(baseURL, token string) *Client {
@@ -54,25 +56,17 @@ func New(baseURL, token string) *Client {
}
}
-// SetStationToken 设置工位登录态 JWT(方案 B):登录成功后由上层注入,
-// 后续报工/拧紧调用将以 Authorization: Bearer 携带,供 MES 校验可信操作人。
-func (c *Client) SetStationToken(t string) {
- c.mu.Lock()
- c.stationToken = t
- c.mu.Unlock()
-}
-
-// Get 发送 GET 请求,query 为空则忽略。
-func (c *Client) Get(path string, query url.Values) ([]byte, http.Header, error) {
+// Get 发送 GET 请求,query 为空则忽略;bearer 可选(当前请求的工位登录 JWT)。
+func (c *Client) Get(path string, query url.Values, bearer ...string) ([]byte, http.Header, error) {
u := c.baseURL + path
if len(query) > 0 {
u += "?" + query.Encode()
}
- return c.do(http.MethodGet, u, nil)
+ return c.do(http.MethodGet, u, nil, firstBearer(bearer))
}
-// Post 发送 POST 请求(实时路径),body 序列化为 JSON;Bearer 使用当前登录态 JWT。
-func (c *Client) Post(path string, body any) ([]byte, http.Header, error) {
+// Post 发送 POST 请求(实时路径),body 序列化为 JSON;bearer 可选(当前请求的工位登录 JWT)。
+func (c *Client) Post(path string, body any, bearer ...string) ([]byte, http.Header, error) {
var reader io.Reader
if body != nil {
b, err := json.Marshal(body)
@@ -81,7 +75,16 @@ func (c *Client) Post(path string, body any) ([]byte, http.Header, error) {
}
reader = bytes.NewReader(b)
}
- return c.do(http.MethodPost, c.baseURL+path, reader)
+ return c.do(http.MethodPost, c.baseURL+path, reader, firstBearer(bearer))
+}
+
+func firstBearer(v []string) string {
+ for _, s := range v {
+ if s != "" {
+ return s
+ }
+ }
+ return ""
}
// ReportTighteningConfig 向 MES 上报本终端 yaml 的拧紧枪配置快照,仅供「拧紧枪配置」页展示。
@@ -133,24 +136,21 @@ func (c *Client) GetStream(path string, query url.Values) (io.ReadCloser, error)
return resp.Body, nil
}
-// do 执行请求:Bearer 固定使用当前登录态 JWT(c.stationToken)。
-// 仅在「当前登录态有效」时刷新空闲计时(核实4)。
-func (c *Client) do(method, u string, body io.Reader) ([]byte, http.Header, error) {
- c.mu.Lock()
- bearer := c.stationToken
- c.mu.Unlock()
+// do 执行请求:Bearer 使用调用方传入的请求级 JWT(多会话透传),空则不携带。
+// 仅在携带有效登录态时刷新对应会话的空闲计时(核实4)。
+func (c *Client) do(method, u string, body io.Reader, bearer string) ([]byte, http.Header, error) {
req, err := http.NewRequest(method, u, body)
if err != nil {
return nil, nil, err
}
req.Header.Set("X-API-TOKEN", c.token)
req.Header.Set("Content-Type", "application/json;charset=utf-8")
- // 方案 B:携带工位登录态 JWT,使 MES 能从 claims 取出可信操作人/工位号
+ // 方案 B(多会话):透传当前请求的工位登录态 JWT,使 MES 能从 claims 取出可信操作人/工位号
if bearer != "" {
req.Header.Set("Authorization", "Bearer "+bearer)
- // 核实4:携带当前登录态的调用视为一次人工活动,刷新空闲计时
+ // 核实4:携带当前登录态的调用视为一次人工活动,刷新该会话的空闲计时
if c.Touch != nil {
- c.Touch()
+ c.Touch(bearer)
}
}
diff --git a/bj_power_workstation/internal/store/store.go b/bj_power_workstation/internal/store/store.go
index 9f15541..af4976d 100644
--- a/bj_power_workstation/internal/store/store.go
+++ b/bj_power_workstation/internal/store/store.go
@@ -3,6 +3,7 @@ package store
import (
"database/sql"
"fmt"
+ "strings"
"time"
_ "modernc.org/sqlite" // 纯 Go SQLite 驱动(驱动名 "sqlite"),避免 CGO
@@ -34,20 +35,23 @@ CREATE TABLE IF NOT EXISTS event_log (
created_at INTEGER
);
--- 工位终端当前登录态(方案 B · 可信身份锚点):单行(id=1)保存 MES 签发的登录 JWT 与其声明身份。
--- 报工/拧紧转发 MES 时携带该 JWT 作为 Bearer,MES 据 claims 落痕,杜绝浏览器侧冒名操作工。
+-- 工位终端登录态(方案 B · 可信身份锚点):多行会话表(2026-11-11 多会话改造)。
+-- 同一套终端实例支持多人同时登录不同工位;同一工位只允许一个会话(partial UNIQUE 索引强制),
+-- 新登录同工位时踢掉旧会话(ReplaceStationSession 删旧行)。报工/拧紧等转发 MES 时按请求
+-- token 透传对应会话 JWT 作为 Bearer,MES 据 claims 落痕,杜绝浏览器侧冒名操作工。
-- user_id 为 MES 用户 ID(落库用),expire_at 为凭证过期时间。
CREATE TABLE IF NOT EXISTS station_session (
- id INTEGER PRIMARY KEY CHECK(id=1),
- token TEXT,
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token TEXT UNIQUE,
username TEXT,
name TEXT,
- station_no INTEGER,
+ station_no INTEGER NOT NULL DEFAULT 0,
user_id INTEGER,
expire_at INTEGER,
last_active_at INTEGER,
created_at INTEGER
);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_station_session_station ON station_session(station_no) WHERE station_no > 0;
`
// Open 打开(必要时创建)本地 SQLite 数据库并建表。
@@ -87,10 +91,14 @@ func Open(path string) (*Store, error) {
db.Close()
return nil, err
}
+ if err := s.migrateStationSessionMulti(); err != nil {
+ db.Close()
+ return nil, err
+ }
return s, nil
}
-// migrateStationSession 兼容旧库:登录态表为方案 B 新增,缺失时自动补齐。
+// migrateStationSession 兼容旧库:登录态表为方案 B 新增,缺失时自动补齐(多行会话版)。
func (s *Store) migrateStationSession() error {
rows, err := s.db.Query(`SELECT name FROM pragma_table_info('station_session') WHERE name='token'`)
if err != nil {
@@ -102,9 +110,14 @@ func (s *Store) migrateStationSession() error {
return nil
}
_, err = s.db.Exec(`CREATE TABLE IF NOT EXISTS station_session (
- id INTEGER PRIMARY KEY CHECK(id=1),
- token TEXT, username TEXT, name TEXT, station_no INTEGER, expire_at INTEGER, last_active_at INTEGER, created_at INTEGER
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token TEXT UNIQUE, username TEXT, name TEXT, station_no INTEGER NOT NULL DEFAULT 0,
+ expire_at INTEGER, last_active_at INTEGER, created_at INTEGER
)`)
+ if err != nil {
+ return err
+ }
+ _, err = s.db.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_station_session_station ON station_session(station_no) WHERE station_no > 0`)
return err
}
@@ -138,6 +151,47 @@ func (s *Store) migrateStationSessionUser() error {
return err
}
+// migrateStationSessionMulti 多会话改造迁移(2026-11-11):旧库 station_session 为单行表
+// (DDL 含 CHECK(id=1),SQLite 无法 ALTER 改约束)→ 重建表迁数据,去掉单行约束,
+// 改 AUTOINCREMENT 主键 + token UNIQUE + 同工位唯一 partial index。
+func (s *Store) migrateStationSessionMulti() error {
+ var sqlText string
+ err := s.db.QueryRow(`SELECT sql FROM sqlite_master WHERE type='table' AND name='station_session'`).Scan(&sqlText)
+ if err != nil {
+ if err == sql.ErrNoRows {
+ return nil // 表不存在(migrateStationSession 已在上游建好)
+ }
+ return err
+ }
+ if !strings.Contains(sqlText, "CHECK(id=1)") {
+ return nil // 已是多行版
+ }
+ tx, err := s.db.Begin()
+ if err != nil {
+ return err
+ }
+ defer tx.Rollback()
+ stmts := []string{
+ `CREATE TABLE station_session_multi (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token TEXT UNIQUE, username TEXT, name TEXT, station_no INTEGER NOT NULL DEFAULT 0,
+ user_id INTEGER, expire_at INTEGER, last_active_at INTEGER, created_at INTEGER
+ )`,
+ `INSERT INTO station_session_multi(token,username,name,station_no,user_id,expire_at,last_active_at,created_at)
+ SELECT token,username,name,COALESCE(station_no,0),user_id,expire_at,last_active_at,created_at
+ FROM station_session WHERE token IS NOT NULL AND token != ''`,
+ `DROP TABLE station_session`,
+ `ALTER TABLE station_session_multi RENAME TO station_session`,
+ `CREATE UNIQUE INDEX IF NOT EXISTS idx_station_session_station ON station_session(station_no) WHERE station_no > 0`,
+ }
+ for _, q := range stmts {
+ if _, err := tx.Exec(q); err != nil {
+ return err
+ }
+ }
+ return tx.Commit()
+}
+
// StationSession 工位终端当前登录态(方案 B 可信身份锚点)。
type StationSession struct {
Token string // MES 签发的登录 JWT(Bearer 凭证)
@@ -148,58 +202,96 @@ type StationSession struct {
ExpireAt int64 // 凭证过期时间戳(秒)
}
-// SaveStationSession 写入/覆盖当前登录态(单行 id=1)。
-func (s *Store) SaveStationSession(token, username, name string, stationNo int, expireAt int64, userID int64) error {
+// SaveStationSession 写入登录会话(多会话版,2026-11-11):同一工位只允许一个会话——
+// 若该工位已有会话则先删除(返回被踢会话供上层通知 MES 登出),随后插入新会话。
+// 不同工位的会话互不影响,可同时在线。
+func (s *Store) SaveStationSession(token, username, name string, stationNo int, expireAt int64, userID int64) (*StationSession, error) {
now := time.Now().Unix()
- _, err := s.db.Exec(
- `INSERT INTO station_session(id,token,username,name,station_no,user_id,expire_at,last_active_at,created_at)
- VALUES(1,?,?,?,?,?,?,?,?)
- ON CONFLICT(id) DO UPDATE SET
- token=excluded.token, username=excluded.username, name=excluded.name,
- station_no=excluded.station_no, user_id=excluded.user_id, expire_at=excluded.expire_at,
- last_active_at=excluded.last_active_at, created_at=excluded.created_at`,
- token, username, name, stationNo, userID, expireAt, now, now)
+ tx, err := s.db.Begin()
+ if err != nil {
+ return nil, err
+ }
+ defer tx.Rollback()
+ // 踢掉同工位旧会话(始终先删,保证同工位唯一;旧 token 与新 token 不同时才上报被踢者)
+ var kicked *StationSession
+ row := tx.QueryRow(`SELECT token,username,name,station_no,COALESCE(user_id,0),expire_at FROM station_session WHERE station_no=?`, stationNo)
+ var k StationSession
+ if err := row.Scan(&k.Token, &k.Username, &k.Name, &k.StationNo, &k.UserID, &k.ExpireAt); err == nil {
+ if k.Token != token {
+ kicked = &k
+ }
+ if _, err := tx.Exec(`DELETE FROM station_session WHERE station_no=?`, stationNo); err != nil {
+ return nil, err
+ }
+ } else if err != sql.ErrNoRows {
+ return nil, err
+ }
+ if _, err := tx.Exec(
+ `INSERT INTO station_session(token,username,name,station_no,user_id,expire_at,last_active_at,created_at)
+ VALUES(?,?,?,?,?,?,?,?)`,
+ token, username, name, stationNo, userID, expireAt, now, now); err != nil {
+ return nil, err
+ }
+ if err := tx.Commit(); err != nil {
+ return nil, err
+ }
+ return kicked, nil
+}
+
+// TouchSessionByToken 刷新指定会话的空闲计时(核实4 · 多会话版):每次以有效登录态发起的
+// MES 调用触发,证明当前操作人仍活跃在岗;后台 sweeper 据此逐会话判断是否超时自动登出。
+func (s *Store) TouchSessionByToken(token string) error {
+ if token == "" {
+ return nil
+ }
+ _, err := s.db.Exec(`UPDATE station_session SET last_active_at=? WHERE token=?`, time.Now().Unix(), token)
return err
}
-// TouchStationSession 刷新登录态空闲计时(核实4):每次以有效登录态发起的 MES 调用触发,
-// 证明当前操作人仍活跃在岗;后台 sweeper 据此判断是否超时自动登出。
-func (s *Store) TouchStationSession() error {
- _, err := s.db.Exec(`UPDATE station_session SET last_active_at=? WHERE id=1`, time.Now().Unix())
- return err
-}
-
-// ClearExpiredSession 若当前登录态空闲超过 idleSec 秒,则清除并返回 true(核实4 超时自动登出)。
-// 删除的是「当前登录态」(station_session),会触发 mc.SetStationToken("") 强制前端重新登录。
-func (s *Store) ClearExpiredSession(idleSec int64) (bool, error) {
+// ClearExpiredSessions 清除所有空闲超过 idleSec 秒的会话,返回被清除的会话列表
+//(核实4 超时自动登出 · 多会话版:逐会话独立计时,互不影响)。
+func (s *Store) ClearExpiredSessions(idleSec int64) ([]*StationSession, error) {
if idleSec <= 0 {
- return false, nil
+ return nil, nil
}
- var lastActive int64
- row := s.db.QueryRow(`SELECT last_active_at FROM station_session WHERE id=1`)
- if err := row.Scan(&lastActive); err != nil {
- if err == sql.ErrNoRows {
- return false, nil
+ rows, err := s.db.Query(
+ `SELECT token,username,name,station_no,user_id,expire_at,
+ COALESCE(NULLIF(last_active_at,0),COALESCE(created_at,0))
+ FROM station_session`)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ var expired []*StationSession
+ for rows.Next() {
+ var ss StationSession
+ var lastActive int64
+ if err := rows.Scan(&ss.Token, &ss.Username, &ss.Name, &ss.StationNo, &ss.UserID, &ss.ExpireAt, &lastActive); err != nil {
+ return nil, err
}
- return false, err
- }
- if lastActive <= 0 {
- // 旧数据无计时:以创建时间兜底,避免无限期有效
- row2 := s.db.QueryRow(`SELECT COALESCE(created_at,0) FROM station_session WHERE id=1`)
- _ = row2.Scan(&lastActive)
- }
- if time.Now().Unix()-lastActive > idleSec {
- if _, err := s.db.Exec(`DELETE FROM station_session WHERE id=1`); err != nil {
- return false, err
+ if time.Now().Unix()-lastActive > idleSec {
+ expired = append(expired, &ss)
}
- return true, nil
}
- return false, nil
+ if err := rows.Err(); err != nil {
+ return nil, err
+ }
+ for _, ss := range expired {
+ if _, err := s.db.Exec(`DELETE FROM station_session WHERE token=?`, ss.Token); err != nil {
+ return nil, err
+ }
+ }
+ return expired, nil
}
-// GetStationSession 读取当前登录态;无记录返回 (nil, nil)。
-func (s *Store) GetStationSession() (*StationSession, error) {
- row := s.db.QueryRow(`SELECT token,username,name,station_no,user_id,expire_at FROM station_session WHERE id=1`)
+// GetStationSessionByToken 按请求 Bearer token 定位登录会话;无匹配返回 (nil, nil)。
+// 多会话版:token 即会话标识(前端每请求自带 Bearer,终端据此取该会话的操作人/工位号)。
+func (s *Store) GetStationSessionByToken(token string) (*StationSession, error) {
+ if token == "" {
+ return nil, nil
+ }
+ row := s.db.QueryRow(
+ `SELECT token,username,name,station_no,COALESCE(user_id,0),expire_at FROM station_session WHERE token=?`, token)
var ss StationSession
if err := row.Scan(&ss.Token, &ss.Username, &ss.Name, &ss.StationNo, &ss.UserID, &ss.ExpireAt); err != nil {
if err == sql.ErrNoRows {
@@ -210,16 +302,32 @@ func (s *Store) GetStationSession() (*StationSession, error) {
return &ss, nil
}
-// UpdateSessionToken 仅更新当前登录会话的 token(滑动续签重签后同步),
+// HasSessionToken 请求 token 是否存在于任一有效登录会话(在线态校验 · 多会话版)。
+func (s *Store) HasSessionToken(token string) (bool, error) {
+ if token == "" {
+ return false, nil
+ }
+ var n int
+ err := s.db.QueryRow(`SELECT COUNT(*) FROM station_session WHERE token=?`, token).Scan(&n)
+ return n > 0, err
+}
+
+// UpdateSessionTokenByToken 滑动续签重签后按旧 token 定位会话并更新为新 token,
// 不动用户名/工位/过期时间等其它字段。
-func (s *Store) UpdateSessionToken(token string) error {
- _, err := s.db.Exec(`UPDATE station_session SET token=? WHERE id=1`, token)
+func (s *Store) UpdateSessionTokenByToken(oldToken, newToken string) error {
+ if oldToken == "" || newToken == "" || oldToken == newToken {
+ return nil
+ }
+ _, err := s.db.Exec(`UPDATE station_session SET token=? WHERE token=?`, newToken, oldToken)
return err
}
-// ClearStationSession 清除登录态(退出登录时调用)。
-func (s *Store) ClearStationSession() error {
- _, err := s.db.Exec(`DELETE FROM station_session WHERE id=1`)
+// ClearSessionByToken 清除指定会话(退出登录时调用 · 多会话版:只删请求方自己的会话)。
+func (s *Store) ClearSessionByToken(token string) error {
+ if token == "" {
+ return nil
+ }
+ _, err := s.db.Exec(`DELETE FROM station_session WHERE token=?`, token)
return err
}
diff --git a/bj_power_workstation/main.go b/bj_power_workstation/main.go
index e2c190b..53d090a 100644
--- a/bj_power_workstation/main.go
+++ b/bj_power_workstation/main.go
@@ -125,12 +125,12 @@ func main() {
defer cancel()
mc := mes.New(c.Mes.BaseURL, c.Internal.Token)
- // 核实4:绑定空闲计时回调——每次以有效登录态发起的 MES 调用刷新 last_active_at,
- // 证明当前操作人仍活跃在岗,后台 sweeper 据此判断是否超时自动登出。
- mc.Touch = func() { _ = st.TouchStationSession() }
+ // 核实4(多会话版):绑定空闲计时回调——每次以有效登录态发起的 MES 调用按其 Bearer
+ // 刷新对应会话的 last_active_at,证明当前操作人仍活跃在岗,后台 sweeper 逐会话判断超时。
+ mc.Touch = func(bearer string) { _ = st.TouchSessionByToken(bearer) }
- // 核实4:空闲自动登出 sweeper——周期性检查登录态空闲时长,超过 IdleLogoutSeconds 则清除
- // 本地登录态并失效 Bearer 凭证,强制换班/下一班操作工重新登录,杜绝共享终端身份错位。
+ // 核实4(多会话版):空闲自动登出 sweeper——周期性逐会话检查空闲时长,超过 IdleLogoutSeconds
+ // 则删除该会话行,该用户下一次请求即被 401 踢下线;其他工位会话不受影响。
go func() {
ticker := time.NewTicker(60 * time.Second)
defer ticker.Stop()
@@ -139,14 +139,14 @@ func main() {
case <-rootCtx.Done():
return
case <-ticker.C:
- cleared, err := st.ClearExpiredSession(c.Station.IdleLogoutSeconds)
+ cleared, err := st.ClearExpiredSessions(c.Station.IdleLogoutSeconds)
if err != nil {
logx.Errorf("检查工位登录态空闲超时失败: %v", err)
continue
}
- if cleared {
- logx.Infof("工位登录态空闲超过 %d 秒,已自动登出", c.Station.IdleLogoutSeconds)
- mc.SetStationToken("")
+ for _, ss := range cleared {
+ logx.Infof("工位%d 会话(%s/%s)空闲超过 %d 秒,已自动登出",
+ ss.StationNo, ss.Username, ss.Name, c.Station.IdleLogoutSeconds)
}
}
}
@@ -169,9 +169,10 @@ func main() {
}()
}
- // 工位报警事件流(谁受影响谁播报,2026-10-20):长连接 MES SSE,按本机工位过滤后广播给本机前端;
- // 断线自动重连;前端 EventSource 订阅 /api/alerts/stream,断线重连后一次性补拉 /api/alerts/station。
- am := alertstream.New(mc, c.Station.StationNo)
+ // 工位报警事件流(谁受影响谁播报,2026-10-20;多会话版 2026-11-11):长连接 MES SSE,
+ // 按每个前端订阅方自带的工位号过滤后分发(一台终端实例可同时服务多个虚拟工位会话);
+ // 断线自动重连;前端 EventSource 订阅 /api/alerts/stream?stationNo=N,断线重连后一次性补拉 /api/alerts/station。
+ am := alertstream.New(mc)
go am.Run(rootCtx)
// 扫码中间件(键盘 HID 注入):Enable=true 时后台监听 7757,接收网络型扫码枪(iData PAD / 新大陆手机)
@@ -197,15 +198,15 @@ func main() {
AlertStream: am,
}
- // 后登录踢前一个:登录态校验注入到鉴权中间件。
- // 请求 token 必须与当前 station_session.token 一致,否则旧端下一次请求即被判为「已在其他设备登录」;
- // 滑动续签重签 token 时同步写回会话,避免续签后前后端 token 不一致被误判。
+ // 在线态校验(多会话版,2026-11-11):请求 token 必须存在于任一登录会话;
+ // 同工位被新登录踢掉 / 空闲超时清掉后,旧 token 下一次请求即被判为「登录已失效」。
+ // 滑动续签重签 token 时按旧 token 定位会话同步写回,避免续签后前后端 token 不一致被误判。
auth.SessionValidator = func(token string) bool {
- ss, err := st.GetStationSession()
- return err == nil && ss != nil && ss.Token != "" && ss.Token == token
+ ok, err := st.HasSessionToken(token)
+ return err == nil && ok
}
- auth.SessionTokenSync = func(token string) {
- _ = st.UpdateSessionToken(token)
+ auth.SessionTokenSync = func(oldToken, newToken string) {
+ _ = st.UpdateSessionTokenByToken(oldToken, newToken)
}
server := rest.MustNewServer(c.RestConf)
diff --git a/bj_power_workstation/web/static/index.html b/bj_power_workstation/web/static/index.html
index 144587e..3180f42 100644
--- a/bj_power_workstation/web/static/index.html
+++ b/bj_power_workstation/web/static/index.html
@@ -6,7 +6,7 @@
工位终端
-
+
diff --git a/问题临时.md b/问题临时.md
index 8cec1cb..936ffb2 100644
--- a/问题临时.md
+++ b/问题临时.md
@@ -270,3 +270,15 @@ WMS 层号/位置号生成:自动生成,绝对不允许手填,不允许修
18、工位终端 "巡检 / 异常" 标记上小红点1,但是你去并不知道具体要干什么
+
+
+
+
+1、工单详情 - WO-HIST-20261101-001,bug: 产品名称 ????? ,实际有名称但是显示的是 问号
+2、mes 工单详情 - WO-20261110-001 。“工艺路线(3 道工艺,按工位号升序=执行顺序)” 列表里面的工位,只显示了一个工位,但实际上可能有多个工位
+3、mes 排产支撑,缺少分页:1、各工单排产支撑 必须分页;2、逐日消耗模拟 ,也需要分页;3、“各工单排产支撑” 也缺少 搜索条件;4、“各工单排产支撑” ? 工单维度?没问题因为菜单名称的意思就是“日排产”能到哪一天;5、逐日消耗模拟,应该根据实时库存 变化。
+4、多工单缓存策略?只管「PLC管理」页的手动路径下发 ? 描述不正确,还是业务就是这样。这个缓存实时功能应该是指多个工单时主线的缓存要不要缓存,他的目的是为了高效工作,我不阻挡不同工单的工件流转,你再考虑一下业务实际场景
+5、mes 待审核签字,审核通过 退回重做,上下没对齐。
+6、
+
+