544 lines
20 KiB
Go
544 lines
20 KiB
Go
// Package roomtime stores user-scoped in-room duration read models in MySQL.
|
||
package roomtime
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
mysqldriver "github.com/go-sql-driver/mysql"
|
||
"hyapp/pkg/appcode"
|
||
"hyapp/pkg/xerr"
|
||
roomtimedomain "hyapp/services/user-service/internal/domain/roomtime"
|
||
)
|
||
|
||
// Repository owns in-room session state and user duration aggregates inside user-service MySQL.
|
||
type Repository struct {
|
||
db *sql.DB
|
||
}
|
||
|
||
const (
|
||
defaultCompensationBatchSize = 200
|
||
defaultOpenSessionCompensationMs = int64(24 * 60 * 60 * 1000)
|
||
userOutboxStatusPending = "pending"
|
||
)
|
||
|
||
// New creates an in-room duration repository backed by the shared user-service connection pool.
|
||
func New(db *sql.DB) *Repository {
|
||
return &Repository{db: db}
|
||
}
|
||
|
||
// ProcessRoomPresenceEvent idempotently applies one RoomUserJoined/RoomUserLeft/RoomUserKicked fact.
|
||
func (r *Repository) ProcessRoomPresenceEvent(ctx context.Context, event roomtimedomain.RoomPresenceEvent) (roomtimedomain.ApplyResult, error) {
|
||
if r == nil || r.db == nil {
|
||
return roomtimedomain.ApplyResult{}, xerr.New(xerr.Unavailable, "room time repository is not configured")
|
||
}
|
||
event = normalizeRoomPresenceEvent(event)
|
||
if event.EventID == "" || event.EventType == "" {
|
||
return roomtimedomain.ApplyResult{}, xerr.New(xerr.InvalidArgument, "room presence event identity is required")
|
||
}
|
||
if event.OccurredAtMs <= 0 {
|
||
event.OccurredAtMs = time.Now().UnixMilli()
|
||
}
|
||
|
||
tx, err := r.db.BeginTx(ctx, nil)
|
||
if err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
defer tx.Rollback()
|
||
|
||
if err := insertEventConsumption(ctx, tx, event); err != nil {
|
||
if isDuplicate(err) {
|
||
return roomtimedomain.ApplyResult{Skipped: true, Reason: "already_consumed"}, nil
|
||
}
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
|
||
var result roomtimedomain.ApplyResult
|
||
switch {
|
||
case event.RoomID == "" || event.UserID <= 0:
|
||
result = roomtimedomain.ApplyResult{Skipped: true, Reason: "incomplete_presence_event"}
|
||
case event.EventType == roomtimedomain.RoomUserJoinedEventType:
|
||
result, err = applyJoined(ctx, tx, event)
|
||
case event.EventType == roomtimedomain.RoomUserLeftEventType:
|
||
result, err = applyLeft(ctx, tx, event, roomtimedomain.EndReasonLeft)
|
||
case event.EventType == roomtimedomain.RoomUserKickedEventType:
|
||
result, err = applyLeft(ctx, tx, event, roomtimedomain.EndReasonKicked)
|
||
default:
|
||
result = roomtimedomain.ApplyResult{Skipped: true, Reason: "unsupported_presence_event"}
|
||
}
|
||
if err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
if result.Reason == "" && result.Skipped {
|
||
result.Reason = "skipped"
|
||
}
|
||
status := "consumed"
|
||
if result.Skipped {
|
||
status = "skipped"
|
||
}
|
||
if err := finishEventConsumption(ctx, tx, event, status, result.Reason); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
if err := tx.Commit(); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
if !result.Skipped {
|
||
result.Consumed = true
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
// CompensateOpenSessions closes abnormal sessions whose authoritative leave event never reached user-service.
|
||
func (r *Repository) CompensateOpenSessions(ctx context.Context, options roomtimedomain.CompensationOptions) (roomtimedomain.CompensationResult, error) {
|
||
if r == nil || r.db == nil {
|
||
return roomtimedomain.CompensationResult{}, xerr.New(xerr.Unavailable, "room time repository is not configured")
|
||
}
|
||
options = normalizeCompensationOptions(options)
|
||
|
||
tx, err := r.db.BeginTx(ctx, nil)
|
||
if err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
defer tx.Rollback()
|
||
|
||
cutoff := options.NowMs - options.OpenSessionMaxAgeMs
|
||
app := appcode.FromContext(ctx)
|
||
rows, err := tx.QueryContext(ctx, `
|
||
SELECT app_code, room_session_id, user_id, room_id, status, is_robot, joined_at_ms, last_room_version
|
||
FROM user_room_sessions
|
||
WHERE app_code = ? AND status = ? AND joined_at_ms <= ?
|
||
ORDER BY joined_at_ms ASC, room_session_id ASC
|
||
LIMIT ?
|
||
FOR UPDATE SKIP LOCKED
|
||
`, app, roomtimedomain.SessionStatusOpen, cutoff, options.BatchSize)
|
||
if err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
|
||
candidates := make([]roomSessionRow, 0, options.BatchSize)
|
||
for rows.Next() {
|
||
var session roomSessionRow
|
||
if err := rows.Scan(&session.AppCode, &session.RoomSessionID, &session.UserID, &session.RoomID, &session.Status, &session.IsRobot, &session.JoinedAtMs, &session.LastRoomVersion); err != nil {
|
||
_ = rows.Close()
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
candidates = append(candidates, session)
|
||
}
|
||
if err := rows.Close(); err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
|
||
var result roomtimedomain.CompensationResult
|
||
for _, session := range candidates {
|
||
if err := closeRoomSession(ctx, tx, session, closeRoomSessionInput{
|
||
ClosedEventID: fmt.Sprintf("compensated:%s", session.RoomSessionID),
|
||
EndAtMs: minInt64(options.NowMs, session.JoinedAtMs+options.OpenSessionMaxAgeMs),
|
||
EndReason: roomtimedomain.CompensationReasonOpenSessionMaxWindow,
|
||
UpdatedAtMs: options.NowMs,
|
||
RoomVersion: session.LastRoomVersion,
|
||
}); err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
result.ClosedCount++
|
||
}
|
||
|
||
// 孤儿 Left 只用于修正乱序到达；超过补偿窗口后已不可能再匹配任何进房事实，按批清理。
|
||
deleted, err := tx.ExecContext(ctx, `
|
||
DELETE FROM user_room_orphan_leaves
|
||
WHERE app_code = ? AND left_at_ms <= ?
|
||
LIMIT ?
|
||
`, app, cutoff, options.BatchSize)
|
||
if err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
if affected, err := deleted.RowsAffected(); err == nil {
|
||
result.OrphanLeavesDeleted = int(affected)
|
||
}
|
||
|
||
if err := tx.Commit(); err != nil {
|
||
return roomtimedomain.CompensationResult{}, err
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func applyJoined(ctx context.Context, tx *sql.Tx, event roomtimedomain.RoomPresenceEvent) (roomtimedomain.ApplyResult, error) {
|
||
openSessions, err := openSessionsForUpdate(ctx, tx, event.AppCode, event.UserID)
|
||
if err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
for _, session := range openSessions {
|
||
// 一个用户同一时刻只保留一个在房会话：房间侧一个在线周期只发一条 Joined，
|
||
// 这里还有 open 会话说明它的 Left/Kicked 丢失或尚未到达，用新进房时刻闭合避免双计。
|
||
reason := roomtimedomain.EndReasonSupersededByJoin
|
||
if session.RoomID == event.RoomID {
|
||
reason = roomtimedomain.EndReasonSupersededByRejoin
|
||
}
|
||
if err := closeRoomSession(ctx, tx, session, closeRoomSessionInput{
|
||
ClosedEventID: event.EventID,
|
||
EndAtMs: event.OccurredAtMs,
|
||
EndReason: reason,
|
||
UpdatedAtMs: event.OccurredAtMs,
|
||
RoomVersion: event.RoomVersion,
|
||
}); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
}
|
||
|
||
orphan, matched, err := matchOrphanLeave(ctx, tx, event)
|
||
if err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
joinedSession := roomSessionRow{
|
||
AppCode: event.AppCode,
|
||
RoomSessionID: event.EventID,
|
||
UserID: event.UserID,
|
||
RoomID: event.RoomID,
|
||
Status: roomtimedomain.SessionStatusOpen,
|
||
IsRobot: event.IsRobot,
|
||
JoinedAtMs: event.OccurredAtMs,
|
||
LastRoomVersion: event.RoomVersion,
|
||
}
|
||
if matched {
|
||
// Left 先到、Joined 后到：直接落一条已闭合会话，时长取两个事实的间隔。
|
||
if err := insertRoomSession(ctx, tx, joinedSession, event, roomtimedomain.SessionStatusOpen); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
if err := closeRoomSession(ctx, tx, joinedSession, closeRoomSessionInput{
|
||
ClosedEventID: orphan.EventID,
|
||
EndAtMs: orphan.LeftAtMs,
|
||
EndReason: roomtimedomain.EndReasonOrphanLeft,
|
||
UpdatedAtMs: event.OccurredAtMs,
|
||
RoomVersion: event.RoomVersion,
|
||
}); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
if _, err := tx.ExecContext(ctx, `
|
||
DELETE FROM user_room_orphan_leaves WHERE app_code = ? AND event_id = ?
|
||
`, event.AppCode, orphan.EventID); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
return roomtimedomain.ApplyResult{Consumed: true, Opened: true, Closed: true, Reason: "matched_orphan_left"}, nil
|
||
}
|
||
|
||
if err := insertRoomSession(ctx, tx, joinedSession, event, roomtimedomain.SessionStatusOpen); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
return roomtimedomain.ApplyResult{Consumed: true, Opened: true}, nil
|
||
}
|
||
|
||
func applyLeft(ctx context.Context, tx *sql.Tx, event roomtimedomain.RoomPresenceEvent, endReason string) (roomtimedomain.ApplyResult, error) {
|
||
openSessions, err := openRoomSessionsForUpdate(ctx, tx, event.AppCode, event.RoomID, event.UserID)
|
||
if err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
closed := 0
|
||
sawNewerSession := false
|
||
for _, session := range openSessions {
|
||
if session.JoinedAtMs > event.OccurredAtMs {
|
||
// Left 早于当前 open 会话的进房时刻，说明它属于更早的在线周期；那个周期已被 supersede 闭合，直接丢弃。
|
||
sawNewerSession = true
|
||
continue
|
||
}
|
||
if err := closeRoomSession(ctx, tx, session, closeRoomSessionInput{
|
||
ClosedEventID: event.EventID,
|
||
EndAtMs: event.OccurredAtMs,
|
||
EndReason: endReason,
|
||
UpdatedAtMs: event.OccurredAtMs,
|
||
RoomVersion: event.RoomVersion,
|
||
}); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
closed++
|
||
}
|
||
if closed > 0 {
|
||
return roomtimedomain.ApplyResult{Consumed: true, Closed: true}, nil
|
||
}
|
||
if sawNewerSession {
|
||
return roomtimedomain.ApplyResult{Skipped: true, Reason: "stale_left_event"}, nil
|
||
}
|
||
// 没有可闭合的会话：Left 可能先于 Joined 到达，暂存等 Joined 到达时直接生成闭合会话。
|
||
// 踢人对已离房用户也会发 RoomUserKicked，这类孤儿记录不会匹配任何更晚的进房事实，由补偿任务清理。
|
||
if _, err := tx.ExecContext(ctx, `
|
||
INSERT IGNORE INTO user_room_orphan_leaves (app_code, event_id, room_id, user_id, left_at_ms, reason, created_at_ms)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?)
|
||
`, event.AppCode, event.EventID, event.RoomID, event.UserID, event.OccurredAtMs, endReason, event.OccurredAtMs); err != nil {
|
||
return roomtimedomain.ApplyResult{}, err
|
||
}
|
||
return roomtimedomain.ApplyResult{Skipped: true, Reason: "left_before_join_buffered"}, nil
|
||
}
|
||
|
||
type closeRoomSessionInput struct {
|
||
ClosedEventID string
|
||
EndAtMs int64
|
||
EndReason string
|
||
UpdatedAtMs int64
|
||
RoomVersion int64
|
||
}
|
||
|
||
func closeRoomSession(ctx context.Context, tx *sql.Tx, session roomSessionRow, input closeRoomSessionInput) error {
|
||
input.ClosedEventID = strings.TrimSpace(input.ClosedEventID)
|
||
if input.ClosedEventID == "" {
|
||
input.ClosedEventID = "closed:" + session.RoomSessionID
|
||
}
|
||
input.EndReason = strings.TrimSpace(input.EndReason)
|
||
if input.EndReason == "" {
|
||
input.EndReason = roomtimedomain.EndReasonLeft
|
||
}
|
||
if input.EndAtMs < session.JoinedAtMs {
|
||
input.EndAtMs = session.JoinedAtMs
|
||
}
|
||
if input.UpdatedAtMs <= 0 {
|
||
input.UpdatedAtMs = input.EndAtMs
|
||
}
|
||
roomOnlineMs := maxInt64(0, input.EndAtMs-session.JoinedAtMs)
|
||
|
||
_, err := tx.ExecContext(ctx, `
|
||
UPDATE user_room_sessions
|
||
SET status = ?, ended_at_ms = ?, end_reason = ?, room_online_ms = ?,
|
||
closed_event_id = ?, last_event_id = ?, last_room_version = GREATEST(last_room_version, ?), updated_at_ms = ?
|
||
WHERE app_code = ? AND room_session_id = ? AND status <> ?
|
||
`, roomtimedomain.SessionStatusEnded, input.EndAtMs, input.EndReason, roomOnlineMs,
|
||
input.ClosedEventID, input.ClosedEventID, input.RoomVersion, input.UpdatedAtMs,
|
||
session.AppCode, session.RoomSessionID, roomtimedomain.SessionStatusEnded)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if session.IsRobot {
|
||
// 机器人在房不产生活跃/时长统计事实；会话仍闭合留档，方便排查调度行为。
|
||
return nil
|
||
}
|
||
return incrementDaily(ctx, tx, session, input)
|
||
}
|
||
|
||
func incrementDaily(ctx context.Context, tx *sql.Tx, session roomSessionRow, input closeRoomSessionInput) error {
|
||
for date, part := range splitByUTCDay(session.JoinedAtMs, input.EndAtMs) {
|
||
_, err := tx.ExecContext(ctx, `
|
||
INSERT INTO user_room_daily_stats (
|
||
app_code, user_id, stat_date, room_online_ms, session_count, first_room_at_ms, last_room_at_ms, updated_at_ms
|
||
) VALUES (?, ?, ?, ?, 1, ?, ?, ?)
|
||
ON DUPLICATE KEY UPDATE
|
||
room_online_ms = room_online_ms + VALUES(room_online_ms),
|
||
session_count = session_count + 1,
|
||
first_room_at_ms = CASE WHEN first_room_at_ms = 0 OR first_room_at_ms > VALUES(first_room_at_ms) THEN VALUES(first_room_at_ms) ELSE first_room_at_ms END,
|
||
last_room_at_ms = GREATEST(last_room_at_ms, VALUES(last_room_at_ms)),
|
||
updated_at_ms = VALUES(updated_at_ms)
|
||
`, session.AppCode, session.UserID, date, part.DurationMs, part.FirstAtMs, part.LastAtMs, input.UpdatedAtMs)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if err := insertUserOutbox(ctx, tx, session.AppCode,
|
||
roomtimedomain.EventTypeUserRoomDailyStatsUpdated+":"+session.RoomSessionID+":"+date,
|
||
roomtimedomain.EventTypeUserRoomDailyStatsUpdated, "user_room_daily_stats", session.UserID, input.UpdatedAtMs, map[string]any{
|
||
"app_code": session.AppCode,
|
||
"user_id": session.UserID,
|
||
"room_id": session.RoomID,
|
||
"stat_date": date,
|
||
"room_session_id": session.RoomSessionID,
|
||
"room_online_delta_ms": part.DurationMs,
|
||
"session_count_delta": 1,
|
||
"end_reason": input.EndReason,
|
||
"updated_at_ms": input.UpdatedAtMs,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type roomSessionRow struct {
|
||
AppCode string
|
||
RoomSessionID string
|
||
UserID int64
|
||
RoomID string
|
||
Status string
|
||
IsRobot bool
|
||
JoinedAtMs int64
|
||
LastRoomVersion int64
|
||
}
|
||
|
||
type orphanLeaveRow struct {
|
||
EventID string
|
||
LeftAtMs int64
|
||
}
|
||
|
||
func openSessionsForUpdate(ctx context.Context, tx *sql.Tx, appCode string, userID int64) ([]roomSessionRow, error) {
|
||
return scanSessions(tx.QueryContext(ctx, `
|
||
SELECT app_code, room_session_id, user_id, room_id, status, is_robot, joined_at_ms, last_room_version
|
||
FROM user_room_sessions
|
||
WHERE app_code = ? AND user_id = ? AND status = ?
|
||
ORDER BY joined_at_ms ASC, room_session_id ASC
|
||
FOR UPDATE
|
||
`, appCode, userID, roomtimedomain.SessionStatusOpen))
|
||
}
|
||
|
||
func openRoomSessionsForUpdate(ctx context.Context, tx *sql.Tx, appCode string, roomID string, userID int64) ([]roomSessionRow, error) {
|
||
return scanSessions(tx.QueryContext(ctx, `
|
||
SELECT app_code, room_session_id, user_id, room_id, status, is_robot, joined_at_ms, last_room_version
|
||
FROM user_room_sessions
|
||
WHERE app_code = ? AND user_id = ? AND room_id = ? AND status = ?
|
||
ORDER BY joined_at_ms ASC, room_session_id ASC
|
||
FOR UPDATE
|
||
`, appCode, userID, roomID, roomtimedomain.SessionStatusOpen))
|
||
}
|
||
|
||
func scanSessions(rows *sql.Rows, err error) ([]roomSessionRow, error) {
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer rows.Close()
|
||
sessions := []roomSessionRow{}
|
||
for rows.Next() {
|
||
var session roomSessionRow
|
||
if err := rows.Scan(&session.AppCode, &session.RoomSessionID, &session.UserID, &session.RoomID, &session.Status, &session.IsRobot, &session.JoinedAtMs, &session.LastRoomVersion); err != nil {
|
||
return nil, err
|
||
}
|
||
sessions = append(sessions, session)
|
||
}
|
||
return sessions, rows.Err()
|
||
}
|
||
|
||
func matchOrphanLeave(ctx context.Context, tx *sql.Tx, event roomtimedomain.RoomPresenceEvent) (orphanLeaveRow, bool, error) {
|
||
var orphan orphanLeaveRow
|
||
err := tx.QueryRowContext(ctx, `
|
||
SELECT event_id, left_at_ms
|
||
FROM user_room_orphan_leaves
|
||
WHERE app_code = ? AND room_id = ? AND user_id = ? AND left_at_ms >= ?
|
||
ORDER BY left_at_ms ASC
|
||
LIMIT 1
|
||
FOR UPDATE
|
||
`, event.AppCode, event.RoomID, event.UserID, event.OccurredAtMs).Scan(&orphan.EventID, &orphan.LeftAtMs)
|
||
if err == sql.ErrNoRows {
|
||
return orphanLeaveRow{}, false, nil
|
||
}
|
||
if err != nil {
|
||
return orphanLeaveRow{}, false, err
|
||
}
|
||
return orphan, true, nil
|
||
}
|
||
|
||
func insertRoomSession(ctx context.Context, tx *sql.Tx, session roomSessionRow, event roomtimedomain.RoomPresenceEvent, status string) error {
|
||
_, err := tx.ExecContext(ctx, `
|
||
INSERT INTO user_room_sessions (
|
||
app_code, room_session_id, user_id, room_id, status, is_robot,
|
||
joined_at_ms, ended_at_ms, end_reason, room_online_ms,
|
||
opened_event_id, closed_event_id, last_event_id, last_room_version, created_at_ms, updated_at_ms
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, '', 0, ?, '', ?, ?, ?, ?)
|
||
ON DUPLICATE KEY UPDATE
|
||
last_event_id = VALUES(last_event_id),
|
||
last_room_version = GREATEST(last_room_version, VALUES(last_room_version)),
|
||
updated_at_ms = VALUES(updated_at_ms)
|
||
`, session.AppCode, session.RoomSessionID, session.UserID, session.RoomID, status, session.IsRobot,
|
||
session.JoinedAtMs, event.EventID, event.EventID, event.RoomVersion, event.OccurredAtMs, event.OccurredAtMs)
|
||
return err
|
||
}
|
||
|
||
func insertEventConsumption(ctx context.Context, tx *sql.Tx, event roomtimedomain.RoomPresenceEvent) error {
|
||
_, err := tx.ExecContext(ctx, `
|
||
INSERT INTO user_room_event_consumption (
|
||
app_code, event_id, event_type, room_id, user_id, status, skip_reason,
|
||
created_at_ms, consumed_at_ms, updated_at_ms
|
||
) VALUES (?, ?, ?, ?, ?, 'processing', '', ?, NULL, ?)
|
||
`, event.AppCode, event.EventID, event.EventType, event.RoomID, event.UserID, event.OccurredAtMs, event.OccurredAtMs)
|
||
return err
|
||
}
|
||
|
||
func finishEventConsumption(ctx context.Context, tx *sql.Tx, event roomtimedomain.RoomPresenceEvent, status string, reason string) error {
|
||
_, err := tx.ExecContext(ctx, `
|
||
UPDATE user_room_event_consumption
|
||
SET status = ?, skip_reason = ?, consumed_at_ms = ?, updated_at_ms = ?
|
||
WHERE app_code = ? AND event_id = ?
|
||
`, status, strings.TrimSpace(reason), event.OccurredAtMs, event.OccurredAtMs, event.AppCode, event.EventID)
|
||
return err
|
||
}
|
||
|
||
func insertUserOutbox(ctx context.Context, tx *sql.Tx, appCode string, eventID string, eventType string, aggregateType string, aggregateID int64, createdAtMs int64, payload map[string]any) error {
|
||
payloadBytes, err := json.Marshal(payload)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
_, err = tx.ExecContext(ctx, `
|
||
INSERT IGNORE INTO user_outbox (app_code, event_id, event_type, aggregate_type, aggregate_id, status, payload_json, created_at_ms, updated_at_ms)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||
`, appcode.Normalize(appCode), eventID, eventType, aggregateType, aggregateID, userOutboxStatusPending, string(payloadBytes), createdAtMs, createdAtMs)
|
||
return err
|
||
}
|
||
|
||
func normalizeRoomPresenceEvent(event roomtimedomain.RoomPresenceEvent) roomtimedomain.RoomPresenceEvent {
|
||
event.AppCode = appcode.Normalize(event.AppCode)
|
||
event.EventID = strings.TrimSpace(event.EventID)
|
||
event.EventType = strings.TrimSpace(event.EventType)
|
||
event.RoomID = strings.TrimSpace(event.RoomID)
|
||
return event
|
||
}
|
||
|
||
func normalizeCompensationOptions(options roomtimedomain.CompensationOptions) roomtimedomain.CompensationOptions {
|
||
if options.NowMs <= 0 {
|
||
options.NowMs = time.Now().UnixMilli()
|
||
}
|
||
if options.BatchSize <= 0 {
|
||
options.BatchSize = defaultCompensationBatchSize
|
||
}
|
||
if options.OpenSessionMaxAgeMs <= 0 {
|
||
options.OpenSessionMaxAgeMs = defaultOpenSessionCompensationMs
|
||
}
|
||
return options
|
||
}
|
||
|
||
type dayDuration struct {
|
||
DurationMs int64
|
||
FirstAtMs int64
|
||
LastAtMs int64
|
||
}
|
||
|
||
func splitByUTCDay(startMs int64, endMs int64) map[string]dayDuration {
|
||
parts := map[string]dayDuration{}
|
||
if endMs <= startMs {
|
||
return parts
|
||
}
|
||
for cursor := startMs; cursor < endMs; {
|
||
cursorTime := time.UnixMilli(cursor).UTC()
|
||
dayStart := time.Date(cursorTime.Year(), cursorTime.Month(), cursorTime.Day(), 0, 0, 0, 0, time.UTC)
|
||
nextDayMs := dayStart.AddDate(0, 0, 1).UnixMilli()
|
||
segmentEnd := minInt64(endMs, nextDayMs)
|
||
date := dayStart.Format("2006-01-02")
|
||
part := parts[date]
|
||
if part.FirstAtMs == 0 || cursor < part.FirstAtMs {
|
||
part.FirstAtMs = cursor
|
||
}
|
||
if segmentEnd > part.LastAtMs {
|
||
part.LastAtMs = segmentEnd
|
||
}
|
||
part.DurationMs += segmentEnd - cursor
|
||
parts[date] = part
|
||
cursor = segmentEnd
|
||
}
|
||
return parts
|
||
}
|
||
|
||
func isDuplicate(err error) bool {
|
||
var mysqlErr *mysqldriver.MySQLError
|
||
return errors.As(err, &mysqlErr) && mysqlErr.Number == 1062
|
||
}
|
||
|
||
func minInt64(a int64, b int64) int64 {
|
||
if a < b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func maxInt64(a int64, b int64) int64 {
|
||
if a > b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|