521 lines
17 KiB
Go
521 lines
17 KiB
Go
package logic
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gogf/gf/v2/errors/gcode"
|
||
"github.com/gogf/gf/v2/errors/gerror"
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/os/gtime"
|
||
|
||
v1 "tool-api/api/user/v1"
|
||
"tool-api/internal/consts"
|
||
"tool-api/internal/model/entity"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 年会域：公开查座（免登录）
|
||
// 依据：PRD-02 §4.2.3（鉴权与隐私边界）、R7-11~R7-24；架构 §3.2.9、§4.4 图④、§8.6.2。
|
||
//
|
||
// 三条红线：
|
||
// 1) 只查已发布活动（status=published），否则 4005；
|
||
// 2) 姓名/手机号**二选一**即可发起查询（C 端体验）；命中**重名**时返回 ambiguous
|
||
// 标记且**零座位信息**，引导补手机号二次确认——绝不因为"只输了名字"就漏出别人的桌号；
|
||
// 未命中文案统一模糊（防枚举）；
|
||
// 3) 结果最小化：只返回本人桌座 + 本人所在桌示意，绝不返回他人信息 / 名单 / 统计。
|
||
//
|
||
// 限流/冷却无 Redis，以 event_seat_queries 时间窗 COUNT 为准（表为权威源）。
|
||
// ============================================================================
|
||
|
||
// seatLookup 命中结果（本人所在桌座）
|
||
type seatLookup struct {
|
||
TableId int64
|
||
TableNo string
|
||
TableName string
|
||
SeatNo int
|
||
Capacity int
|
||
// 本人桌圆心（hall_layout 大厅逻辑坐标系；缺省 0）
|
||
TableX int
|
||
TableY int
|
||
}
|
||
|
||
// seatGuardInput 限流/冷却判定入参（纯函数入参，便于单测）
|
||
type seatGuardInput struct {
|
||
CountLastMinute int
|
||
CountLastHour int
|
||
ConsecutiveFails int
|
||
LastFailAt *time.Time
|
||
Now time.Time
|
||
CooldownMinutes int
|
||
Threshold int
|
||
PerMinute int
|
||
PerHour int
|
||
}
|
||
|
||
func gcodeEventUnavailable() gcode.Code {
|
||
return gcode.New(consts.CodeEventUnavailable, "", nil)
|
||
}
|
||
|
||
func gcodeSeat(code int) gcode.Code {
|
||
return gcode.New(code, "", nil)
|
||
}
|
||
|
||
// seatBusyMessage 4006/4007 共用文案（§8.1 允许前端合并展示）
|
||
func seatBusyMessage() string {
|
||
return "操作过于频繁，请稍后再试"
|
||
}
|
||
|
||
// seatNotFoundMessage 双因子不匹配/未录入/未分配座位共用文案（防枚举）
|
||
func seatNotFoundMessage() string {
|
||
return "未查询到您的座位信息，请联系活动组织者确认是否已录入"
|
||
}
|
||
|
||
// seatAmbiguousMessage 命中重名时的引导文案（**不透露命中了几条**，只让用户补手机号）
|
||
func seatAmbiguousMessage() string {
|
||
return "有多个同名宾客，请补充手机号后再查询"
|
||
}
|
||
|
||
// errSeatAmbiguous 命中重名的哨兵错误：lookupSeat 返回它，调用方回 4010 且不下发座位信息。
|
||
//
|
||
// 🔴 用哨兵 error 而非第二个返回值，是为了让「未命中（模糊文案，正常返回体）」
|
||
// 与「重名（需消歧，错误码）」在类型上就分得开，不会被后续维护误合并。
|
||
var errSeatAmbiguous = gerror.NewCode(
|
||
gcode.New(consts.CodeSeatAmbiguous, "重名需消歧", nil),
|
||
seatAmbiguousMessage(),
|
||
)
|
||
|
||
// ============================================================================
|
||
// 纯函数
|
||
// ============================================================================
|
||
|
||
// judgeSeatGuard 返回限流判定码：0 放行 / 4006 超频 / 4007 冷却中。
|
||
func judgeSeatGuard(in seatGuardInput) int {
|
||
if in.PerMinute > 0 && in.CountLastMinute >= in.PerMinute {
|
||
return consts.CodeSeatRateLimited
|
||
}
|
||
if in.PerHour > 0 && in.CountLastHour >= in.PerHour {
|
||
return consts.CodeSeatRateLimited
|
||
}
|
||
if in.LastFailAt != nil && in.Threshold > 0 && in.ConsecutiveFails >= in.Threshold {
|
||
cooldown := time.Duration(in.CooldownMinutes) * time.Minute
|
||
if cooldown > 0 && in.Now.Sub(*in.LastFailAt) < cooldown {
|
||
return consts.CodeSeatCooling
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// consecutiveFails 计算最近连续失败次数（results 需按时间倒序，最近在前）。
|
||
func consecutiveFails(results []int) int {
|
||
n := 0
|
||
for _, r := range results {
|
||
if r == 0 {
|
||
n++
|
||
continue
|
||
}
|
||
break
|
||
}
|
||
return n
|
||
}
|
||
|
||
// maskPhone 手机号脱敏：中间 4 位打码（138****0000，PRD-02 Q15）。
|
||
func maskPhone(p string) string {
|
||
if p == "" {
|
||
return ""
|
||
}
|
||
if len(p) <= 4 {
|
||
return strings.Repeat("*", len(p))
|
||
}
|
||
if len(p) >= 7 {
|
||
return p[:3] + "****" + p[len(p)-4:]
|
||
}
|
||
return p[:2] + "***" + p[len(p)-2:]
|
||
}
|
||
|
||
// parseStage 从 hall_layout JSON 解析舞台信息；无舞台/解析失败返回 nil（不阻断查座）。
|
||
func parseStage(layout string) *v1.StageOut {
|
||
if strings.TrimSpace(layout) == "" {
|
||
return nil
|
||
}
|
||
var parsed struct {
|
||
Stage struct {
|
||
X int `json:"x"`
|
||
Y int `json:"y"`
|
||
W int `json:"w"`
|
||
H int `json:"h"`
|
||
Shape string `json:"shape"`
|
||
Rotation int `json:"rotation"`
|
||
Color string `json:"color"`
|
||
} `json:"stage"`
|
||
}
|
||
if err := json.Unmarshal([]byte(layout), &parsed); err != nil {
|
||
return nil
|
||
}
|
||
s := parsed.Stage
|
||
if s.W == 0 && s.H == 0 && s.Shape == "" {
|
||
return nil
|
||
}
|
||
return &v1.StageOut{X: s.X, Y: s.Y, W: s.W, H: s.H, Shape: s.Shape, Rotation: s.Rotation, Color: s.Color}
|
||
}
|
||
|
||
// 大厅逻辑坐标系缺省尺寸（与设计器 hall_layout.canvas 缺省一致：qitongxue-admin Designer.vue canvas:{w:1600,h:1200}）。
|
||
const (
|
||
defaultHallW = 1600
|
||
defaultHallH = 1200
|
||
)
|
||
|
||
// parseCanvas 从 hall_layout JSON 解析大厅逻辑宽高（canvas.w / canvas.h）。
|
||
// 空串 / 解析失败 / 值 ≤0 → 回退 1600×1200（不阻断查座，风格与 parseStage 一致）。
|
||
func parseCanvas(layout string) (w, h int) {
|
||
w, h = defaultHallW, defaultHallH
|
||
if strings.TrimSpace(layout) == "" {
|
||
return
|
||
}
|
||
var parsed struct {
|
||
Canvas struct {
|
||
W int `json:"w"`
|
||
H int `json:"h"`
|
||
} `json:"canvas"`
|
||
}
|
||
if err := json.Unmarshal([]byte(layout), &parsed); err != nil {
|
||
return
|
||
}
|
||
if parsed.Canvas.W > 0 {
|
||
w = parsed.Canvas.W
|
||
}
|
||
if parsed.Canvas.H > 0 {
|
||
h = parsed.Canvas.H
|
||
}
|
||
return
|
||
}
|
||
|
||
// buildSeatCells 生成「本人所在桌」示意：只含座位号 + 是否本人 + 是否有人（不含身份）。
|
||
func buildSeatCells(seats []seatBrief, selfNo int) []v1.SeatCell {
|
||
sorted := append([]seatBrief(nil), seats...)
|
||
sort.SliceStable(sorted, func(i, j int) bool { return sorted[i].SeatNo < sorted[j].SeatNo })
|
||
out := make([]v1.SeatCell, 0, len(sorted))
|
||
for _, s := range sorted {
|
||
out = append(out, v1.SeatCell{
|
||
SeatNo: s.SeatNo,
|
||
IsSelf: s.SeatNo == selfNo,
|
||
Filled: s.EmployeeId != 0,
|
||
})
|
||
}
|
||
return out
|
||
}
|
||
|
||
// validSeatQueryInput 查座入参校验：**姓名 / 手机号二选一非空即可**（均空才拒）。
|
||
//
|
||
// 🔴 与旧版「双因子都必填」的差异（迭代-2026-10-09）：C 端只要能定位到人即可发起查询，
|
||
//
|
||
// 双因子作为**加强**因子而非**前置**因子。重名的消歧由 lookupSeat 返回 ambiguous 兜住。
|
||
func validSeatQueryInput(name, phone string) bool {
|
||
hasName := name != ""
|
||
hasPhone := phone != ""
|
||
// 两个都空 → 拒（防无意义查询打满限流配额）
|
||
if !hasName && !hasPhone {
|
||
return false
|
||
}
|
||
if hasName && len([]rune(name)) > 32 {
|
||
return false
|
||
}
|
||
// 填了手机号就必须合法（没填不算错）
|
||
if hasPhone && !validPhone(phone) {
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// ============================================================================
|
||
// 公开接口
|
||
// ============================================================================
|
||
|
||
// EventInfo 活动公开信息（查座页顶部）。活动不存在 → 4005；未发布时 CanQuery=false。
|
||
func EventInfo(ctx context.Context, req *v1.EventInfoReq) (*v1.EventInfoRes, error) {
|
||
event, err := publicEventRow(ctx, req.EventId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &v1.EventInfoRes{
|
||
Title: event.Title,
|
||
Venue: event.Venue,
|
||
EventTime: formatGTime(event.EventTime),
|
||
Status: event.Status,
|
||
CanQuery: event.Status == consts.EventStatusPublished,
|
||
Stage: parseStage(event.HallLayout),
|
||
}, nil
|
||
}
|
||
|
||
// EventSeatQuery 扫码查座（免登录）：限流 → 双因子精确匹配 → 结果最小化 → 审计。
|
||
func EventSeatQuery(ctx context.Context, req *v1.EventSeatQueryReq) (*v1.EventSeatQueryRes, error) {
|
||
event, err := publicEventRow(ctx, req.EventId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if event.Status != consts.EventStatusPublished {
|
||
return nil, gerror.NewCode(gcodeEventUnavailable(), "活动未开放查询")
|
||
}
|
||
|
||
ip := clientIp(ctx)
|
||
openid := "" // 查座免登录，无 openid
|
||
|
||
// 限流 / 冷却闸门（被拦的请求不写审计，避免自锁）
|
||
if code := seatGuardVerdict(ctx, req.EventId, ip); code != 0 {
|
||
return nil, gerror.NewCode(gcodeSeat(code), seatBusyMessage())
|
||
}
|
||
|
||
name := strings.TrimSpace(req.Name)
|
||
phone := normalizePhone(req.Phone)
|
||
// 参数异常（两个都空 / 手机号格式错 / 姓名超长）→ 拒绝，并计入一次失败（防刷）
|
||
if !validSeatQueryInput(name, phone) {
|
||
writeSeatAudit(ctx, req.EventId, openid, ip, phone, 0)
|
||
// 🔴 三种失败原因要给**各自对应**的文案（迭代-2026-10-09）：
|
||
// 统一回「请填写姓名或手机号」会在「姓名已填、只有手机号格式错」时误导用户
|
||
// 去反复填姓名（实测截图即此问题）。顺序按「最具体 → 最宽泛」，
|
||
// 与 validSeatQueryInput 内部的判定顺序一致，便于逐条对应。
|
||
switch {
|
||
case phone != "" && !validPhone(phone):
|
||
// 手机号填了但不合法 —— 明确指向手机号，避免用户去改已填对的姓名
|
||
return nil, gerror.NewCode(gcode.CodeValidationFailed, "手机号格式不正确，请填写 11 位手机号")
|
||
case name != "" && len([]rune(name)) > 32:
|
||
return nil, gerror.NewCode(gcode.CodeValidationFailed, "姓名过长，请检查后重新输入")
|
||
default:
|
||
// 两项都空
|
||
return nil, gerror.NewCode(gcode.CodeValidationFailed, "请填写姓名或手机号")
|
||
}
|
||
}
|
||
|
||
lookup, err := lookupSeat(ctx, req.EventId, name, phone)
|
||
if err != nil {
|
||
// 🔴 命中重名：**返回 ambiguous 标记 + 零座位信息**（不是 404/模糊文案）。
|
||
// 前端据此把手机号输入框升为必填做二次查询。
|
||
if errors.Is(err, errSeatAmbiguous) || gerror.Code(err).Code() == consts.CodeSeatAmbiguous {
|
||
writeSeatAudit(ctx, req.EventId, openid, ip, phone, 0)
|
||
return &v1.EventSeatQueryRes{
|
||
Found: false,
|
||
Ambiguous: true,
|
||
Message: seatAmbiguousMessage(),
|
||
}, nil
|
||
}
|
||
return nil, err
|
||
}
|
||
if lookup == nil {
|
||
writeSeatAudit(ctx, req.EventId, openid, ip, phone, 0)
|
||
return &v1.EventSeatQueryRes{Found: false, Message: seatNotFoundMessage()}, nil
|
||
}
|
||
|
||
res, err := buildSeatQueryRes(ctx, event, lookup)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
writeSeatAudit(ctx, req.EventId, openid, ip, phone, 1)
|
||
return res, nil
|
||
}
|
||
|
||
// ============================================================================
|
||
// 内部实现
|
||
// ============================================================================
|
||
|
||
// publicEventRow 读取活动；不存在 → 4005。
|
||
func publicEventRow(ctx context.Context, eventId int64) (*entity.AnnualEvents, error) {
|
||
record, err := g.Model(consts.TableAnnualEvents).Where("id", eventId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if record.IsEmpty() {
|
||
return nil, gerror.NewCode(gcodeEventUnavailable(), "活动不存在或未开放查询")
|
||
}
|
||
event := &entity.AnnualEvents{}
|
||
if err = record.Struct(event); err != nil {
|
||
return nil, err
|
||
}
|
||
return event, nil
|
||
}
|
||
|
||
// lookupSeat 查座位：name / phone **二选一或都填**均可查询。
|
||
//
|
||
// 匹配语义：
|
||
// - 两者都填 → 双因子精确匹配（等价于旧行为）；
|
||
// - 只给一个 → 单因子匹配；命中**多行**（重名）时返回 ambiguous=nil 行语义，
|
||
// 由调用方回 4010 并**不下发任何座位信息**（见 seatAmbiguous 哨兵）。
|
||
//
|
||
// 返回 (nil, nil) 表示未命中（前端展示统一模糊文案）；返回 nil lookup + ambiguousErr
|
||
// 表示命中重名、需补手机号消歧。
|
||
func lookupSeat(ctx context.Context, eventId int64, name, phone string) (*seatLookup, error) {
|
||
// 基础 JOIN：本人须在企业员工库、且在该活动候场名单、且已绑定座位。
|
||
// ⚠️ 这里**不**用 DISTINCT：同名同人的多行正是「重名」的判据。
|
||
const baseSQL = "SELECT s.table_id AS table_id, s.seat_no AS seat_no " +
|
||
"FROM employees e " +
|
||
"JOIN event_participants p ON p.employee_id = e.id AND p.event_id = ? " +
|
||
"JOIN event_seats s ON s.employee_id = e.id AND s.event_id = ? "
|
||
|
||
var (
|
||
sql string
|
||
args []any
|
||
)
|
||
switch {
|
||
case name != "" && phone != "":
|
||
sql = baseSQL + "WHERE e.name = ? AND e.phone = ? LIMIT 2"
|
||
args = []any{eventId, eventId, name, phone}
|
||
case name != "":
|
||
// 只按姓名：LIMIT 2 足够判定「是否重名」（0 行=未命中，1 行=唯一，≥2 行=重名）
|
||
sql = baseSQL + "WHERE e.name = ? LIMIT 2"
|
||
args = []any{eventId, eventId, name}
|
||
default:
|
||
// 只按手机号：手机号在本企业内唯一，命中即本人
|
||
sql = baseSQL + "WHERE e.phone = ? LIMIT 2"
|
||
args = []any{eventId, eventId, phone}
|
||
}
|
||
|
||
records, err := g.DB().GetAll(ctx, sql, args...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if len(records) == 0 {
|
||
return nil, nil
|
||
}
|
||
// 🔴 重名：不返回任何座位信息，交由调用方回 4010 引导补手机号
|
||
if len(records) > 1 {
|
||
return nil, errSeatAmbiguous
|
||
}
|
||
|
||
tableId := records[0]["table_id"].Int64()
|
||
seatNo := records[0]["seat_no"].Int()
|
||
|
||
table, err := g.Model(consts.TableEventTables).Where("id", tableId).Where("event_id", eventId).One()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if table.IsEmpty() {
|
||
return nil, nil
|
||
}
|
||
return &seatLookup{
|
||
TableId: tableId,
|
||
TableNo: table["table_no"].String(),
|
||
TableName: table["name"].String(),
|
||
SeatNo: seatNo,
|
||
Capacity: table["capacity"].Int(),
|
||
TableX: table["x"].Int(),
|
||
TableY: table["y"].Int(),
|
||
}, nil
|
||
}
|
||
|
||
// buildSeatQueryRes 组装最小化返回体（本人桌座 + 本桌示意 + 舞台）。
|
||
func buildSeatQueryRes(ctx context.Context, event *entity.AnnualEvents, lookup *seatLookup) (*v1.EventSeatQueryRes, error) {
|
||
briefs, err := loadSeatBriefs(ctx, g.DB(), event.Id, lookup.TableId)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// hall_w / hall_h 取自 hall_layout.canvas（缺省 1600/1200）——只用于前端缩放，
|
||
// 与舞台同源解析，不引入额外查询。
|
||
hallW, hallH := parseCanvas(event.HallLayout)
|
||
return &v1.EventSeatQueryRes{
|
||
Found: true,
|
||
Message: "ok",
|
||
TableNo: lookup.TableNo,
|
||
TableName: lookup.TableName,
|
||
SeatNo: lookup.SeatNo,
|
||
Capacity: lookup.Capacity,
|
||
Seats: buildSeatCells(briefs, lookup.SeatNo),
|
||
Stage: parseStage(event.HallLayout),
|
||
TableX: lookup.TableX,
|
||
TableY: lookup.TableY,
|
||
HallW: hallW,
|
||
HallH: hallH,
|
||
}, nil
|
||
}
|
||
|
||
// seatGuardVerdict 计算限流/冷却判定码（0 放行）。查询异常时放行（宁漏不误伤）。
|
||
func seatGuardVerdict(ctx context.Context, eventId int64, ip string) int {
|
||
perMin, perHour, cooldownMin, threshold := seatGuardParams(ctx)
|
||
now := gtime.Now()
|
||
|
||
cntMin, err := g.Model(consts.TableEventSeatQueries).
|
||
Where("event_id", eventId).Where("ip", ip).
|
||
WhereGTE("created_at", now.Add(-time.Minute)).Count()
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
cntHour, err := g.Model(consts.TableEventSeatQueries).
|
||
Where("event_id", eventId).Where("ip", ip).
|
||
WhereGTE("created_at", now.Add(-time.Hour)).Count()
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
rows, err := g.Model(consts.TableEventSeatQueries).
|
||
Where("event_id", eventId).Where("ip", ip).
|
||
OrderDesc("id").Limit(20).All()
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
results := make([]int, 0, len(rows))
|
||
var lastFailAt *time.Time
|
||
for i, r := range rows {
|
||
res := r["result"].Int()
|
||
results = append(results, res)
|
||
if i == 0 && res == 0 {
|
||
if t := r["created_at"].GTime(); t != nil {
|
||
lastFailAt = &t.Time
|
||
}
|
||
}
|
||
}
|
||
return judgeSeatGuard(seatGuardInput{
|
||
CountLastMinute: cntMin,
|
||
CountLastHour: cntHour,
|
||
ConsecutiveFails: consecutiveFails(results),
|
||
LastFailAt: lastFailAt,
|
||
Now: now.Time,
|
||
CooldownMinutes: cooldownMin,
|
||
Threshold: threshold,
|
||
PerMinute: perMin,
|
||
PerHour: perHour,
|
||
})
|
||
}
|
||
|
||
// seatGuardParams 读取阈值（settings 覆盖 > 缺省）。
|
||
func seatGuardParams(ctx context.Context) (perMin, perHour, cooldownMin, threshold int) {
|
||
perMin = settingInt(ctx, consts.SettingSeatRateLimitPerMin, consts.DefaultSeatRateLimitPerMin)
|
||
perHour = settingInt(ctx, consts.SettingSeatRateLimitPerHour, consts.DefaultSeatRateLimitPerHour)
|
||
cooldownMin = settingInt(ctx, consts.SettingSeatFailCooldownMinutes, consts.DefaultSeatFailCooldownMinutes)
|
||
threshold = settingInt(ctx, consts.SettingSeatFailThreshold, consts.DefaultSeatFailThreshold)
|
||
return
|
||
}
|
||
|
||
// settingInt 读 settings 整数配置；缺失/非法用默认值。
|
||
func settingInt(ctx context.Context, key string, def int) int {
|
||
raw := SettingValue(ctx, key)
|
||
if v, err := strconv.Atoi(strings.TrimSpace(raw)); err == nil && v > 0 {
|
||
return v
|
||
}
|
||
return def
|
||
}
|
||
|
||
// writeSeatAudit 写审计（成功/失败都写），手机号脱敏。
|
||
func writeSeatAudit(ctx context.Context, eventId int64, openid, ip, phone string, result int) {
|
||
if _, err := g.Model(consts.TableEventSeatQueries).Data(g.Map{
|
||
"event_id": eventId,
|
||
"openid": openid,
|
||
"ip": ip,
|
||
"phone_masked": maskPhone(phone),
|
||
"result": result,
|
||
"created_at": gtime.Now(),
|
||
}).Insert(); err != nil {
|
||
g.Log().Warningf(ctx, "[event-seat] 写查座审计失败: %v", err)
|
||
}
|
||
}
|
||
|
||
// clientIp 取客户端 IP（无请求上下文时为空串）。
|
||
func clientIp(ctx context.Context) string {
|
||
req := g.RequestFromCtx(ctx)
|
||
if req == nil {
|
||
return ""
|
||
}
|
||
return req.GetClientIp()
|
||
}
|