style: 统一代码格式和行尾

This commit is contained in:
leonincs
2026-05-20 16:34:19 +08:00
parent 0b87fd94cc
commit 732e284369
68 changed files with 7784 additions and 7781 deletions

View File

@@ -1,316 +1,316 @@
package main package main
import ( import (
"context" "context"
"feedsystem_video_go/internal/config" "feedsystem_video_go/internal/config"
"feedsystem_video_go/internal/db" "feedsystem_video_go/internal/db"
rediscache "feedsystem_video_go/internal/middleware/redis" mqrabbit "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/observability" rediscache "feedsystem_video_go/internal/middleware/redis"
"feedsystem_video_go/internal/social" "feedsystem_video_go/internal/observability"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/social"
"feedsystem_video_go/internal/worker" "feedsystem_video_go/internal/video"
mqrabbit "feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/worker"
"log" "log"
"os" "os"
"os/signal" "os/signal"
"strconv" "strconv"
"syscall" "syscall"
"time" "time"
amqp "github.com/rabbitmq/amqp091-go" amqp "github.com/rabbitmq/amqp091-go"
"gorm.io/gorm" "gorm.io/gorm"
) )
const ( const (
socialExchange = "social.events" socialExchange = "social.events"
socialQueue = "social.events" socialQueue = "social.events"
socialBindingKey = "social.*" socialBindingKey = "social.*"
likeExchange = "like.events" likeExchange = "like.events"
likeQueue = "like.events" likeQueue = "like.events"
likeBindingKey = "like.*" likeBindingKey = "like.*"
commentExchange = "comment.events" commentExchange = "comment.events"
commentQueue = "comment.events" commentQueue = "comment.events"
commentBindingKey = "comment.*" commentBindingKey = "comment.*"
popularityExchange = "video.popularity.events" popularityExchange = "video.popularity.events"
popularityQueue = "video.popularity.events" popularityQueue = "video.popularity.events"
popularityBindingKey = "video.popularity.*" popularityBindingKey = "video.popularity.*"
) )
func connectWithRetry(name string, maxRetries int, fn func() error) { func connectWithRetry(name string, maxRetries int, fn func() error) {
for i := 0; i < maxRetries; i++ { for i := 0; i < maxRetries; i++ {
if err := fn(); err == nil { if err := fn(); err == nil {
return return
} }
wait := time.Duration(1<<i) * time.Second wait := time.Duration(1<<i) * time.Second
if wait > 30*time.Second { if wait > 30*time.Second {
wait = 30 * time.Second wait = 30 * time.Second
} }
log.Printf("%s 不可用,%v 后重试 (%d/%d)...", name, wait, i+1, maxRetries) log.Printf("%s 不可用,%v 后重试 (%d/%d)...", name, wait, i+1, maxRetries)
time.Sleep(wait) time.Sleep(wait)
} }
log.Fatalf("%s: 超过最大重试次数", name) log.Fatalf("%s: 超过最大重试次数", name)
} }
func main() { func main() {
// 加载配置 // 加载配置
configPath := os.Getenv("CONFIG_PATH") configPath := os.Getenv("CONFIG_PATH")
if configPath == "" { if configPath == "" {
configPath = "configs/config.yaml" configPath = "configs/config.yaml"
} }
log.Printf("Loading config from %s", configPath) log.Printf("Loading config from %s", configPath)
cfg, usedDefault, err := config.LoadLocalDev(configPath) cfg, usedDefault, err := config.LoadLocalDev(configPath)
if err != nil { if err != nil {
log.Fatalf("Failed to load config: %v", err) log.Fatalf("Failed to load config: %v", err)
} }
if usedDefault { if usedDefault {
log.Printf("Config File %s not found, using default local config", configPath) log.Printf("Config File %s not found, using default local config", configPath)
} else { } else {
log.Printf("Config loaded from file: %s", configPath) log.Printf("Config loaded from file: %s", configPath)
} }
// 连接数据库(带重试) // 连接数据库(带重试)
var sqlDB *gorm.DB var sqlDB *gorm.DB
connectWithRetry("MySQL", 10, func() error { connectWithRetry("MySQL", 10, func() error {
var err error var err error
sqlDB, err = db.NewDB(cfg.Database) sqlDB, err = db.NewDB(cfg.Database)
return err return err
}) })
defer db.CloseDB(sqlDB) defer db.CloseDB(sqlDB)
// 连接 Redis(用于流行度更新) // 连接 Redis(用于流行度更新)
cache, err := rediscache.NewFromEnv(&cfg.Redis) cache, err := rediscache.NewFromEnv(&cfg.Redis)
if err != nil { if err != nil {
log.Printf("Redis config error (popularity worker disabled): %v", err) log.Printf("Redis config error (popularity worker disabled): %v", err)
cache = nil cache = nil
} else { } else {
pingCtx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond) pingCtx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
defer cancel() defer cancel()
if err := cache.Ping(pingCtx); err != nil { if err := cache.Ping(pingCtx); err != nil {
log.Printf("Redis not available (popularity worker disabled): %v", err) log.Printf("Redis not available (popularity worker disabled): %v", err)
_ = cache.Close() _ = cache.Close()
cache = nil cache = nil
} else { } else {
defer cache.Close() defer cache.Close()
log.Printf("Redis connected (popularity worker enabled)") log.Printf("Redis connected (popularity worker enabled)")
} }
} }
// 连接 RabbitMQ(带重试) // 连接 RabbitMQ(带重试)
url := "amqp://" + cfg.RabbitMQ.Username + ":" + cfg.RabbitMQ.Password + "@" + cfg.RabbitMQ.Host + ":" + strconv.Itoa(cfg.RabbitMQ.Port) + "/" url := "amqp://" + cfg.RabbitMQ.Username + ":" + cfg.RabbitMQ.Password + "@" + cfg.RabbitMQ.Host + ":" + strconv.Itoa(cfg.RabbitMQ.Port) + "/"
var conn *amqp.Connection var conn *amqp.Connection
connectWithRetry("RabbitMQ", 10, func() error { connectWithRetry("RabbitMQ", 10, func() error {
var err error var err error
conn, err = amqp.Dial(url) conn, err = amqp.Dial(url)
return err return err
}) })
defer conn.Close() defer conn.Close()
// 创建 RabbitMQ 通道 // 创建 RabbitMQ 通道
ch, err := conn.Channel() ch, err := conn.Channel()
if err != nil { if err != nil {
log.Fatalf("Failed to open rabbitmq channel: %v", err) log.Fatalf("Failed to open rabbitmq channel: %v", err)
} }
defer ch.Close() defer ch.Close()
// 声明 Social 交换机和队列 // 声明 Social 交换机和队列
if err := declareSocialTopology(ch); err != nil { if err := declareSocialTopology(ch); err != nil {
log.Fatalf("Failed to declare social topology: %v", err) log.Fatalf("Failed to declare social topology: %v", err)
} }
if err := declareLikeTopology(ch); err != nil { if err := declareLikeTopology(ch); err != nil {
log.Fatalf("Failed to declare like topology: %v", err) log.Fatalf("Failed to declare like topology: %v", err)
} }
if err := declareCommentTopology(ch); err != nil { if err := declareCommentTopology(ch); err != nil {
log.Fatalf("Failed to declare comment topology: %v", err) log.Fatalf("Failed to declare comment topology: %v", err)
} }
if cache != nil { if cache != nil {
if err := declarePopularityTopology(ch); err != nil { if err := declarePopularityTopology(ch); err != nil {
log.Fatalf("Failed to declare popularity topology: %v", err) log.Fatalf("Failed to declare popularity topology: %v", err)
} }
} }
if err := ch.Qos(50, 0, false); err != nil { if err := ch.Qos(50, 0, false); err != nil {
log.Fatalf("Failed to set qos: %v", err) log.Fatalf("Failed to set qos: %v", err)
} }
repo := social.NewSocialRepository(sqlDB) repo := social.NewSocialRepository(sqlDB)
socialWorker := worker.NewSocialWorker(ch, repo, socialQueue) socialWorker := worker.NewSocialWorker(ch, repo, socialQueue)
videoRepo := video.NewVideoRepository(sqlDB) videoRepo := video.NewVideoRepository(sqlDB)
likeRepo := video.NewLikeRepository(sqlDB) likeRepo := video.NewLikeRepository(sqlDB)
commentRepo := video.NewCommentRepository(sqlDB) commentRepo := video.NewCommentRepository(sqlDB)
likeWorker := worker.NewLikeWorker(ch, likeRepo, videoRepo, likeQueue) likeWorker := worker.NewLikeWorker(ch, likeRepo, videoRepo, likeQueue)
commentWorker := worker.NewCommentWorker(ch, commentRepo, videoRepo, commentQueue) commentWorker := worker.NewCommentWorker(ch, commentRepo, videoRepo, commentQueue)
var popularityWorker *worker.PopularityWorker var popularityWorker *worker.PopularityWorker
if cache != nil { if cache != nil {
popularityWorker = worker.NewPopularityWorker(ch, cache, popularityQueue) popularityWorker = worker.NewPopularityWorker(ch, cache, popularityQueue)
} }
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop() defer stop()
pprofServer, err := observability.NewPprofServer( pprofServer, err := observability.NewPprofServer(
"Worker", "Worker",
cfg.ObservabilityConfig.Pprof.Enabled, cfg.ObservabilityConfig.Pprof.Enabled,
cfg.ObservabilityConfig.Pprof.WorkerAddr, cfg.ObservabilityConfig.Pprof.WorkerAddr,
) )
if err != nil { if err != nil {
log.Printf("Failed to start worker pprof server: %v", err) log.Printf("Failed to start worker pprof server: %v", err)
} }
if pprofServer != nil { if pprofServer != nil {
defer pprofServer.Close() defer pprofServer.Close()
} }
errCh := make(chan error, 4) errCh := make(chan error, 4)
log.Printf("Worker started, consuming queue=%s", socialQueue) log.Printf("Worker started, consuming queue=%s", socialQueue)
go func() { errCh <- socialWorker.Run(ctx) }() go func() { errCh <- socialWorker.Run(ctx) }()
log.Printf("Worker started, consuming queue=%s", likeQueue) log.Printf("Worker started, consuming queue=%s", likeQueue)
go func() { errCh <- likeWorker.Run(ctx) }() go func() { errCh <- likeWorker.Run(ctx) }()
log.Printf("Worker started, consuming queue=%s", commentQueue) log.Printf("Worker started, consuming queue=%s", commentQueue)
go func() { errCh <- commentWorker.Run(ctx) }() go func() { errCh <- commentWorker.Run(ctx) }()
if popularityWorker != nil { if popularityWorker != nil {
log.Printf("Worker started, consuming queue=%s", popularityQueue) log.Printf("Worker started, consuming queue=%s", popularityQueue)
go func() { errCh <- popularityWorker.Run(ctx) }() go func() { errCh <- popularityWorker.Run(ctx) }()
} }
err = <-errCh err = <-errCh
if err != nil && err != context.Canceled { if err != nil && err != context.Canceled {
log.Fatalf("Worker stopped: %v", err) log.Fatalf("Worker stopped: %v", err)
} }
log.Printf("Worker stopped") log.Printf("Worker stopped")
} }
func declareSocialTopology(ch *amqp.Channel) error { func declareSocialTopology(ch *amqp.Channel) error {
if err := ch.ExchangeDeclare( if err := ch.ExchangeDeclare(
socialExchange, socialExchange,
"topic", "topic",
true, true,
false, false,
false, false,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
q, err := ch.QueueDeclare( q, err := ch.QueueDeclare(
socialQueue, socialQueue,
true, true,
false, false,
false, false,
false, false,
amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange}, amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange},
) )
if err != nil { if err != nil {
return err return err
} }
if err := ch.QueueBind( if err := ch.QueueBind(
q.Name, q.Name,
socialBindingKey, socialBindingKey,
socialExchange, socialExchange,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
return nil return nil
} }
func declarePopularityTopology(ch *amqp.Channel) error { func declarePopularityTopology(ch *amqp.Channel) error {
if err := ch.ExchangeDeclare( if err := ch.ExchangeDeclare(
popularityExchange, popularityExchange,
"topic", "topic",
true, true,
false, false,
false, false,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
q, err := ch.QueueDeclare( q, err := ch.QueueDeclare(
popularityQueue, popularityQueue,
true, true,
false, false,
false, false,
false, false,
amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange}, amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange},
) )
if err != nil { if err != nil {
return err return err
} }
return ch.QueueBind( return ch.QueueBind(
q.Name, q.Name,
popularityBindingKey, popularityBindingKey,
popularityExchange, popularityExchange,
false, false,
nil, nil,
) )
} }
func declareLikeTopology(ch *amqp.Channel) error { func declareLikeTopology(ch *amqp.Channel) error {
if err := ch.ExchangeDeclare( if err := ch.ExchangeDeclare(
likeExchange, likeExchange,
"topic", "topic",
true, true,
false, false,
false, false,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
q, err := ch.QueueDeclare( q, err := ch.QueueDeclare(
likeQueue, likeQueue,
true, true,
false, false,
false, false,
false, false,
amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange}, amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange},
) )
if err != nil { if err != nil {
return err return err
} }
return ch.QueueBind( return ch.QueueBind(
q.Name, q.Name,
likeBindingKey, likeBindingKey,
likeExchange, likeExchange,
false, false,
nil, nil,
) )
} }
func declareCommentTopology(ch *amqp.Channel) error { func declareCommentTopology(ch *amqp.Channel) error {
if err := ch.ExchangeDeclare( if err := ch.ExchangeDeclare(
commentExchange, commentExchange,
"topic", "topic",
true, true,
false, false,
false, false,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
q, err := ch.QueueDeclare( q, err := ch.QueueDeclare(
commentQueue, commentQueue,
true, true,
false, false,
false, false,
false, false,
amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange}, amqp.Table{"x-dead-letter-exchange": mqrabbit.DLXExchange},
) )
if err != nil { if err != nil {
return err return err
} }
return ch.QueueBind( return ch.QueueBind(
q.Name, q.Name,
commentBindingKey, commentBindingKey,
commentExchange, commentExchange,
false, false,
nil, nil,
) )
} }

View File

@@ -1,79 +1,79 @@
package account package account
type Account struct { type Account struct {
ID uint `gorm:"primaryKey" json:"id"` ID uint `gorm:"primaryKey" json:"id"`
Username string `gorm:"unique" json:"username"` Username string `gorm:"unique" json:"username"`
Password string `json:"-"` Password string `json:"-"`
Token string `json:"-"` Token string `json:"-"`
RefreshToken string `json:"-"` RefreshToken string `json:"-"`
AvatarURL string `gorm:"type:varchar(512)" json:"avatar_url,omitempty"` AvatarURL string `gorm:"type:varchar(512)" json:"avatar_url,omitempty"`
Bio string `gorm:"type:varchar(255)" json:"bio,omitempty"` Bio string `gorm:"type:varchar(255)" json:"bio,omitempty"`
} }
type CreateAccountRequest struct { type CreateAccountRequest struct {
Username string `json:"username"` Username string `json:"username"`
Password string `json:"password"` Password string `json:"password"`
} }
type RenameRequest struct { type RenameRequest struct {
NewUsername string `json:"new_username"` NewUsername string `json:"new_username"`
} }
type FindByIDRequest struct { type FindByIDRequest struct {
ID uint `json:"id"` ID uint `json:"id"`
} }
type FindByIDResponse struct { type FindByIDResponse struct {
ID uint `json:"id"` ID uint `json:"id"`
Username string `json:"username"` Username string `json:"username"`
AvatarURL string `json:"avatar_url,omitempty"` AvatarURL string `json:"avatar_url,omitempty"`
Bio string `json:"bio,omitempty"` Bio string `json:"bio,omitempty"`
} }
type FindByUsernameRequest struct { type FindByUsernameRequest struct {
Username string `json:"username"` Username string `json:"username"`
} }
type FindByUsernameResponse struct { type FindByUsernameResponse struct {
ID uint `json:"id"` ID uint `json:"id"`
Username string `json:"username"` Username string `json:"username"`
} }
type ChangePasswordRequest struct { type ChangePasswordRequest struct {
Username string `json:"username"` Username string `json:"username"`
OldPassword string `json:"old_password"` OldPassword string `json:"old_password"`
NewPassword string `json:"new_password"` NewPassword string `json:"new_password"`
} }
type LoginRequest struct { type LoginRequest struct {
Username string `json:"username"` Username string `json:"username"`
Password string `json:"password"` Password string `json:"password"`
} }
type LoginResponse struct { type LoginResponse struct {
Token string `json:"token"` Token string `json:"token"`
RefreshToken string `json:"refresh_token"` RefreshToken string `json:"refresh_token"`
AccountID uint `json:"account_id"` AccountID uint `json:"account_id"`
Username string `json:"username"` Username string `json:"username"`
} }
type UpdateProfileRequest struct { type UpdateProfileRequest struct {
AvatarURL string `json:"avatar_url"` AvatarURL string `json:"avatar_url"`
Bio string `json:"bio"` Bio string `json:"bio"`
} }
type RefreshRequest struct { type RefreshRequest struct {
RefreshToken string `json:"refresh_token"` RefreshToken string `json:"refresh_token"`
} }
type GetProfileRequest struct { type GetProfileRequest struct {
AccountID uint `json:"account_id"` AccountID uint `json:"account_id"`
} }
type GetProfileResponse struct { type GetProfileResponse struct {
Account FindByIDResponse `json:"account"` Account FindByIDResponse `json:"account"`
VideoCount int64 `json:"video_count"` VideoCount int64 `json:"video_count"`
TotalLikes int64 `json:"total_likes"` TotalLikes int64 `json:"total_likes"`
FollowerCount int64 `json:"follower_count"` FollowerCount int64 `json:"follower_count"`
VloggerCount int64 `json:"vlogger_count"` VloggerCount int64 `json:"vlogger_count"`
} }

View File

@@ -1,257 +1,257 @@
package account package account
import ( import (
"crypto/rand" "crypto/rand"
"encoding/hex" "encoding/hex"
"errors" "errors"
"fmt" "fmt"
"net/http" "net/http"
"os" "os"
"path" "path"
"path/filepath" "path/filepath"
"strconv" "strconv"
"strings" "strings"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/apierror"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"gorm.io/gorm" "gorm.io/gorm"
) )
type AccountHandler struct { type AccountHandler struct {
accountService *AccountService accountService *AccountService
} }
func NewAccountHandler(accountService *AccountService) *AccountHandler { func NewAccountHandler(accountService *AccountService) *AccountHandler {
return &AccountHandler{accountService: accountService} return &AccountHandler{accountService: accountService}
} }
func (h *AccountHandler) CreateAccount(c *gin.Context) { func (h *AccountHandler) CreateAccount(c *gin.Context) {
var req CreateAccountRequest var req CreateAccountRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := h.accountService.CreateAccount(c.Request.Context(), &Account{ if err := h.accountService.CreateAccount(c.Request.Context(), &Account{
Username: req.Username, Username: req.Username,
Password: req.Password, Password: req.Password,
}); err != nil { }); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "account created"}) c.JSON(200, gin.H{"message": "account created"})
} }
func (h *AccountHandler) Rename(c *gin.Context) { func (h *AccountHandler) Rename(c *gin.Context) {
var req RenameRequest var req RenameRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
accountID, err := getAccountID(c) accountID, err := getAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
token, err := h.accountService.Rename(c.Request.Context(), accountID, req.NewUsername) token, err := h.accountService.Rename(c.Request.Context(), accountID, req.NewUsername)
if err != nil { if err != nil {
if errors.Is(err, ErrNewUsernameRequired) { if errors.Is(err, ErrNewUsernameRequired) {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if errors.Is(err, ErrUsernameTaken) { if errors.Is(err, ErrUsernameTaken) {
c.JSON(409, gin.H{"error": err.Error()}) c.JSON(409, gin.H{"error": err.Error()})
return return
} }
if errors.Is(err, gorm.ErrRecordNotFound) { if errors.Is(err, gorm.ErrRecordNotFound) {
c.JSON(404, gin.H{"error": "account not found"}) c.JSON(404, gin.H{"error": "account not found"})
return return
} }
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"token": token}) c.JSON(200, gin.H{"token": token})
} }
func (h *AccountHandler) ChangePassword(c *gin.Context) { func (h *AccountHandler) ChangePassword(c *gin.Context) {
var req ChangePasswordRequest var req ChangePasswordRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := h.accountService.ChangePassword(c.Request.Context(), req.Username, req.OldPassword, req.NewPassword); err != nil { if err := h.accountService.ChangePassword(c.Request.Context(), req.Username, req.OldPassword, req.NewPassword); err != nil {
c.JSON(400, gin.H{"error": "unsuccessfully password changed"}) c.JSON(400, gin.H{"error": "unsuccessfully password changed"})
return return
} }
c.JSON(200, gin.H{"message": "successfully password changed"}) c.JSON(200, gin.H{"message": "successfully password changed"})
} }
func (h *AccountHandler) FindByID(c *gin.Context) { func (h *AccountHandler) FindByID(c *gin.Context) {
var req FindByIDRequest var req FindByIDRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if account, err := h.accountService.FindByID(c.Request.Context(), req.ID); err != nil { if account, err := h.accountService.FindByID(c.Request.Context(), req.ID); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} else { } else {
c.JSON(200, account) c.JSON(200, account)
} }
} }
func (h *AccountHandler) FindByUsername(c *gin.Context) { func (h *AccountHandler) FindByUsername(c *gin.Context) {
var req FindByUsernameRequest var req FindByUsernameRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if account, err := h.accountService.FindByUsername(c.Request.Context(), req.Username); err != nil { if account, err := h.accountService.FindByUsername(c.Request.Context(), req.Username); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} else { } else {
c.JSON(200, account) c.JSON(200, account)
} }
} }
func (h *AccountHandler) Login(c *gin.Context) { func (h *AccountHandler) Login(c *gin.Context) {
var req LoginRequest var req LoginRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
account, err := h.accountService.FindByUsername(c.Request.Context(), req.Username) account, err := h.accountService.FindByUsername(c.Request.Context(), req.Username)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
accessToken, refreshToken, err := h.accountService.Login(c.Request.Context(), req.Username, req.Password) accessToken, refreshToken, err := h.accountService.Login(c.Request.Context(), req.Username, req.Password)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, LoginResponse{Token: accessToken, RefreshToken: refreshToken, AccountID: account.ID, Username: account.Username}) c.JSON(200, LoginResponse{Token: accessToken, RefreshToken: refreshToken, AccountID: account.ID, Username: account.Username})
} }
func (h *AccountHandler) Logout(c *gin.Context) { func (h *AccountHandler) Logout(c *gin.Context) {
accountID, err := getAccountID(c) accountID, err := getAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := h.accountService.Logout(c.Request.Context(), accountID); err != nil { if err := h.accountService.Logout(c.Request.Context(), accountID); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "account logged out"}) c.JSON(200, gin.H{"message": "account logged out"})
} }
func (h *AccountHandler) UploadAvatar(c *gin.Context) { func (h *AccountHandler) UploadAvatar(c *gin.Context) {
accountID, err := getAccountID(c) accountID, err := getAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
f, err := c.FormFile("file") f, err := c.FormFile("file")
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"}) c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"})
return return
} }
const maxSize = 10 << 20 const maxSize = 10 << 20
if f.Size <= 0 || f.Size > maxSize { if f.Size <= 0 || f.Size > maxSize {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"}) c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"})
return return
} }
ext := strings.ToLower(filepath.Ext(f.Filename)) ext := strings.ToLower(filepath.Ext(f.Filename))
switch ext { switch ext {
case ".jpg", ".jpeg", ".png", ".webp": case ".jpg", ".jpeg", ".png", ".webp":
default: default:
c.JSON(http.StatusBadRequest, gin.H{"error": "only .jpg/.jpeg/.png/.webp allowed"}) c.JSON(http.StatusBadRequest, gin.H{"error": "only .jpg/.jpeg/.png/.webp allowed"})
return return
} }
dir := filepath.Join(".run", "uploads", "avatars", strconv.FormatUint(uint64(accountID), 10)) dir := filepath.Join(".run", "uploads", "avatars", strconv.FormatUint(uint64(accountID), 10))
if err := os.MkdirAll(dir, 0o755); err != nil { if err := os.MkdirAll(dir, 0o755); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
filename, err := randHex(16) filename, err := randHex(16)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
filename = filename + ext filename = filename + ext
absPath := filepath.Join(dir, filename) absPath := filepath.Join(dir, filename)
if err := c.SaveUploadedFile(f, absPath); err != nil { if err := c.SaveUploadedFile(f, absPath); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
urlPath := path.Join("/static", "avatars", strconv.FormatUint(uint64(accountID), 10), filename) urlPath := path.Join("/static", "avatars", strconv.FormatUint(uint64(accountID), 10), filename)
avatarURL := buildAbsoluteURL(c, urlPath) avatarURL := buildAbsoluteURL(c, urlPath)
if err := h.accountService.UpdateAvatar(c.Request.Context(), accountID, avatarURL); err != nil { if err := h.accountService.UpdateAvatar(c.Request.Context(), accountID, avatarURL); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
c.JSON(http.StatusOK, gin.H{"avatar_url": avatarURL}) c.JSON(http.StatusOK, gin.H{"avatar_url": avatarURL})
} }
func (h *AccountHandler) UpdateProfile(c *gin.Context) { func (h *AccountHandler) UpdateProfile(c *gin.Context) {
accountID, err := getAccountID(c) accountID, err := getAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
var req UpdateProfileRequest var req UpdateProfileRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := h.accountService.UpdateProfile(c.Request.Context(), accountID, &req); err != nil { if err := h.accountService.UpdateProfile(c.Request.Context(), accountID, &req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(http.StatusOK, gin.H{"message": "profile updated"}) c.JSON(http.StatusOK, gin.H{"message": "profile updated"})
} }
func (h *AccountHandler) Refresh(c *gin.Context) { func (h *AccountHandler) Refresh(c *gin.Context) {
var req RefreshRequest var req RefreshRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
newToken, accountID, username, err := h.accountService.RefreshAccessToken(c.Request.Context(), req.RefreshToken) newToken, accountID, username, err := h.accountService.RefreshAccessToken(c.Request.Context(), req.RefreshToken)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid refresh token"}) c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid refresh token"})
return return
} }
c.JSON(http.StatusOK, LoginResponse{Token: newToken, AccountID: accountID, Username: username}) c.JSON(http.StatusOK, LoginResponse{Token: newToken, AccountID: accountID, Username: username})
} }
func randHex(n int) (string, error) { func randHex(n int) (string, error) {
b := make([]byte, n) b := make([]byte, n)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
return "", fmt.Errorf("rand.Read: %w", err) return "", fmt.Errorf("rand.Read: %w", err)
} }
return hex.EncodeToString(b), nil return hex.EncodeToString(b), nil
} }
func buildAbsoluteURL(c *gin.Context, p string) string { func buildAbsoluteURL(c *gin.Context, p string) string {
scheme := "http" scheme := "http"
if c.Request.TLS != nil { if c.Request.TLS != nil {
scheme = "https" scheme = "https"
} }
if xf := c.GetHeader("X-Forwarded-Proto"); xf != "" { if xf := c.GetHeader("X-Forwarded-Proto"); xf != "" {
scheme = xf scheme = xf
} }
return fmt.Sprintf("%s://%s%s", scheme, c.Request.Host, p) return fmt.Sprintf("%s://%s%s", scheme, c.Request.Host, p)
} }
func getAccountID(c *gin.Context) (uint, error) { func getAccountID(c *gin.Context) (uint, error) {
value, exists := c.Get("accountID") value, exists := c.Get("accountID")
if !exists { if !exists {
return 0, errors.New("accountID not found") return 0, errors.New("accountID not found")
} }
id, ok := value.(uint) id, ok := value.(uint)
if !ok { if !ok {
return 0, errors.New("accountID has invalid type") return 0, errors.New("accountID has invalid type")
} }
return id, nil return id, nil
} }

View File

@@ -1,106 +1,106 @@
package account package account
import ( import (
"context" "context"
"gorm.io/gorm" "gorm.io/gorm"
) )
type AccountRepository struct { type AccountRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewAccountRepository(db *gorm.DB) *AccountRepository { func NewAccountRepository(db *gorm.DB) *AccountRepository {
return &AccountRepository{db: db} return &AccountRepository{db: db}
} }
func (ar *AccountRepository) CreateAccount(ctx context.Context, account *Account) error { func (ar *AccountRepository) CreateAccount(ctx context.Context, account *Account) error {
if err := ar.db.WithContext(ctx).Create(account).Error; err != nil { if err := ar.db.WithContext(ctx).Create(account).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (ar *AccountRepository) Rename(ctx context.Context, id uint, newUsername string) error { func (ar *AccountRepository) Rename(ctx context.Context, id uint, newUsername string) error {
result := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("username", newUsername) result := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("username", newUsername)
if result.Error != nil { if result.Error != nil {
return result.Error return result.Error
} }
if result.RowsAffected == 0 { if result.RowsAffected == 0 {
return gorm.ErrRecordNotFound return gorm.ErrRecordNotFound
} }
return nil return nil
} }
func (ar *AccountRepository) RenameWithToken(ctx context.Context, id uint, newUsername string, token string) error { func (ar *AccountRepository) RenameWithToken(ctx context.Context, id uint, newUsername string, token string) error {
return ar.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { return ar.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
result := tx.Model(&Account{}).Where("id = ?", id).Update("username", newUsername) result := tx.Model(&Account{}).Where("id = ?", id).Update("username", newUsername)
if result.Error != nil { if result.Error != nil {
return result.Error return result.Error
} }
if result.RowsAffected == 0 { if result.RowsAffected == 0 {
return gorm.ErrRecordNotFound return gorm.ErrRecordNotFound
} }
if err := tx.Model(&Account{}).Where("id = ?", id).Update("token", token).Error; err != nil { if err := tx.Model(&Account{}).Where("id = ?", id).Update("token", token).Error; err != nil {
return err return err
} }
return nil return nil
}) })
} }
func (ar *AccountRepository) ChangePassword(ctx context.Context, id uint, newPassword string) error { func (ar *AccountRepository) ChangePassword(ctx context.Context, id uint, newPassword string) error {
if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("password", newPassword).Error; err != nil { if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("password", newPassword).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (ar *AccountRepository) FindByID(ctx context.Context, id uint) (*Account, error) { func (ar *AccountRepository) FindByID(ctx context.Context, id uint) (*Account, error) {
var account Account var account Account
if err := ar.db.WithContext(ctx).First(&account, id).Error; err != nil { if err := ar.db.WithContext(ctx).First(&account, id).Error; err != nil {
return nil, err return nil, err
} }
return &account, nil return &account, nil
} }
func (ar *AccountRepository) FindByUsername(ctx context.Context, username string) (*Account, error) { func (ar *AccountRepository) FindByUsername(ctx context.Context, username string) (*Account, error) {
var account Account var account Account
if err := ar.db.WithContext(ctx).Where("username = ?", username).First(&account).Error; err != nil { if err := ar.db.WithContext(ctx).Where("username = ?", username).First(&account).Error; err != nil {
return nil, err return nil, err
} }
return &account, nil return &account, nil
} }
func (ar *AccountRepository) Login(ctx context.Context, id uint, token, refreshToken string) error { func (ar *AccountRepository) Login(ctx context.Context, id uint, token, refreshToken string) error {
if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(map[string]interface{}{"token": token, "refresh_token": refreshToken}).Error; err != nil { if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(map[string]interface{}{"token": token, "refresh_token": refreshToken}).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (ar *AccountRepository) Logout(ctx context.Context, id uint) error { func (ar *AccountRepository) Logout(ctx context.Context, id uint) error {
if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(map[string]interface{}{"token": "", "refresh_token": ""}).Error; err != nil { if err := ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(map[string]interface{}{"token": "", "refresh_token": ""}).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (ar *AccountRepository) UpdateAvatar(ctx context.Context, accountID uint, avatarURL string) error { func (ar *AccountRepository) UpdateAvatar(ctx context.Context, accountID uint, avatarURL string) error {
return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", accountID).Update("avatar_url", avatarURL).Error return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", accountID).Update("avatar_url", avatarURL).Error
} }
func (ar *AccountRepository) UpdateToken(ctx context.Context, id uint, token string) error { func (ar *AccountRepository) UpdateToken(ctx context.Context, id uint, token string) error {
return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("token", token).Error return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Update("token", token).Error
} }
func (ar *AccountRepository) UpdateFields(ctx context.Context, id uint, updates map[string]interface{}) error { func (ar *AccountRepository) UpdateFields(ctx context.Context, id uint, updates map[string]interface{}) error {
return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(updates).Error return ar.db.WithContext(ctx).Model(&Account{}).Where("id = ?", id).Updates(updates).Error
} }
func (ar *AccountRepository) FindAll(ctx context.Context) ([]*Account, error) { func (ar *AccountRepository) FindAll(ctx context.Context) ([]*Account, error) {
var accounts []*Account var accounts []*Account
if err := ar.db.WithContext(ctx).Find(&accounts).Error; err != nil { if err := ar.db.WithContext(ctx).Find(&accounts).Error; err != nil {
return nil, err return nil, err
} }
return accounts, nil return accounts, nil
} }

View File

@@ -1,236 +1,236 @@
package account package account
import ( import (
"context" "context"
"errors" "errors"
"feedsystem_video_go/internal/auth" "feedsystem_video_go/internal/auth"
"log" "log"
"strconv" "strconv"
"strings" "strings"
"time" "time"
rediscache "feedsystem_video_go/internal/middleware/redis" rediscache "feedsystem_video_go/internal/middleware/redis"
"github.com/go-sql-driver/mysql" "github.com/go-sql-driver/mysql"
"golang.org/x/crypto/bcrypt" "golang.org/x/crypto/bcrypt"
"gorm.io/gorm" "gorm.io/gorm"
) )
type AccountService struct { type AccountService struct {
accountRepository *AccountRepository accountRepository *AccountRepository
cache *rediscache.Client cache *rediscache.Client
} }
var ( var (
ErrUsernameTaken = errors.New("username already exists") ErrUsernameTaken = errors.New("username already exists")
ErrNewUsernameRequired = errors.New("new_username is required") ErrNewUsernameRequired = errors.New("new_username is required")
) )
func NewAccountService(accountRepository *AccountRepository, cache *rediscache.Client) *AccountService { func NewAccountService(accountRepository *AccountRepository, cache *rediscache.Client) *AccountService {
return &AccountService{accountRepository: accountRepository, cache: cache} return &AccountService{accountRepository: accountRepository, cache: cache}
} }
func (as *AccountService) CreateAccount(ctx context.Context, account *Account) error { func (as *AccountService) CreateAccount(ctx context.Context, account *Account) error {
passwordHash, err := bcrypt.GenerateFromPassword([]byte(account.Password), bcrypt.DefaultCost) passwordHash, err := bcrypt.GenerateFromPassword([]byte(account.Password), bcrypt.DefaultCost)
if err != nil { if err != nil {
return err return err
} }
account.Password = string(passwordHash) account.Password = string(passwordHash)
if err := as.accountRepository.CreateAccount(ctx, account); err != nil { if err := as.accountRepository.CreateAccount(ctx, account); err != nil {
return err return err
} }
return nil return nil
} }
func (as *AccountService) Rename(ctx context.Context, accountID uint, newUsername string) (string, error) { func (as *AccountService) Rename(ctx context.Context, accountID uint, newUsername string) (string, error) {
if newUsername == "" { if newUsername == "" {
return "", ErrNewUsernameRequired return "", ErrNewUsernameRequired
} }
token, err := auth.GenerateToken(accountID, newUsername) token, err := auth.GenerateToken(accountID, newUsername)
if err != nil { if err != nil {
return "", err return "", err
} }
if err := as.accountRepository.RenameWithToken(ctx, accountID, newUsername, token); err != nil { if err := as.accountRepository.RenameWithToken(ctx, accountID, newUsername, token); err != nil {
var mysqlErr *mysql.MySQLError var mysqlErr *mysql.MySQLError
if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 { if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
return "", ErrUsernameTaken return "", ErrUsernameTaken
} }
if errors.Is(err, gorm.ErrRecordNotFound) { if errors.Is(err, gorm.ErrRecordNotFound) {
return "", err return "", err
} }
return "", err return "", err
} }
if as.cache != nil { if as.cache != nil {
cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", accountID), []byte(token), 24*time.Hour); err != nil { if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", accountID), []byte(token), 24*time.Hour); err != nil {
log.Printf("failed to set cache: %v", err) log.Printf("failed to set cache: %v", err)
} }
} }
return token, nil return token, nil
} }
func (as *AccountService) ChangePassword(ctx context.Context, username, oldPassword, newPassword string) error { func (as *AccountService) ChangePassword(ctx context.Context, username, oldPassword, newPassword string) error {
account, err := as.FindByUsername(ctx, username) account, err := as.FindByUsername(ctx, username)
if err != nil { if err != nil {
return err return err
} }
if err := bcrypt.CompareHashAndPassword([]byte(account.Password), []byte(oldPassword)); err != nil { if err := bcrypt.CompareHashAndPassword([]byte(account.Password), []byte(oldPassword)); err != nil {
return err return err
} }
passwordHash, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost) passwordHash, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
if err != nil { if err != nil {
return err return err
} }
if err := as.accountRepository.ChangePassword(ctx, account.ID, string(passwordHash)); err != nil { if err := as.accountRepository.ChangePassword(ctx, account.ID, string(passwordHash)); err != nil {
return err return err
} }
if err := as.Logout(ctx, account.ID); err != nil { if err := as.Logout(ctx, account.ID); err != nil {
return err return err
} }
return nil return nil
} }
func (as *AccountService) FindByID(ctx context.Context, id uint) (*Account, error) { func (as *AccountService) FindByID(ctx context.Context, id uint) (*Account, error) {
if account, err := as.accountRepository.FindByID(ctx, id); err != nil { if account, err := as.accountRepository.FindByID(ctx, id); err != nil {
return nil, err return nil, err
} else { } else {
return account, nil return account, nil
} }
} }
func (as *AccountService) FindByUsername(ctx context.Context, username string) (*Account, error) { func (as *AccountService) FindByUsername(ctx context.Context, username string) (*Account, error) {
if account, err := as.accountRepository.FindByUsername(ctx, username); err != nil { if account, err := as.accountRepository.FindByUsername(ctx, username); err != nil {
return nil, err return nil, err
} else { } else {
return account, nil return account, nil
} }
} }
func (as *AccountService) Login(ctx context.Context, username, password string) (string, string, error) { func (as *AccountService) Login(ctx context.Context, username, password string) (string, string, error) {
account, err := as.FindByUsername(ctx, username) account, err := as.FindByUsername(ctx, username)
if err != nil { if err != nil {
return "", "", err return "", "", err
} }
if err := bcrypt.CompareHashAndPassword([]byte(account.Password), []byte(password)); err != nil { if err := bcrypt.CompareHashAndPassword([]byte(account.Password), []byte(password)); err != nil {
return "", "", err return "", "", err
} }
accessToken, err := auth.GenerateToken(account.ID, account.Username) accessToken, err := auth.GenerateToken(account.ID, account.Username)
if err != nil { if err != nil {
return "", "", err return "", "", err
} }
refreshToken, err := auth.GenerateRefreshToken(account.ID) refreshToken, err := auth.GenerateRefreshToken(account.ID)
if err != nil { if err != nil {
return "", "", err return "", "", err
} }
if err := as.accountRepository.Login(ctx, account.ID, accessToken, refreshToken); err != nil { if err := as.accountRepository.Login(ctx, account.ID, accessToken, refreshToken); err != nil {
return "", "", err return "", "", err
} }
if as.cache != nil { if as.cache != nil {
cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", account.ID), []byte(accessToken), 24*time.Hour); err != nil { if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", account.ID), []byte(accessToken), 24*time.Hour); err != nil {
log.Printf("failed to set cache: %v", err) log.Printf("failed to set cache: %v", err)
} }
if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d:refresh", account.ID), []byte(refreshToken), 7*24*time.Hour); err != nil { if err := as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d:refresh", account.ID), []byte(refreshToken), 7*24*time.Hour); err != nil {
log.Printf("failed to set refresh cache: %v", err) log.Printf("failed to set refresh cache: %v", err)
} }
if err := as.cache.SetBytes(cacheCtx, as.cache.Key("refresh:%s", refreshToken), []byte(strconv.FormatUint(uint64(account.ID), 10)), 7*24*time.Hour); err != nil { if err := as.cache.SetBytes(cacheCtx, as.cache.Key("refresh:%s", refreshToken), []byte(strconv.FormatUint(uint64(account.ID), 10)), 7*24*time.Hour); err != nil {
log.Printf("failed to set refresh lookup: %v", err) log.Printf("failed to set refresh lookup: %v", err)
} }
} }
return accessToken, refreshToken, nil return accessToken, refreshToken, nil
} }
func (as *AccountService) Logout(ctx context.Context, accountID uint) error { func (as *AccountService) Logout(ctx context.Context, accountID uint) error {
account, err := as.FindByID(ctx, accountID) account, err := as.FindByID(ctx, accountID)
if err != nil { if err != nil {
return err return err
} }
if account.Token == "" { if account.Token == "" {
return nil return nil
} }
if as.cache != nil { if as.cache != nil {
cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
if err := as.cache.Del(cacheCtx, as.cache.Key("account:%d", account.ID)); err != nil { if err := as.cache.Del(cacheCtx, as.cache.Key("account:%d", account.ID)); err != nil {
log.Printf("failed to del cache: %v", err) log.Printf("failed to del cache: %v", err)
} }
if err := as.cache.Del(cacheCtx, as.cache.Key("account:%d:refresh", account.ID)); err != nil { if err := as.cache.Del(cacheCtx, as.cache.Key("account:%d:refresh", account.ID)); err != nil {
log.Printf("failed to del refresh cache: %v", err) log.Printf("failed to del refresh cache: %v", err)
} }
if account.RefreshToken != "" { if account.RefreshToken != "" {
as.cache.Del(cacheCtx, as.cache.Key("refresh:%s", account.RefreshToken)) as.cache.Del(cacheCtx, as.cache.Key("refresh:%s", account.RefreshToken))
} }
} }
return as.accountRepository.Logout(ctx, account.ID) return as.accountRepository.Logout(ctx, account.ID)
} }
func (as *AccountService) UpdateAvatar(ctx context.Context, accountID uint, avatarURL string) error { func (as *AccountService) UpdateAvatar(ctx context.Context, accountID uint, avatarURL string) error {
return as.accountRepository.UpdateAvatar(ctx, accountID, avatarURL) return as.accountRepository.UpdateAvatar(ctx, accountID, avatarURL)
} }
func (as *AccountService) FindAll(ctx context.Context) ([]*Account, error) { func (as *AccountService) FindAll(ctx context.Context) ([]*Account, error) {
return as.accountRepository.FindAll(ctx) return as.accountRepository.FindAll(ctx)
} }
func (as *AccountService) UpdateProfile(ctx context.Context, accountID uint, req *UpdateProfileRequest) error { func (as *AccountService) UpdateProfile(ctx context.Context, accountID uint, req *UpdateProfileRequest) error {
updates := map[string]interface{}{} updates := map[string]interface{}{}
if req.Bio != "" { if req.Bio != "" {
updates["bio"] = strings.TrimSpace(req.Bio) updates["bio"] = strings.TrimSpace(req.Bio)
} }
if req.AvatarURL != "" { if req.AvatarURL != "" {
updates["avatar_url"] = strings.TrimSpace(req.AvatarURL) updates["avatar_url"] = strings.TrimSpace(req.AvatarURL)
} }
if len(updates) == 0 { if len(updates) == 0 {
return errors.New("nothing to update") return errors.New("nothing to update")
} }
return as.accountRepository.UpdateFields(ctx, accountID, updates) return as.accountRepository.UpdateFields(ctx, accountID, updates)
} }
func (as *AccountService) RefreshAccessToken(ctx context.Context, refreshToken string) (string, uint, string, error) { func (as *AccountService) RefreshAccessToken(ctx context.Context, refreshToken string) (string, uint, string, error) {
if refreshToken == "" { if refreshToken == "" {
return "", 0, "", errors.New("refresh token is empty") return "", 0, "", errors.New("refresh token is empty")
} }
if as.cache != nil { if as.cache != nil {
cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
b, err := as.cache.GetBytes(cacheCtx, as.cache.Key("refresh:%s", refreshToken)) b, err := as.cache.GetBytes(cacheCtx, as.cache.Key("refresh:%s", refreshToken))
if err == nil { if err == nil {
idStr := string(b) idStr := string(b)
id, parseErr := strconv.ParseUint(idStr, 10, 64) id, parseErr := strconv.ParseUint(idStr, 10, 64)
if parseErr == nil { if parseErr == nil {
account, err := as.FindByID(ctx, uint(id)) account, err := as.FindByID(ctx, uint(id))
if err == nil && account != nil && account.RefreshToken == refreshToken { if err == nil && account != nil && account.RefreshToken == refreshToken {
newToken, err := auth.GenerateToken(account.ID, account.Username) newToken, err := auth.GenerateToken(account.ID, account.Username)
if err != nil { if err != nil {
return "", 0, "", err return "", 0, "", err
} }
as.accountRepository.UpdateToken(ctx, account.ID, newToken) as.accountRepository.UpdateToken(ctx, account.ID, newToken)
as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", account.ID), []byte(newToken), 24*time.Hour) as.cache.SetBytes(cacheCtx, as.cache.Key("account:%d", account.ID), []byte(newToken), 24*time.Hour)
return newToken, account.ID, account.Username, nil return newToken, account.ID, account.Username, nil
} }
} }
} }
} }
accounts, err := as.FindAll(ctx) accounts, err := as.FindAll(ctx)
if err != nil { if err != nil {
return "", 0, "", err return "", 0, "", err
} }
for _, acc := range accounts { for _, acc := range accounts {
if acc.RefreshToken == refreshToken { if acc.RefreshToken == refreshToken {
newToken, err := auth.GenerateToken(acc.ID, acc.Username) newToken, err := auth.GenerateToken(acc.ID, acc.Username)
if err != nil { if err != nil {
return "", 0, "", err return "", 0, "", err
} }
as.accountRepository.UpdateToken(ctx, acc.ID, newToken) as.accountRepository.UpdateToken(ctx, acc.ID, newToken)
return newToken, acc.ID, acc.Username, nil return newToken, acc.ID, acc.Username, nil
} }
} }
return "", 0, "", errors.New("invalid refresh token") return "", 0, "", errors.New("invalid refresh token")
} }

View File

@@ -1,82 +1,82 @@
// internal/auth/jwt.go // internal/auth/jwt.go
package auth package auth
import ( import (
"crypto/rand" "crypto/rand"
"encoding/hex" "encoding/hex"
"errors" "errors"
"log" "log"
"os" "os"
"time" "time"
"github.com/golang-jwt/jwt/v5" "github.com/golang-jwt/jwt/v5"
) )
func jwtSecret() []byte { func jwtSecret() []byte {
secret := os.Getenv("JWT_SECRET") secret := os.Getenv("JWT_SECRET")
if secret == "" { if secret == "" {
b := make([]byte, 32) b := make([]byte, 32)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
log.Printf("FATAL: cannot generate JWT secret: %v", err) log.Printf("FATAL: cannot generate JWT secret: %v", err)
return []byte("fallback-unsafe-key-change-me") return []byte("fallback-unsafe-key-change-me")
} }
secret = hex.EncodeToString(b) secret = hex.EncodeToString(b)
log.Printf("WARNING: JWT_SECRET not set, generated random key. All tokens invalid on restart.") log.Printf("WARNING: JWT_SECRET not set, generated random key. All tokens invalid on restart.")
} }
return []byte(secret) return []byte(secret)
} }
type Claims struct { type Claims struct {
AccountID uint `json:"account_id"` AccountID uint `json:"account_id"`
Username string `json:"username"` Username string `json:"username"`
jwt.RegisteredClaims jwt.RegisteredClaims
} }
func GenerateToken(accountID uint, username string) (string, error) { func GenerateToken(accountID uint, username string) (string, error) {
now := time.Now() now := time.Now()
claims := Claims{ claims := Claims{
AccountID: accountID, AccountID: accountID,
Username: username, Username: username,
RegisteredClaims: jwt.RegisteredClaims{ RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(now.Add(15 * time.Minute)), ExpiresAt: jwt.NewNumericDate(now.Add(15 * time.Minute)),
IssuedAt: jwt.NewNumericDate(now), IssuedAt: jwt.NewNumericDate(now),
NotBefore: jwt.NewNumericDate(now), NotBefore: jwt.NewNumericDate(now),
}, },
} }
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
return token.SignedString(jwtSecret()) return token.SignedString(jwtSecret())
} }
func GenerateRefreshToken(accountID uint) (string, error) { func GenerateRefreshToken(accountID uint) (string, error) {
b := make([]byte, 32) b := make([]byte, 32)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
return "", err return "", err
} }
return hex.EncodeToString(b), nil return hex.EncodeToString(b), nil
} }
func ParseToken(tokenString string) (*Claims, error) { func ParseToken(tokenString string) (*Claims, error) {
token, err := jwt.ParseWithClaims( token, err := jwt.ParseWithClaims(
tokenString, tokenString,
&Claims{}, &Claims{},
func(token *jwt.Token) (interface{}, error) { func(token *jwt.Token) (interface{}, error) {
if token.Method == nil || token.Method.Alg() != jwt.SigningMethodHS256.Alg() { if token.Method == nil || token.Method.Alg() != jwt.SigningMethodHS256.Alg() {
return nil, errors.New("unexpected signing method") return nil, errors.New("unexpected signing method")
} }
return jwtSecret(), nil return jwtSecret(), nil
}, },
) )
if err != nil { if err != nil {
return nil, err return nil, err
} }
claims, ok := token.Claims.(*Claims) claims, ok := token.Claims.(*Claims)
if !ok || !token.Valid { if !ok || !token.Valid {
return nil, jwt.ErrTokenInvalidClaims return nil, jwt.ErrTokenInvalidClaims
} }
return claims, nil return claims, nil
} }

View File

@@ -1,42 +1,42 @@
package db package db
import ( import (
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/config" "feedsystem_video_go/internal/config"
"feedsystem_video_go/internal/message" "feedsystem_video_go/internal/message"
"feedsystem_video_go/internal/social" "feedsystem_video_go/internal/social"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"feedsystem_video_go/internal/worker" "feedsystem_video_go/internal/worker"
"fmt" "fmt"
"gorm.io/driver/mysql" "gorm.io/driver/mysql"
"gorm.io/gorm" "gorm.io/gorm"
) )
func NewDB(dbcfg config.DatabaseConfig) (*gorm.DB, error) { func NewDB(dbcfg config.DatabaseConfig) (*gorm.DB, error) {
dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local", dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local",
dbcfg.User, dbcfg.Password, dbcfg.Host, dbcfg.Port, dbcfg.DBName) dbcfg.User, dbcfg.Password, dbcfg.Host, dbcfg.Port, dbcfg.DBName)
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil { if err != nil {
return nil, err return nil, err
} }
return db, nil return db, nil
} }
func AutoMigrate(db *gorm.DB) error { func AutoMigrate(db *gorm.DB) error {
return db.AutoMigrate( return db.AutoMigrate(
&account.Account{}, &video.Video{}, &video.Like{}, &video.Comment{}, &account.Account{}, &video.Video{}, &video.Like{}, &video.Comment{},
&social.Social{}, &video.OutboxMsg{}, &video.Tag{}, &video.VideoTag{}, &social.Social{}, &video.OutboxMsg{}, &video.Tag{}, &video.VideoTag{},
&message.Message{}, &worker.Notification{}, &message.Message{}, &worker.Notification{},
) )
} }
func CloseDB(db *gorm.DB) error { func CloseDB(db *gorm.DB) error {
sqlDB, err := db.DB() sqlDB, err := db.DB()
if err != nil { if err != nil {
return err return err
} }
return sqlDB.Close() return sqlDB.Close()
} }

View File

@@ -1,82 +1,82 @@
package feed package feed
import "time" import "time"
type FeedAuthor struct { type FeedAuthor struct {
ID uint `json:"id"` ID uint `json:"id"`
Username string `json:"username"` Username string `json:"username"`
} }
type FeedVideoItem struct { type FeedVideoItem struct {
ID uint `json:"id"` ID uint `json:"id"`
Author FeedAuthor `json:"author"` Author FeedAuthor `json:"author"`
Title string `json:"title"` Title string `json:"title"`
Description string `json:"description,omitempty"` Description string `json:"description,omitempty"`
PlayURL string `json:"play_url"` PlayURL string `json:"play_url"`
CoverURL string `json:"cover_url"` CoverURL string `json:"cover_url"`
CreateTime int64 `json:"create_time"` CreateTime int64 `json:"create_time"`
LikesCount int64 `json:"likes_count"` LikesCount int64 `json:"likes_count"`
IsLiked bool `json:"is_liked"` IsLiked bool `json:"is_liked"`
} }
type ListLatestRequest struct { type ListLatestRequest struct {
Limit int `json:"limit"` Limit int `json:"limit"`
LatestTime int64 `json:"latest_time"` LatestTime int64 `json:"latest_time"`
} }
type ListLatestResponse struct { type ListLatestResponse struct {
VideoList []FeedVideoItem `json:"video_list"` VideoList []FeedVideoItem `json:"video_list"`
NextTime int64 `json:"next_time"` NextTime int64 `json:"next_time"`
HasMore bool `json:"has_more"` HasMore bool `json:"has_more"`
} }
type ListLikesCountRequest struct { type ListLikesCountRequest struct {
Limit int `json:"limit"` Limit int `json:"limit"`
LikesCountBefore *int64 `json:"likes_count_before,omitempty"` LikesCountBefore *int64 `json:"likes_count_before,omitempty"`
IDBefore *uint `json:"id_before,omitempty"` IDBefore *uint `json:"id_before,omitempty"`
} }
type LikesCountCursor struct { type LikesCountCursor struct {
LikesCount int64 LikesCount int64
ID uint ID uint
} }
type ListLikesCountResponse struct { type ListLikesCountResponse struct {
VideoList []FeedVideoItem `json:"video_list"` VideoList []FeedVideoItem `json:"video_list"`
NextLikesCountBefore *int64 `json:"next_likes_count_before,omitempty"` NextLikesCountBefore *int64 `json:"next_likes_count_before,omitempty"`
NextIDBefore *uint `json:"next_id_before,omitempty"` NextIDBefore *uint `json:"next_id_before,omitempty"`
HasMore bool `json:"has_more"` HasMore bool `json:"has_more"`
} }
type ListByFollowingRequest struct { type ListByFollowingRequest struct {
Limit int `json:"limit"` Limit int `json:"limit"`
LatestTime int64 `json:"latest_time"` LatestTime int64 `json:"latest_time"`
} }
type ListByFollowingResponse struct { type ListByFollowingResponse struct {
VideoList []FeedVideoItem `json:"video_list"` VideoList []FeedVideoItem `json:"video_list"`
NextTime int64 `json:"next_time"` NextTime int64 `json:"next_time"`
HasMore bool `json:"has_more"` HasMore bool `json:"has_more"`
} }
type ListByPopularityRequest struct { type ListByPopularityRequest struct {
Limit int `json:"limit"` Limit int `json:"limit"`
AsOf int64 `json:"as_of"` // 服务器返回的分钟时间戳;第一页传0 AsOf int64 `json:"as_of"` // 服务器返回的分钟时间戳;第一页传0
Offset int `json:"offset"` // 下一页从这里开始;第一页传0 Offset int `json:"offset"` // 下一页从这里开始;第一页传0
LatestIDBefore *uint `json:"latest_id_before,omitempty"` LatestIDBefore *uint `json:"latest_id_before,omitempty"`
// DB fallback 用(可选) // DB fallback 用(可选)
LatestPopularity int64 `json:"latest_popularity"` LatestPopularity int64 `json:"latest_popularity"`
LatestBefore time.Time `json:"latest_before"` LatestBefore time.Time `json:"latest_before"`
} }
type ListByPopularityResponse struct { type ListByPopularityResponse struct {
VideoList []FeedVideoItem `json:"video_list"` VideoList []FeedVideoItem `json:"video_list"`
AsOf int64 `json:"as_of"` AsOf int64 `json:"as_of"`
NextOffset int `json:"next_offset"` NextOffset int `json:"next_offset"`
HasMore bool `json:"has_more"` HasMore bool `json:"has_more"`
NextLatestPopularity *int64 `json:"next_latest_popularity,omitempty"` NextLatestPopularity *int64 `json:"next_latest_popularity,omitempty"`
NextLatestBefore *time.Time `json:"next_latest_before,omitempty"` NextLatestBefore *time.Time `json:"next_latest_before,omitempty"`
NextLatestIDBefore *uint `json:"next_latest_id_before,omitempty"` NextLatestIDBefore *uint `json:"next_latest_id_before,omitempty"`
} }

View File

@@ -1,201 +1,201 @@
package feed package feed
import ( import (
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/apierror"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/middleware/jwt"
"time" "time"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
type FeedHandler struct { type FeedHandler struct {
service *FeedService service *FeedService
} }
func NewFeedHandler(service *FeedService) *FeedHandler { func NewFeedHandler(service *FeedService) *FeedHandler {
return &FeedHandler{service: service} return &FeedHandler{service: service}
} }
func (f *FeedHandler) ListLatest(c *gin.Context) { func (f *FeedHandler) ListLatest(c *gin.Context) {
var req ListLatestRequest var req ListLatestRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.Limit <= 0 || req.Limit > 50 { if req.Limit <= 0 || req.Limit > 50 {
req.Limit = 10 req.Limit = 10
} }
var latestTime time.Time var latestTime time.Time
if req.LatestTime > 0 { if req.LatestTime > 0 {
latestTime = time.UnixMilli(req.LatestTime) latestTime = time.UnixMilli(req.LatestTime)
} }
viewerAccountID, err := jwt.GetAccountID(c) viewerAccountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
viewerAccountID = 0 viewerAccountID = 0
} }
feedItems, err := f.service.ListLatest(c.Request.Context(), req.Limit, latestTime, viewerAccountID) feedItems, err := f.service.ListLatest(c.Request.Context(), req.Limit, latestTime, viewerAccountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList) feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList)
c.JSON(200, feedItems) c.JSON(200, feedItems)
} }
func (f *FeedHandler) ListLikesCount(c *gin.Context) { func (f *FeedHandler) ListLikesCount(c *gin.Context) {
var req ListLikesCountRequest var req ListLikesCountRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.Limit <= 0 || req.Limit > 50 { if req.Limit <= 0 || req.Limit > 50 {
req.Limit = 10 req.Limit = 10
} }
var cursor *LikesCountCursor var cursor *LikesCountCursor
if req.LikesCountBefore != nil || req.IDBefore != nil { if req.LikesCountBefore != nil || req.IDBefore != nil {
if req.LikesCountBefore == nil || req.IDBefore == nil { if req.LikesCountBefore == nil || req.IDBefore == nil {
c.JSON(400, gin.H{"error": "likes_count_before and id_before must be provided together"}) c.JSON(400, gin.H{"error": "likes_count_before and id_before must be provided together"})
return return
} }
likesCountBefore := *req.LikesCountBefore likesCountBefore := *req.LikesCountBefore
idBefore := *req.IDBefore idBefore := *req.IDBefore
if likesCountBefore < 0 { if likesCountBefore < 0 {
c.JSON(400, gin.H{"error": "invalid cursor: likes_count_before must be >= 0"}) c.JSON(400, gin.H{"error": "invalid cursor: likes_count_before must be >= 0"})
return return
} }
if idBefore == 0 { if idBefore == 0 {
if likesCountBefore != 0 { if likesCountBefore != 0 {
c.JSON(400, gin.H{"error": "invalid cursor: id_before must be > 0"}) c.JSON(400, gin.H{"error": "invalid cursor: id_before must be > 0"})
return return
} }
} else { } else {
cursor = &LikesCountCursor{ cursor = &LikesCountCursor{
LikesCount: likesCountBefore, LikesCount: likesCountBefore,
ID: idBefore, ID: idBefore,
} }
} }
} }
viewerAccountID, err := jwt.GetAccountID(c) viewerAccountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
viewerAccountID = 0 viewerAccountID = 0
} }
feedItems, err := f.service.ListLikesCount(c.Request.Context(), req.Limit, cursor, viewerAccountID) feedItems, err := f.service.ListLikesCount(c.Request.Context(), req.Limit, cursor, viewerAccountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList) feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList)
c.JSON(200, feedItems) c.JSON(200, feedItems)
} }
func (f *FeedHandler) ListByFollowing(c *gin.Context) { func (f *FeedHandler) ListByFollowing(c *gin.Context) {
var req ListByFollowingRequest var req ListByFollowingRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.Limit <= 0 || req.Limit > 50 { if req.Limit <= 0 || req.Limit > 50 {
req.Limit = 10 req.Limit = 10
} }
viewerAccountID, err := jwt.GetAccountID(c) viewerAccountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
viewerAccountID = 0 viewerAccountID = 0
} }
var latestTime time.Time var latestTime time.Time
if req.LatestTime > 0 { if req.LatestTime > 0 {
latestTime = time.Unix(req.LatestTime, 0) latestTime = time.Unix(req.LatestTime, 0)
} }
feedItems, err := f.service.ListByFollowing(c.Request.Context(), req.Limit, latestTime, viewerAccountID) feedItems, err := f.service.ListByFollowing(c.Request.Context(), req.Limit, latestTime, viewerAccountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList) feedItems.VideoList = nonNilFeedVideoItems(feedItems.VideoList)
c.JSON(200, feedItems) c.JSON(200, feedItems)
} }
func (f *FeedHandler) ListByPopularity(c *gin.Context) { func (f *FeedHandler) ListByPopularity(c *gin.Context) {
var req ListByPopularityRequest var req ListByPopularityRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.Limit <= 0 || req.Limit > 50 { if req.Limit <= 0 || req.Limit > 50 {
req.Limit = 10 req.Limit = 10
} }
viewerAccountID, err := jwt.GetAccountID(c) viewerAccountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
viewerAccountID = 0 viewerAccountID = 0
} }
var latestPopularity int64 var latestPopularity int64
var latestBefore time.Time var latestBefore time.Time
var latestIDBefore uint var latestIDBefore uint
if req.LatestPopularity < 0 { if req.LatestPopularity < 0 {
c.JSON(400, gin.H{"error": "latest_popularity must be >= 0"}) c.JSON(400, gin.H{"error": "latest_popularity must be >= 0"})
return return
} }
anyCursor := !req.LatestBefore.IsZero() || req.LatestIDBefore != nil anyCursor := !req.LatestBefore.IsZero() || req.LatestIDBefore != nil
if anyCursor { if anyCursor {
if req.LatestBefore.IsZero() || req.LatestIDBefore == nil || *req.LatestIDBefore == 0 { if req.LatestBefore.IsZero() || req.LatestIDBefore == nil || *req.LatestIDBefore == 0 {
c.JSON(400, gin.H{"error": "latest_before and latest_id_before must be provided together"}) c.JSON(400, gin.H{"error": "latest_before and latest_id_before must be provided together"})
return return
} }
latestPopularity = req.LatestPopularity latestPopularity = req.LatestPopularity
latestBefore = req.LatestBefore latestBefore = req.LatestBefore
latestIDBefore = *req.LatestIDBefore latestIDBefore = *req.LatestIDBefore
} }
resp, err := f.service.ListByPopularity( resp, err := f.service.ListByPopularity(
c.Request.Context(), c.Request.Context(),
req.Limit, req.Limit,
req.AsOf, req.AsOf,
req.Offset, req.Offset,
viewerAccountID, viewerAccountID,
latestPopularity, latestPopularity,
latestBefore, latestBefore,
latestIDBefore, latestIDBefore,
) )
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
resp.VideoList = nonNilFeedVideoItems(resp.VideoList) resp.VideoList = nonNilFeedVideoItems(resp.VideoList)
c.JSON(200, resp) c.JSON(200, resp)
} }
func nonNilFeedVideoItems(items []FeedVideoItem) []FeedVideoItem { func nonNilFeedVideoItems(items []FeedVideoItem) []FeedVideoItem {
if items == nil { if items == nil {
return []FeedVideoItem{} return []FeedVideoItem{}
} }
return items return items
} }
func (h *FeedHandler) ListByTag(c *gin.Context) { func (h *FeedHandler) ListByTag(c *gin.Context) {
var req struct { var req struct {
TagName string `json:"tag_name"` TagName string `json:"tag_name"`
Limit int `json:"limit"` Limit int `json:"limit"`
} }
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(400, gin.H{"error": err.Error()}) c.JSON(400, gin.H{"error": err.Error()})
return return
} }
if req.TagName == "" { if req.TagName == "" {
c.JSON(400, gin.H{"error": "tag_name is required"}) c.JSON(400, gin.H{"error": "tag_name is required"})
return return
} }
if req.Limit <= 0 || req.Limit > 50 { if req.Limit <= 0 || req.Limit > 50 {
req.Limit = 10 req.Limit = 10
} }
viewerAccountID, _ := jwt.GetAccountID(c) viewerAccountID, _ := jwt.GetAccountID(c)
items, err := h.service.ListByTag(c.Request.Context(), req.TagName, req.Limit, viewerAccountID) items, err := h.service.ListByTag(c.Request.Context(), req.TagName, req.Limit, viewerAccountID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"video_list": nonNilFeedVideoItems(items)}) c.JSON(200, gin.H{"video_list": nonNilFeedVideoItems(items)})
} }

View File

@@ -1,115 +1,115 @@
package feed package feed
import ( import (
"context" "context"
"feedsystem_video_go/internal/social" "feedsystem_video_go/internal/social"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"time" "time"
"gorm.io/gorm" "gorm.io/gorm"
) )
type FeedRepository struct { type FeedRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewFeedRepository(db *gorm.DB) *FeedRepository { func NewFeedRepository(db *gorm.DB) *FeedRepository {
return &FeedRepository{db: db} return &FeedRepository{db: db}
} }
func (repo *FeedRepository) ListLatest(ctx context.Context, limit int, latestBefore time.Time) ([]*video.Video, error) { func (repo *FeedRepository) ListLatest(ctx context.Context, limit int, latestBefore time.Time) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
query := repo.db.WithContext(ctx).Model(&video.Video{}). query := repo.db.WithContext(ctx).Model(&video.Video{}).
Order("create_time DESC") Order("create_time DESC")
if !latestBefore.IsZero() { if !latestBefore.IsZero() {
query = query.Where("create_time < ?", latestBefore) query = query.Where("create_time < ?", latestBefore)
} }
if err := query.Limit(limit).Find(&videos).Error; err != nil { if err := query.Limit(limit).Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (repo *FeedRepository) ListLikesCountWithCursor(ctx context.Context, limit int, cursor *LikesCountCursor) ([]*video.Video, error) { func (repo *FeedRepository) ListLikesCountWithCursor(ctx context.Context, limit int, cursor *LikesCountCursor) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
query := repo.db.WithContext(ctx).Model(&video.Video{}). query := repo.db.WithContext(ctx).Model(&video.Video{}).
Order("likes_count DESC, id DESC") Order("likes_count DESC, id DESC")
if cursor != nil { if cursor != nil {
query = query.Where( query = query.Where(
"(likes_count < ?) OR (likes_count = ? AND id < ?)", "(likes_count < ?) OR (likes_count = ? AND id < ?)",
cursor.LikesCount, cursor.LikesCount,
cursor.LikesCount, cursor.ID, cursor.LikesCount, cursor.ID,
) )
} }
if err := query.Limit(limit).Find(&videos).Error; err != nil { if err := query.Limit(limit).Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (repo *FeedRepository) ListByFollowing(ctx context.Context, limit int, viewerAccountID uint, latestBefore time.Time) ([]*video.Video, error) { func (repo *FeedRepository) ListByFollowing(ctx context.Context, limit int, viewerAccountID uint, latestBefore time.Time) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
query := repo.db.WithContext(ctx).Model(&video.Video{}). query := repo.db.WithContext(ctx).Model(&video.Video{}).
Order("create_time DESC") Order("create_time DESC")
if viewerAccountID > 0 { if viewerAccountID > 0 {
followingSubQuery := repo.db.WithContext(ctx). followingSubQuery := repo.db.WithContext(ctx).
Model(&social.Social{}). Model(&social.Social{}).
Select("vlogger_id"). Select("vlogger_id").
Where("follower_id = ?", viewerAccountID) Where("follower_id = ?", viewerAccountID)
query = query.Where("author_id IN (?)", followingSubQuery) query = query.Where("author_id IN (?)", followingSubQuery)
} }
if !latestBefore.IsZero() { if !latestBefore.IsZero() {
query = query.Where("create_time < ?", latestBefore) query = query.Where("create_time < ?", latestBefore)
} }
if err := query.Limit(limit).Find(&videos).Error; err != nil { if err := query.Limit(limit).Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (repo *FeedRepository) ListByPopularity(ctx context.Context, limit int, popularityBefore int64, timeBefore time.Time, idBefore uint) ([]*video.Video, error) { func (repo *FeedRepository) ListByPopularity(ctx context.Context, limit int, popularityBefore int64, timeBefore time.Time, idBefore uint) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
query := repo.db.WithContext(ctx).Model(&video.Video{}). query := repo.db.WithContext(ctx).Model(&video.Video{}).
Order("popularity DESC, create_time DESC, id DESC") Order("popularity DESC, create_time DESC, id DESC")
// 只有当游标完整提供时才加过滤(popularity 允许为 0) // 只有当游标完整提供时才加过滤(popularity 允许为 0)
if !timeBefore.IsZero() && idBefore > 0 { if !timeBefore.IsZero() && idBefore > 0 {
query = query.Where( query = query.Where(
"(popularity < ?) OR (popularity = ? AND create_time < ?) OR (popularity = ? AND create_time = ? AND id < ?)", "(popularity < ?) OR (popularity = ? AND create_time < ?) OR (popularity = ? AND create_time = ? AND id < ?)",
popularityBefore, popularityBefore,
popularityBefore, timeBefore, popularityBefore, timeBefore,
popularityBefore, timeBefore, idBefore, popularityBefore, timeBefore, idBefore,
) )
} }
if err := query.Limit(limit).Find(&videos).Error; err != nil { if err := query.Limit(limit).Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (repo *FeedRepository) GetByIDs(ctx context.Context, ids []uint) ([]*video.Video, error) { func (repo *FeedRepository) GetByIDs(ctx context.Context, ids []uint) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
if len(ids) == 0 { if len(ids) == 0 {
return videos, nil return videos, nil
} }
if err := repo.db.WithContext(ctx).Model(&video.Video{}). if err := repo.db.WithContext(ctx).Model(&video.Video{}).
Where("id IN ?", ids).Find(&videos).Error; err != nil { Where("id IN ?", ids).Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (repo *FeedRepository) ListByTag(ctx context.Context, tagName string, limit int) ([]*video.Video, error) { func (repo *FeedRepository) ListByTag(ctx context.Context, tagName string, limit int) ([]*video.Video, error) {
var videos []*video.Video var videos []*video.Video
err := repo.db.WithContext(ctx).Model(&video.Video{}).Table("videos"). err := repo.db.WithContext(ctx).Model(&video.Video{}).Table("videos").
Joins("JOIN video_tags ON video_tags.video_id = videos.id"). Joins("JOIN video_tags ON video_tags.video_id = videos.id").
Joins("JOIN tags ON tags.id = video_tags.tag_id"). Joins("JOIN tags ON tags.id = video_tags.tag_id").
Where("tags.name = ?", tagName). Where("tags.name = ?", tagName).
Order("videos.create_time desc"). Order("videos.create_time desc").
Limit(limit). Limit(limit).
Find(&videos).Error Find(&videos).Error
return videos, err return videos, err
} }

View File

@@ -1,242 +1,242 @@
package http package http
import ( import (
"context" "context"
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/feed" "feedsystem_video_go/internal/feed"
"feedsystem_video_go/internal/message" "feedsystem_video_go/internal/message"
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/middleware/jwt"
"feedsystem_video_go/internal/middleware/ratelimit" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/ratelimit"
rediscache "feedsystem_video_go/internal/middleware/redis" rediscache "feedsystem_video_go/internal/middleware/redis"
"feedsystem_video_go/internal/social" "feedsystem_video_go/internal/social"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"feedsystem_video_go/internal/worker" "feedsystem_video_go/internal/worker"
"log" "github.com/gin-gonic/gin"
"time" "gorm.io/gorm"
"github.com/gin-gonic/gin" "log"
"gorm.io/gorm" "time"
) )
func SetRouter(db *gorm.DB, cache *rediscache.Client, rmq *rabbitmq.RabbitMQ) *gin.Engine { func SetRouter(db *gorm.DB, cache *rediscache.Client, rmq *rabbitmq.RabbitMQ) *gin.Engine {
r := gin.Default() r := gin.Default()
if err := r.SetTrustedProxies(nil); err != nil { if err := r.SetTrustedProxies(nil); err != nil {
log.Printf("SetTrustedProxies failed: %v", err) log.Printf("SetTrustedProxies failed: %v", err)
} }
r.Static("/static", "./.run/uploads") r.Static("/static", "./.run/uploads")
// rate_limit // rate_limit
loginLimiter := ratelimit.Limit(cache, "account_login", 10, time.Minute, ratelimit.KeyByIP) loginLimiter := ratelimit.Limit(cache, "account_login", 10, time.Minute, ratelimit.KeyByIP)
registerLimiter := ratelimit.Limit(cache, "account_register", 5, time.Hour, ratelimit.KeyByIP) registerLimiter := ratelimit.Limit(cache, "account_register", 5, time.Hour, ratelimit.KeyByIP)
likeLimiter := ratelimit.Limit(cache, "like_write", 30, time.Minute, ratelimit.KeyByAccount) likeLimiter := ratelimit.Limit(cache, "like_write", 30, time.Minute, ratelimit.KeyByAccount)
commentLimiter := ratelimit.Limit(cache, "comment_write", 10, time.Minute, ratelimit.KeyByAccount) commentLimiter := ratelimit.Limit(cache, "comment_write", 10, time.Minute, ratelimit.KeyByAccount)
socialLimiter := ratelimit.Limit(cache, "social_write", 20, time.Minute, ratelimit.KeyByAccount) socialLimiter := ratelimit.Limit(cache, "social_write", 20, time.Minute, ratelimit.KeyByAccount)
// account // account
accountRepository := account.NewAccountRepository(db) accountRepository := account.NewAccountRepository(db)
accountService := account.NewAccountService(accountRepository, cache) accountService := account.NewAccountService(accountRepository, cache)
accountHandler := account.NewAccountHandler(accountService) accountHandler := account.NewAccountHandler(accountService)
accountGroup := r.Group("/account") accountGroup := r.Group("/account")
{ {
accountGroup.POST("/register", registerLimiter, accountHandler.CreateAccount) accountGroup.POST("/register", registerLimiter, accountHandler.CreateAccount)
accountGroup.POST("/login", loginLimiter, accountHandler.Login) accountGroup.POST("/login", loginLimiter, accountHandler.Login)
accountGroup.POST("/changePassword", accountHandler.ChangePassword) accountGroup.POST("/changePassword", accountHandler.ChangePassword)
accountGroup.POST("/findByID", accountHandler.FindByID) accountGroup.POST("/findByID", accountHandler.FindByID)
accountGroup.POST("/findByUsername", accountHandler.FindByUsername) accountGroup.POST("/findByUsername", accountHandler.FindByUsername)
accountGroup.POST("/refresh", accountHandler.Refresh) accountGroup.POST("/refresh", accountHandler.Refresh)
} }
protectedAccountGroup := accountGroup.Group("") protectedAccountGroup := accountGroup.Group("")
protectedAccountGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedAccountGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedAccountGroup.POST("/logout", accountHandler.Logout) protectedAccountGroup.POST("/logout", accountHandler.Logout)
protectedAccountGroup.POST("/rename", accountHandler.Rename) protectedAccountGroup.POST("/rename", accountHandler.Rename)
protectedAccountGroup.POST("/uploadAvatar", accountHandler.UploadAvatar) protectedAccountGroup.POST("/uploadAvatar", accountHandler.UploadAvatar)
protectedAccountGroup.POST("/updateProfile", accountHandler.UpdateProfile) protectedAccountGroup.POST("/updateProfile", accountHandler.UpdateProfile)
} }
// video // video
videoRepository := video.NewVideoRepository(db) videoRepository := video.NewVideoRepository(db)
popularityMQ, err := rabbitmq.NewPopularityMQ(rmq) popularityMQ, err := rabbitmq.NewPopularityMQ(rmq)
if err != nil { if err != nil {
log.Printf("PopularityMQ init failed (mq disabled): %v", err) log.Printf("PopularityMQ init failed (mq disabled): %v", err)
popularityMQ = nil popularityMQ = nil
} }
videoService := video.NewVideoService(videoRepository, cache, popularityMQ) videoService := video.NewVideoService(videoRepository, cache, popularityMQ)
videoHandler := video.NewVideoHandler(videoService, accountService) videoHandler := video.NewVideoHandler(videoService, accountService)
chunkHandler := video.NewChunkUploadHandler(cache) chunkHandler := video.NewChunkUploadHandler(cache)
videoGroup := r.Group("/video") videoGroup := r.Group("/video")
{ {
videoGroup.POST("/listByAuthorID", videoHandler.ListByAuthorID) videoGroup.POST("/listByAuthorID", videoHandler.ListByAuthorID)
videoGroup.POST("/getDetail", videoHandler.GetDetail) videoGroup.POST("/getDetail", videoHandler.GetDetail)
} }
protectedVideoGroup := videoGroup.Group("") protectedVideoGroup := videoGroup.Group("")
protectedVideoGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedVideoGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedVideoGroup.POST("/uploadVideo", videoHandler.UploadVideo) protectedVideoGroup.POST("/uploadVideo", videoHandler.UploadVideo)
protectedVideoGroup.POST("/uploadCover", videoHandler.UploadCover) protectedVideoGroup.POST("/uploadCover", videoHandler.UploadCover)
protectedVideoGroup.POST("/publish", videoHandler.PublishVideo) protectedVideoGroup.POST("/publish", videoHandler.PublishVideo)
protectedVideoGroup.POST("/chunk/init", chunkHandler.InitChunkUpload) protectedVideoGroup.POST("/chunk/init", chunkHandler.InitChunkUpload)
protectedVideoGroup.POST("/chunk/upload", chunkHandler.UploadChunk) protectedVideoGroup.POST("/chunk/upload", chunkHandler.UploadChunk)
protectedVideoGroup.POST("/chunk/status", chunkHandler.ChunkStatus) protectedVideoGroup.POST("/chunk/status", chunkHandler.ChunkStatus)
protectedVideoGroup.POST("/chunk/complete", chunkHandler.CompleteChunkUpload) protectedVideoGroup.POST("/chunk/complete", chunkHandler.CompleteChunkUpload)
} }
// like // like
likeMQ, err := rabbitmq.NewLikeMQ(rmq) likeMQ, err := rabbitmq.NewLikeMQ(rmq)
if err != nil { if err != nil {
log.Printf("LikeMQ init failed (mq disabled): %v", err) log.Printf("LikeMQ init failed (mq disabled): %v", err)
likeMQ = nil likeMQ = nil
} }
likeRepository := video.NewLikeRepository(db) likeRepository := video.NewLikeRepository(db)
likeService := video.NewLikeService(likeRepository, videoRepository, cache, likeMQ, popularityMQ) likeService := video.NewLikeService(likeRepository, videoRepository, cache, likeMQ, popularityMQ)
likeHandler := video.NewLikeHandler(likeService) likeHandler := video.NewLikeHandler(likeService)
likeGroup := r.Group("/like") likeGroup := r.Group("/like")
protectedLikeGroup := likeGroup.Group("") protectedLikeGroup := likeGroup.Group("")
protectedLikeGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedLikeGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedLikeGroup.POST("/like", likeLimiter, likeHandler.Like) protectedLikeGroup.POST("/like", likeLimiter, likeHandler.Like)
protectedLikeGroup.POST("/unlike", likeLimiter, likeHandler.Unlike) protectedLikeGroup.POST("/unlike", likeLimiter, likeHandler.Unlike)
protectedLikeGroup.POST("/isLiked", likeHandler.IsLiked) protectedLikeGroup.POST("/isLiked", likeHandler.IsLiked)
protectedLikeGroup.POST("/listMyLikedVideos", likeHandler.ListMyLikedVideos) protectedLikeGroup.POST("/listMyLikedVideos", likeHandler.ListMyLikedVideos)
} }
// comment // comment
commentRepository := video.NewCommentRepository(db) commentRepository := video.NewCommentRepository(db)
commentMQ, err := rabbitmq.NewCommentMQ(rmq) commentMQ, err := rabbitmq.NewCommentMQ(rmq)
if err != nil { if err != nil {
log.Printf("CommentMQ init failed (mq disabled): %v", err) log.Printf("CommentMQ init failed (mq disabled): %v", err)
commentMQ = nil commentMQ = nil
} }
commentService := video.NewCommentService(commentRepository, videoRepository, cache, commentMQ, popularityMQ) commentService := video.NewCommentService(commentRepository, videoRepository, cache, commentMQ, popularityMQ)
commentHandler := video.NewCommentHandler(commentService, accountService) commentHandler := video.NewCommentHandler(commentService, accountService)
commentGroup := r.Group("/comment") commentGroup := r.Group("/comment")
{ {
commentGroup.POST("/listAll", commentHandler.GetAllComments) commentGroup.POST("/listAll", commentHandler.GetAllComments)
} }
protectedCommentGroup := commentGroup.Group("") protectedCommentGroup := commentGroup.Group("")
protectedCommentGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedCommentGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedCommentGroup.POST("/publish", commentLimiter, commentHandler.PublishComment) protectedCommentGroup.POST("/publish", commentLimiter, commentHandler.PublishComment)
protectedCommentGroup.POST("/delete", commentLimiter, commentHandler.DeleteComment) protectedCommentGroup.POST("/delete", commentLimiter, commentHandler.DeleteComment)
} }
// social // social
socialMQ, err := rabbitmq.NewSocialMQ(rmq) socialMQ, err := rabbitmq.NewSocialMQ(rmq)
if err != nil { if err != nil {
log.Printf("SocialMQ init failed (mq disabled): %v", err) log.Printf("SocialMQ init failed (mq disabled): %v", err)
socialMQ = nil socialMQ = nil
} }
socialRepository := social.NewSocialRepository(db) socialRepository := social.NewSocialRepository(db)
socialService := social.NewSocialService(socialRepository, accountRepository, socialMQ) socialService := social.NewSocialService(socialRepository, accountRepository, socialMQ)
socialHandler := social.NewSocialHandler(socialService) socialHandler := social.NewSocialHandler(socialService)
socialGroup := r.Group("/social") socialGroup := r.Group("/social")
protectedSocialGroup := socialGroup.Group("") protectedSocialGroup := socialGroup.Group("")
protectedSocialGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedSocialGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedSocialGroup.POST("/follow", socialLimiter, socialHandler.Follow) protectedSocialGroup.POST("/follow", socialLimiter, socialHandler.Follow)
protectedSocialGroup.POST("/unfollow", socialLimiter, socialHandler.Unfollow) protectedSocialGroup.POST("/unfollow", socialLimiter, socialHandler.Unfollow)
protectedSocialGroup.POST("/getAllFollowers", socialHandler.GetAllFollowers) protectedSocialGroup.POST("/getAllFollowers", socialHandler.GetAllFollowers)
protectedSocialGroup.POST("/getAllVloggers", socialHandler.GetAllVloggers) protectedSocialGroup.POST("/getAllVloggers", socialHandler.GetAllVloggers)
protectedSocialGroup.POST("/getCounts", socialHandler.GetCounts) protectedSocialGroup.POST("/getCounts", socialHandler.GetCounts)
} }
accountGroup.POST("/getProfile", func(c *gin.Context) { accountGroup.POST("/getProfile", func(c *gin.Context) {
var req account.GetProfileRequest var req account.GetProfileRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(400, gin.H{"error": err.Error()}) c.JSON(400, gin.H{"error": err.Error()})
return return
} }
if req.AccountID == 0 { if req.AccountID == 0 {
c.JSON(400, gin.H{"error": "account_id is required"}) c.JSON(400, gin.H{"error": "account_id is required"})
return return
} }
acc, err := accountService.FindByID(c.Request.Context(), req.AccountID) acc, err := accountService.FindByID(c.Request.Context(), req.AccountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
videoCount, _ := videoRepository.CountByAuthor(c.Request.Context(), req.AccountID) videoCount, _ := videoRepository.CountByAuthor(c.Request.Context(), req.AccountID)
totalLikes, _ := videoRepository.TotalLikesByAuthor(c.Request.Context(), req.AccountID) totalLikes, _ := videoRepository.TotalLikesByAuthor(c.Request.Context(), req.AccountID)
followerCount, _ := socialRepository.CountFollowers(c.Request.Context(), req.AccountID) followerCount, _ := socialRepository.CountFollowers(c.Request.Context(), req.AccountID)
vloggerCount, _ := socialRepository.CountVloggers(c.Request.Context(), req.AccountID) vloggerCount, _ := socialRepository.CountVloggers(c.Request.Context(), req.AccountID)
c.JSON(200, account.GetProfileResponse{ c.JSON(200, account.GetProfileResponse{
Account: account.FindByIDResponse{ID: acc.ID, Username: acc.Username, AvatarURL: acc.AvatarURL, Bio: acc.Bio}, Account: account.FindByIDResponse{ID: acc.ID, Username: acc.Username, AvatarURL: acc.AvatarURL, Bio: acc.Bio},
VideoCount: videoCount, TotalLikes: totalLikes, VideoCount: videoCount, TotalLikes: totalLikes,
FollowerCount: followerCount, VloggerCount: vloggerCount, FollowerCount: followerCount, VloggerCount: vloggerCount,
}) })
}) })
// feed // feed
feedRepository := feed.NewFeedRepository(db) feedRepository := feed.NewFeedRepository(db)
feedService := feed.NewFeedService(feedRepository, likeRepository, cache) feedService := feed.NewFeedService(feedRepository, likeRepository, cache)
feedHandler := feed.NewFeedHandler(feedService) feedHandler := feed.NewFeedHandler(feedService)
feedGroup := r.Group("/feed") feedGroup := r.Group("/feed")
feedGroup.Use(jwt.SoftJWTAuth(accountRepository, cache)) feedGroup.Use(jwt.SoftJWTAuth(accountRepository, cache))
{ {
feedGroup.POST("/listLatest", feedHandler.ListLatest) feedGroup.POST("/listLatest", feedHandler.ListLatest)
feedGroup.POST("/listLikesCount", feedHandler.ListLikesCount) feedGroup.POST("/listLikesCount", feedHandler.ListLikesCount)
feedGroup.POST("/listByPopularity", feedHandler.ListByPopularity) feedGroup.POST("/listByPopularity", feedHandler.ListByPopularity)
feedGroup.POST("/listByTag", feedHandler.ListByTag) feedGroup.POST("/listByTag", feedHandler.ListByTag)
} }
protectedFeedGroup := feedGroup.Group("") protectedFeedGroup := feedGroup.Group("")
protectedFeedGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedFeedGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedFeedGroup.POST("/listByFollowing", feedHandler.ListByFollowing) protectedFeedGroup.POST("/listByFollowing", feedHandler.ListByFollowing)
} }
// message // message
messageRepo := message.NewRepository(db) messageRepo := message.NewRepository(db)
messageService := message.NewService(messageRepo) messageService := message.NewService(messageRepo)
messageHandler := message.NewHandler(messageService) messageHandler := message.NewHandler(messageService)
messageGroup := r.Group("/message") messageGroup := r.Group("/message")
protectedMessageGroup := messageGroup.Group("") protectedMessageGroup := messageGroup.Group("")
protectedMessageGroup.Use(jwt.JWTAuth(accountRepository, cache)) protectedMessageGroup.Use(jwt.JWTAuth(accountRepository, cache))
{ {
protectedMessageGroup.POST("/send", messageHandler.Send) protectedMessageGroup.POST("/send", messageHandler.Send)
protectedMessageGroup.POST("/list", messageHandler.List) protectedMessageGroup.POST("/list", messageHandler.List)
} }
//worker //worker
timelineMQ, err := rabbitmq.NewTimelineMQ(rmq) timelineMQ, err := rabbitmq.NewTimelineMQ(rmq)
if err != nil { if err != nil {
log.Printf("timelineMQ init failed (mq disabled): %v", err) log.Printf("timelineMQ init failed (mq disabled): %v", err)
timelineMQ = nil timelineMQ = nil
} }
worker.StartOutboxPoller(db, timelineMQ) worker.StartOutboxPoller(db, timelineMQ)
worker.StartConsumer(timelineMQ, "video.timeline.update.queue", cache) worker.StartConsumer(timelineMQ, "video.timeline.update.queue", cache)
// SSE notification // SSE notification
if rmq != nil && rmq.Ch != nil { if rmq != nil && rmq.Ch != nil {
rmq.DeclareTopic("like.events", "notification.like", "like.like") rmq.DeclareTopic("like.events", "notification.like", "like.like")
rmq.DeclareTopic("comment.events", "notification.comment", "comment.publish") rmq.DeclareTopic("comment.events", "notification.comment", "comment.publish")
rmq.DeclareTopic("social.events", "notification.social", "social.follow") rmq.DeclareTopic("social.events", "notification.social", "social.follow")
} }
sseHub := worker.NewSSEHub(db) sseHub := worker.NewSSEHub(db)
notifGroup := r.Group("/notification") notifGroup := r.Group("/notification")
notifGroup.Use(sseHub.SSERequireAuth()) notifGroup.Use(sseHub.SSERequireAuth())
sseHub.RegisterRoutes(r, notifGroup) sseHub.RegisterRoutes(r, notifGroup)
go func() { go func() {
if rmq != nil && rmq.Ch != nil { if rmq != nil && rmq.Ch != nil {
hub := sseHub hub := sseHub
ctx := context.Background() ctx := context.Background()
// consume from like queue // consume from like queue
go func() { go func() {
w := worker.NewNotificationWorker(rmq.Ch, db, "notification.like", hub) w := worker.NewNotificationWorker(rmq.Ch, db, "notification.like", hub)
if err := w.Run(ctx); err != nil { if err := w.Run(ctx); err != nil {
log.Printf("notification-like worker: %v", err) log.Printf("notification-like worker: %v", err)
} }
}() }()
go func() { go func() {
w := worker.NewNotificationWorker(rmq.Ch, db, "notification.comment", hub) w := worker.NewNotificationWorker(rmq.Ch, db, "notification.comment", hub)
if err := w.Run(ctx); err != nil { if err := w.Run(ctx); err != nil {
log.Printf("notification-comment worker: %v", err) log.Printf("notification-comment worker: %v", err)
} }
}() }()
go func() { go func() {
w := worker.NewNotificationWorker(rmq.Ch, db, "notification.social", hub) w := worker.NewNotificationWorker(rmq.Ch, db, "notification.social", hub)
if err := w.Run(ctx); err != nil { if err := w.Run(ctx); err != nil {
log.Printf("notification-social worker: %v", err) log.Printf("notification-social worker: %v", err)
} }
}() }()
} else { } else {
log.Printf("Notification SSE disabled (MQ not available)") log.Printf("Notification SSE disabled (MQ not available)")
} }
}() }()
return r return r
} }

View File

@@ -19,8 +19,8 @@ type Service struct{ repo *Repository }
type Handler struct{ service *Service } type Handler struct{ service *Service }
func NewRepository(db *gorm.DB) *Repository { return &Repository{db: db} } func NewRepository(db *gorm.DB) *Repository { return &Repository{db: db} }
func NewService(repo *Repository) *Service { return &Service{repo: repo} } func NewService(repo *Repository) *Service { return &Service{repo: repo} }
func NewHandler(service *Service) *Handler { return &Handler{service: service} } func NewHandler(service *Service) *Handler { return &Handler{service: service} }
func (r *Repository) AutoMigrate(ctx context.Context) error { func (r *Repository) AutoMigrate(ctx context.Context) error {
return r.db.WithContext(ctx).AutoMigrate(&Message{}) return r.db.WithContext(ctx).AutoMigrate(&Message{})

View File

@@ -1,139 +1,139 @@
package jwt package jwt
import ( import (
"context" "context"
"errors" "errors"
"log" "log"
"net/http" "net/http"
"strings" "strings"
"time" "time"
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/auth" "feedsystem_video_go/internal/auth"
rediscache "feedsystem_video_go/internal/middleware/redis" rediscache "feedsystem_video_go/internal/middleware/redis"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
// JWTAuth check jwt token and ensure it matches the currently stored token. // JWTAuth check jwt token and ensure it matches the currently stored token.
func JWTAuth(accountRepo *account.AccountRepository, cache *rediscache.Client) gin.HandlerFunc { func JWTAuth(accountRepo *account.AccountRepository, cache *rediscache.Client) gin.HandlerFunc {
return func(c *gin.Context) { return func(c *gin.Context) {
authHeader := c.GetHeader("Authorization") authHeader := c.GetHeader("Authorization")
if authHeader == "" { if authHeader == "" {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "missing authorization header"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "missing authorization header"})
return return
} }
parts := strings.SplitN(authHeader, " ", 2) parts := strings.SplitN(authHeader, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") { if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid authorization header"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid authorization header"})
return return
} }
tokenString := parts[1] tokenString := parts[1]
claims, err := auth.ParseToken(tokenString) claims, err := auth.ParseToken(tokenString)
if err != nil { if err != nil {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid or expired token"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid or expired token"})
return return
} }
check(c, claims, tokenString, accountRepo, cache) check(c, claims, tokenString, accountRepo, cache)
} }
} }
func SoftJWTAuth(accountRepo *account.AccountRepository, cache *rediscache.Client) gin.HandlerFunc { func SoftJWTAuth(accountRepo *account.AccountRepository, cache *rediscache.Client) gin.HandlerFunc {
return func(c *gin.Context) { return func(c *gin.Context) {
authHeader := c.GetHeader("Authorization") authHeader := c.GetHeader("Authorization")
if authHeader == "" { if authHeader == "" {
c.Next() c.Next()
return return
} }
parts := strings.SplitN(authHeader, " ", 2) parts := strings.SplitN(authHeader, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") { if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid authorization header"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid authorization header"})
return return
} }
tokenString := parts[1] tokenString := parts[1]
claims, err := auth.ParseToken(tokenString) claims, err := auth.ParseToken(tokenString)
if err != nil { if err != nil {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid or expired token"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid or expired token"})
return return
} }
check(c, claims, tokenString, accountRepo, cache) check(c, claims, tokenString, accountRepo, cache)
} }
} }
func check(c *gin.Context, claims *auth.Claims, tokenString string, accountRepo *account.AccountRepository, cache *rediscache.Client) { func check(c *gin.Context, claims *auth.Claims, tokenString string, accountRepo *account.AccountRepository, cache *rediscache.Client) {
key := cache.Key("account:%d", claims.AccountID) key := cache.Key("account:%d", claims.AccountID)
// 先查 Redis // 先查 Redis
if cache != nil { if cache != nil {
cacheCtx, cancel := context.WithTimeout(c.Request.Context(), 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(c.Request.Context(), 50*time.Millisecond)
defer cancel() defer cancel()
b, err := cache.GetBytes(cacheCtx, key) b, err := cache.GetBytes(cacheCtx, key)
if err == nil { if err == nil {
if string(b) != tokenString { if string(b) != tokenString {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "token has been revoked"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "token has been revoked"})
return return
} }
c.Set("accountID", claims.AccountID) c.Set("accountID", claims.AccountID)
c.Set("username", claims.Username) c.Set("username", claims.Username)
c.Next() c.Next()
return return
} }
} }
// Redis 故障/未启用:查 DB 兜底 // Redis 故障/未启用:查 DB 兜底
accountInfo, err := accountRepo.FindByID(c.Request.Context(), claims.AccountID) accountInfo, err := accountRepo.FindByID(c.Request.Context(), claims.AccountID)
if err != nil || accountInfo.Token == "" || accountInfo.Token != tokenString { if err != nil || accountInfo.Token == "" || accountInfo.Token != tokenString {
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "token has been revoked"}) c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "token has been revoked"})
return return
} }
if cache != nil { if cache != nil {
cacheCtx, cancel := context.WithTimeout(c.Request.Context(), 50*time.Millisecond) cacheCtx, cancel := context.WithTimeout(c.Request.Context(), 50*time.Millisecond)
defer cancel() defer cancel()
if err := cache.SetBytes(cacheCtx, key, []byte(tokenString), 24*time.Hour); err != nil { if err := cache.SetBytes(cacheCtx, key, []byte(tokenString), 24*time.Hour); err != nil {
log.Printf("failed to set cache: %v", err) log.Printf("failed to set cache: %v", err)
} }
} }
c.Set("accountID", claims.AccountID) c.Set("accountID", claims.AccountID)
c.Set("username", claims.Username) c.Set("username", claims.Username)
c.Next() c.Next()
} }
func GetAccountID(c *gin.Context) (uint, error) { func GetAccountID(c *gin.Context) (uint, error) {
uidValue, exists := c.Get("accountID") uidValue, exists := c.Get("accountID")
if !exists { if !exists {
return 0, errors.New("accountID not found") return 0, errors.New("accountID not found")
} }
accountID, ok := uidValue.(uint) accountID, ok := uidValue.(uint)
if !ok { if !ok {
return 0, errors.New("accountID has invalid type") return 0, errors.New("accountID has invalid type")
} }
return accountID, nil return accountID, nil
} }
func GetUsername(c *gin.Context) (string, error) { func GetUsername(c *gin.Context) (string, error) {
val, exists := c.Get("username") val, exists := c.Get("username")
if !exists { if !exists {
return "", errors.New("username not found") return "", errors.New("username not found")
} }
username, ok := val.(string) username, ok := val.(string)
if !ok { if !ok {
return "", errors.New("username has invalid type") return "", errors.New("username has invalid type")
} }
return username, nil return username, nil
} }

View File

@@ -68,4 +68,3 @@ func (c *CommentMQ) publish(ctx context.Context, action, routingKey string, evt
evt.OccurredAt = time.Now().UTC() evt.OccurredAt = time.Now().UTC()
return c.PublishJSON(ctx, commentExchange, routingKey, evt) return c.PublishJSON(ctx, commentExchange, routingKey, evt)
} }

View File

@@ -54,4 +54,3 @@ func (p *PopularityMQ) Update(ctx context.Context, videoID uint, change int64) e
} }
return p.PublishJSON(ctx, popularityExchange, popularityUpdateRK, event) return p.PublishJSON(ctx, popularityExchange, popularityUpdateRK, event)
} }

View File

@@ -1,123 +1,123 @@
package rabbitmq package rabbitmq
import ( import (
"context" "context"
"crypto/rand" "crypto/rand"
"encoding/hex" "encoding/hex"
"encoding/json" "encoding/json"
"errors" "errors"
"feedsystem_video_go/internal/config" "feedsystem_video_go/internal/config"
"log" "log"
"strconv" "strconv"
"time" "time"
amqp "github.com/rabbitmq/amqp091-go" amqp "github.com/rabbitmq/amqp091-go"
) )
type RabbitMQ struct { type RabbitMQ struct {
Conn *amqp.Connection Conn *amqp.Connection
Ch *amqp.Channel Ch *amqp.Channel
} }
func NewRabbitMQ(cfg *config.RabbitMQConfig) (*RabbitMQ, error) { func NewRabbitMQ(cfg *config.RabbitMQConfig) (*RabbitMQ, error) {
if cfg == nil { if cfg == nil {
return nil, errors.New("rabbitmq config is nil") return nil, errors.New("rabbitmq config is nil")
} }
url := "amqp://" + cfg.Username + ":" + cfg.Password + "@" + cfg.Host + ":" + strconv.Itoa(cfg.Port) + "/" url := "amqp://" + cfg.Username + ":" + cfg.Password + "@" + cfg.Host + ":" + strconv.Itoa(cfg.Port) + "/"
conn, err := amqp.Dial(url) conn, err := amqp.Dial(url)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ch, err := conn.Channel() ch, err := conn.Channel()
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &RabbitMQ{Conn: conn, Ch: ch}, nil return &RabbitMQ{Conn: conn, Ch: ch}, nil
} }
func (r *RabbitMQ) Close() error { func (r *RabbitMQ) Close() error {
if r == nil || r.Ch == nil || r.Conn == nil { if r == nil || r.Ch == nil || r.Conn == nil {
return nil return nil
} }
if err := r.Ch.Close(); err != nil { if err := r.Ch.Close(); err != nil {
return err return err
} }
if err := r.Conn.Close(); err != nil { if err := r.Conn.Close(); err != nil {
return err return err
} }
return nil return nil
} }
func (r *RabbitMQ) DeclareTopic(exchange string, queue string, bindingKey string) error { func (r *RabbitMQ) DeclareTopic(exchange string, queue string, bindingKey string) error {
if r == nil || r.Ch == nil { if r == nil || r.Ch == nil {
return errors.New("rabbitmq is not initialized") return errors.New("rabbitmq is not initialized")
} }
if exchange == "" || queue == "" || bindingKey == "" { if exchange == "" || queue == "" || bindingKey == "" {
return errors.New("exchange/queue/bindingKey is required") return errors.New("exchange/queue/bindingKey is required")
} }
if err := r.Ch.ExchangeDeclare( if err := r.Ch.ExchangeDeclare(
exchange, exchange,
"topic", "topic",
true, true,
false, false,
false, false,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
q, err := r.Ch.QueueDeclare( q, err := r.Ch.QueueDeclare(
queue, queue,
true, true,
false, false,
false, false,
false, false,
amqp.Table{"x-dead-letter-exchange": DLXExchange}, amqp.Table{"x-dead-letter-exchange": DLXExchange},
) )
if err != nil { if err != nil {
return err return err
} }
if err := r.Ch.QueueBind( if err := r.Ch.QueueBind(
q.Name, q.Name,
bindingKey, bindingKey,
exchange, exchange,
false, false,
nil, nil,
); err != nil { ); err != nil {
return err return err
} }
if err := DeclareDLX(r.Ch, queue); err != nil { if err := DeclareDLX(r.Ch, queue); err != nil {
log.Printf("DLX declare failed for %s: %v", queue, err) log.Printf("DLX declare failed for %s: %v", queue, err)
} }
return nil return nil
} }
func (r *RabbitMQ) PublishJSON(ctx context.Context, exchange string, routingKey string, payload any) error { func (r *RabbitMQ) PublishJSON(ctx context.Context, exchange string, routingKey string, payload any) error {
if r == nil || r.Ch == nil { if r == nil || r.Ch == nil {
return errors.New("rabbitmq is not initialized") return errors.New("rabbitmq is not initialized")
} }
if exchange == "" || routingKey == "" { if exchange == "" || routingKey == "" {
return errors.New("exchange and routingKey are required") return errors.New("exchange and routingKey are required")
} }
b, err := json.Marshal(payload) b, err := json.Marshal(payload)
if err != nil { if err != nil {
return err return err
} }
return r.Ch.PublishWithContext(ctx, exchange, routingKey, false, false, amqp.Publishing{ return r.Ch.PublishWithContext(ctx, exchange, routingKey, false, false, amqp.Publishing{
ContentType: "application/json", ContentType: "application/json",
DeliveryMode: amqp.Persistent, DeliveryMode: amqp.Persistent,
Timestamp: time.Now(), Timestamp: time.Now(),
Body: b, Body: b,
}) })
} }
func newEventID(n int) (string, error) { func newEventID(n int) (string, error) {
b := make([]byte, n) b := make([]byte, n)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
return "", err return "", err
} }
return hex.EncodeToString(b), nil return hex.EncodeToString(b), nil
} }

View File

@@ -1,14 +1,14 @@
package ratelimit package ratelimit
import ( import (
rediscache "feedsystem_video_go/internal/middleware/redis"
jwt "feedsystem_video_go/internal/middleware/jwt" jwt "feedsystem_video_go/internal/middleware/jwt"
rediscache "feedsystem_video_go/internal/middleware/redis"
"fmt" "fmt"
"github.com/gin-gonic/gin"
"net/http" "net/http"
"strconv"
"strings" "strings"
"time" "time"
"strconv"
"github.com/gin-gonic/gin"
) )
type KeyFunc func(*gin.Context) (string, bool) type KeyFunc func(*gin.Context) (string, bool)
@@ -68,4 +68,4 @@ func KeyByAccount(c *gin.Context) (string, bool) {
return "", false return "", false
} }
return strconv.FormatUint(uint64(accountID), 10), true return strconv.FormatUint(uint64(accountID), 10), true
} }

View File

@@ -1,115 +1,115 @@
package redis package redis
import ( import (
"context" "context"
"crypto/rand" "crypto/rand"
"encoding/hex" "encoding/hex"
"feedsystem_video_go/internal/config" "feedsystem_video_go/internal/config"
"fmt" "fmt"
"strconv" "strconv"
"time" "time"
redis "github.com/redis/go-redis/v9" redis "github.com/redis/go-redis/v9"
) )
type Client struct { type Client struct {
rdb *redis.Client rdb *redis.Client
keyPrefix string keyPrefix string
} }
const defaultKeyPrefix = "v1:" const defaultKeyPrefix = "v1:"
func NewClient(rdb *redis.Client, keyPrefix string) *Client { func NewClient(rdb *redis.Client, keyPrefix string) *Client {
return &Client{rdb: rdb, keyPrefix: keyPrefix} return &Client{rdb: rdb, keyPrefix: keyPrefix}
} }
func NewFromEnv(cfg *config.RedisConfig) (*Client, error) { func NewFromEnv(cfg *config.RedisConfig) (*Client, error) {
rdb := redis.NewClient(&redis.Options{ rdb := redis.NewClient(&redis.Options{
Addr: cfg.Host + ":" + strconv.Itoa(cfg.Port), Addr: cfg.Host + ":" + strconv.Itoa(cfg.Port),
Password: cfg.Password, Password: cfg.Password,
DB: cfg.DB, DB: cfg.DB,
}) })
return &Client{rdb: rdb, keyPrefix: defaultKeyPrefix}, nil return &Client{rdb: rdb, keyPrefix: defaultKeyPrefix}, nil
} }
func (c *Client) Close() error { func (c *Client) Close() error {
if c == nil || c.rdb == nil { if c == nil || c.rdb == nil {
return nil return nil
} }
return c.rdb.Close() return c.rdb.Close()
} }
func (c *Client) Ping(ctx context.Context) error { func (c *Client) Ping(ctx context.Context) error {
if c == nil || c.rdb == nil { if c == nil || c.rdb == nil {
return nil return nil
} }
return c.rdb.Ping(ctx).Err() return c.rdb.Ping(ctx).Err()
} }
func IsMiss(err error) bool { func IsMiss(err error) bool {
return err == redis.Nil return err == redis.Nil
} }
func (c *Client) Key(format string, args ...any) string { func (c *Client) Key(format string, args ...any) string {
prefix := "" prefix := ""
if c != nil { if c != nil {
prefix = c.keyPrefix prefix = c.keyPrefix
} }
return prefix + fmt.Sprintf(format, args...) return prefix + fmt.Sprintf(format, args...)
} }
func randToken(n int) (string, error) { func randToken(n int) (string, error) {
b := make([]byte, n) b := make([]byte, n)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
return "", err return "", err
} }
return hex.EncodeToString(b), nil return hex.EncodeToString(b), nil
} }
func (c *Client) Lock(ctx context.Context, key string, ttl time.Duration) (token string, ok bool, err error) { func (c *Client) Lock(ctx context.Context, key string, ttl time.Duration) (token string, ok bool, err error) {
if c == nil || c.rdb == nil { if c == nil || c.rdb == nil {
return "", false, nil return "", false, nil
} }
token, err = randToken(16) token, err = randToken(16)
if err != nil { if err != nil {
return "", false, err return "", false, err
} }
ok, err = c.rdb.SetNX(ctx, key, token, ttl).Result() ok, err = c.rdb.SetNX(ctx, key, token, ttl).Result()
return token, ok, err return token, ok, err
} }
var unlockScript = redis.NewScript(` var unlockScript = redis.NewScript(`
if redis.call("GET", KEYS[1]) == ARGV[1] then if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("DEL", KEYS[1]) return redis.call("DEL", KEYS[1])
else else
return 0 return 0
end end
`) `)
var incrementWithExpireScript = redis.NewScript(` var incrementWithExpireScript = redis.NewScript(`
local count = redis.call("INCR", KEYS[1]) local count = redis.call("INCR", KEYS[1])
if count == 1 then if count == 1 then
redis.call("PEXPIRE", KEYS[1], ARGV[1]) redis.call("PEXPIRE", KEYS[1], ARGV[1])
end end
return count return count
`) `)
func (c *Client) Unlock(ctx context.Context, key string, token string) error { func (c *Client) Unlock(ctx context.Context, key string, token string) error {
if c == nil || c.rdb == nil { if c == nil || c.rdb == nil {
return nil return nil
} }
_, err := unlockScript.Run(ctx, c.rdb, []string{key}, token).Result() _, err := unlockScript.Run(ctx, c.rdb, []string{key}, token).Result()
return err return err
} }
func (c *Client) IncrementWithExpire(ctx context.Context, key string, expire time.Duration) (int64, error) { func (c *Client) IncrementWithExpire(ctx context.Context, key string, expire time.Duration) (int64, error) {
if c == nil || c.rdb == nil { if c == nil || c.rdb == nil {
return 0, nil return 0, nil
} }
return incrementWithExpireScript.Run( return incrementWithExpireScript.Run(
ctx, ctx,
c.rdb, c.rdb,
[]string{key}, []string{key},
expire.Milliseconds(), expire.Milliseconds(),
).Int64() ).Int64()
} }

View File

@@ -5,6 +5,7 @@ import (
"net/http/httptest" "net/http/httptest"
"testing" "testing"
) )
func TestNewPprofMux(t *testing.T) { func TestNewPprofMux(t *testing.T) {
t.Parallel() t.Parallel()
@@ -31,7 +32,7 @@ func TestNewPprofServerWithDisabled(t *testing.T) {
func TestPprofServerCloseWithDisabledServer(t *testing.T) { func TestPprofServerCloseWithDisabledServer(t *testing.T) {
t.Parallel() t.Parallel()
pprofServer, err := NewPprofServer("api", false, "localhost:6060") pprofServer, err := NewPprofServer("api", false, "localhost:6060")
if err != nil { if err != nil {
t.Fatalf("Failed to create pprof server: %v", err) t.Fatalf("Failed to create pprof server: %v", err)
@@ -39,4 +40,4 @@ func TestPprofServerCloseWithDisabledServer(t *testing.T) {
if err := pprofServer.Close(); err != nil { if err := pprofServer.Close(); err != nil {
t.Fatalf("Expected no error when closing disabled pprof server, got: %v", err) t.Fatalf("Expected no error when closing disabled pprof server, got: %v", err)
} }
} }

View File

@@ -1,40 +1,40 @@
package social package social
import "feedsystem_video_go/internal/account" import "feedsystem_video_go/internal/account"
type Social struct { type Social struct {
ID uint `gorm:"primaryKey"` ID uint `gorm:"primaryKey"`
FollowerID uint `gorm:"not null;index:idx_social_follower;uniqueIndex:idx_social_follower_vlogger"` FollowerID uint `gorm:"not null;index:idx_social_follower;uniqueIndex:idx_social_follower_vlogger"`
VloggerID uint `gorm:"not null;index:idx_social_vlogger;uniqueIndex:idx_social_follower_vlogger"` VloggerID uint `gorm:"not null;index:idx_social_vlogger;uniqueIndex:idx_social_follower_vlogger"`
} }
type FollowRequest struct { type FollowRequest struct {
VloggerID uint `json:"vlogger_id"` VloggerID uint `json:"vlogger_id"`
} }
type UnfollowRequest struct { type UnfollowRequest struct {
VloggerID uint `json:"vlogger_id"` VloggerID uint `json:"vlogger_id"`
} }
type GetAllFollowersRequest struct { type GetAllFollowersRequest struct {
VloggerID uint `json:"vlogger_id"` VloggerID uint `json:"vlogger_id"`
} }
type GetAllFollowersResponse struct { type GetAllFollowersResponse struct {
Followers []*account.Account `json:"followers"` Followers []*account.Account `json:"followers"`
FollowerCount int64 `json:"follower_count"` FollowerCount int64 `json:"follower_count"`
} }
type GetAllVloggersResponse struct { type GetAllVloggersResponse struct {
Vloggers []*account.Account `json:"vloggers"` Vloggers []*account.Account `json:"vloggers"`
VloggerCount int64 `json:"vlogger_count"` VloggerCount int64 `json:"vlogger_count"`
} }
type SocialCounts struct { type SocialCounts struct {
FollowerCount int64 `json:"follower_count"` FollowerCount int64 `json:"follower_count"`
VloggerCount int64 `json:"vlogger_count"` VloggerCount int64 `json:"vlogger_count"`
}
type GetAllVloggersRequest struct {
FollowerID uint `json:"follower_id"`
} }
type GetAllVloggersRequest struct {
FollowerID uint `json:"follower_id"`
}

View File

@@ -1,139 +1,139 @@
package social package social
import ( import (
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/apierror"
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/middleware/jwt"
"net/http" "net/http"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
type SocialHandler struct { type SocialHandler struct {
service *SocialService service *SocialService
} }
func NewSocialHandler(service *SocialService) *SocialHandler { func NewSocialHandler(service *SocialService) *SocialHandler {
return &SocialHandler{service: service} return &SocialHandler{service: service}
} }
func (h *SocialHandler) Follow(c *gin.Context) { func (h *SocialHandler) Follow(c *gin.Context) {
var req FollowRequest var req FollowRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VloggerID <= 0 { if req.VloggerID <= 0 {
c.JSON(http.StatusBadRequest, gin.H{"error": "vlogger_id is required"}) c.JSON(http.StatusBadRequest, gin.H{"error": "vlogger_id is required"})
return return
} }
FollowerID, err := jwt.GetAccountID(c) FollowerID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
social := &Social{ social := &Social{
FollowerID: FollowerID, FollowerID: FollowerID,
VloggerID: req.VloggerID, VloggerID: req.VloggerID,
} }
if err := h.service.Follow(c.Request.Context(), social); err != nil { if err := h.service.Follow(c.Request.Context(), social); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(http.StatusOK, gin.H{"message": "followed"}) c.JSON(http.StatusOK, gin.H{"message": "followed"})
} }
func (h *SocialHandler) Unfollow(c *gin.Context) { func (h *SocialHandler) Unfollow(c *gin.Context) {
var req UnfollowRequest var req UnfollowRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VloggerID <= 0 { if req.VloggerID <= 0 {
c.JSON(http.StatusBadRequest, gin.H{"error": "vlogger_id is required"}) c.JSON(http.StatusBadRequest, gin.H{"error": "vlogger_id is required"})
return return
} }
FollowerID, err := jwt.GetAccountID(c) FollowerID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
social := &Social{ social := &Social{
FollowerID: FollowerID, FollowerID: FollowerID,
VloggerID: req.VloggerID, VloggerID: req.VloggerID,
} }
if err := h.service.Unfollow(c.Request.Context(), social); err != nil { if err := h.service.Unfollow(c.Request.Context(), social); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(http.StatusOK, gin.H{"message": "unfollowed"}) c.JSON(http.StatusOK, gin.H{"message": "unfollowed"})
} }
func (h *SocialHandler) GetAllFollowers(c *gin.Context) { func (h *SocialHandler) GetAllFollowers(c *gin.Context) {
var req GetAllFollowersRequest var req GetAllFollowersRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
vloggerID := req.VloggerID vloggerID := req.VloggerID
if vloggerID == 0 { if vloggerID == 0 {
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
vloggerID = accountID vloggerID = accountID
} }
followers, err := h.service.GetAllFollowers(c.Request.Context(), vloggerID) followers, err := h.service.GetAllFollowers(c.Request.Context(), vloggerID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if followers == nil { if followers == nil {
followers = []*account.Account{} followers = []*account.Account{}
} }
followerCount, _ := h.service.CountFollowers(c.Request.Context(), vloggerID) followerCount, _ := h.service.CountFollowers(c.Request.Context(), vloggerID)
c.JSON(http.StatusOK, GetAllFollowersResponse{Followers: followers, FollowerCount: followerCount}) c.JSON(http.StatusOK, GetAllFollowersResponse{Followers: followers, FollowerCount: followerCount})
} }
func (h *SocialHandler) GetAllVloggers(c *gin.Context) { func (h *SocialHandler) GetAllVloggers(c *gin.Context) {
var req GetAllVloggersRequest var req GetAllVloggersRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
followerID := req.FollowerID followerID := req.FollowerID
if followerID == 0 { if followerID == 0 {
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
followerID = accountID followerID = accountID
} }
vloggers, err := h.service.GetAllVloggers(c.Request.Context(), followerID) vloggers, err := h.service.GetAllVloggers(c.Request.Context(), followerID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if vloggers == nil { if vloggers == nil {
vloggers = []*account.Account{} vloggers = []*account.Account{}
} }
vloggerCount, _ := h.service.CountVloggers(c.Request.Context(), followerID) vloggerCount, _ := h.service.CountVloggers(c.Request.Context(), followerID)
c.JSON(http.StatusOK, GetAllVloggersResponse{Vloggers: vloggers, VloggerCount: vloggerCount}) c.JSON(http.StatusOK, GetAllVloggersResponse{Vloggers: vloggers, VloggerCount: vloggerCount})
} }
func (h *SocialHandler) GetCounts(c *gin.Context) { func (h *SocialHandler) GetCounts(c *gin.Context) {
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()}) c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
return return
} }
followerCount, _ := h.service.CountFollowers(c.Request.Context(), accountID) followerCount, _ := h.service.CountFollowers(c.Request.Context(), accountID)
vloggerCount, _ := h.service.CountVloggers(c.Request.Context(), accountID) vloggerCount, _ := h.service.CountVloggers(c.Request.Context(), accountID)
c.JSON(http.StatusOK, SocialCounts{FollowerCount: followerCount, VloggerCount: vloggerCount}) c.JSON(http.StatusOK, SocialCounts{FollowerCount: followerCount, VloggerCount: vloggerCount})
} }

View File

@@ -1,109 +1,109 @@
package social package social
import ( import (
"context" "context"
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"gorm.io/gorm" "gorm.io/gorm"
) )
type SocialRepository struct { type SocialRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewSocialRepository(db *gorm.DB) *SocialRepository { func NewSocialRepository(db *gorm.DB) *SocialRepository {
return &SocialRepository{db: db} return &SocialRepository{db: db}
} }
func (r *SocialRepository) Follow(ctx context.Context, social *Social) error { func (r *SocialRepository) Follow(ctx context.Context, social *Social) error {
return r.db.WithContext(ctx).Create(social).Error return r.db.WithContext(ctx).Create(social).Error
} }
func (r *SocialRepository) Unfollow(ctx context.Context, social *Social) error { func (r *SocialRepository) Unfollow(ctx context.Context, social *Social) error {
return r.db.WithContext(ctx). return r.db.WithContext(ctx).
Where("follower_id = ? AND vlogger_id = ?", social.FollowerID, social.VloggerID). Where("follower_id = ? AND vlogger_id = ?", social.FollowerID, social.VloggerID).
Delete(&Social{}).Error Delete(&Social{}).Error
} }
func (r *SocialRepository) GetAllFollowers(ctx context.Context, VloggerID uint) ([]*account.Account, error) { func (r *SocialRepository) GetAllFollowers(ctx context.Context, VloggerID uint) ([]*account.Account, error) {
var relations []Social var relations []Social
if err := r.db.WithContext(ctx). if err := r.db.WithContext(ctx).
Model(&Social{}). Model(&Social{}).
Where("vlogger_id = ?", VloggerID). Where("vlogger_id = ?", VloggerID).
Limit(200). Limit(200).
Find(&relations).Error; err != nil { Find(&relations).Error; err != nil {
return nil, err return nil, err
} }
followerIDs := make([]uint, 0, len(relations)) followerIDs := make([]uint, 0, len(relations))
for _, rel := range relations { for _, rel := range relations {
followerIDs = append(followerIDs, rel.FollowerID) followerIDs = append(followerIDs, rel.FollowerID)
} }
if len(followerIDs) == 0 { if len(followerIDs) == 0 {
return []*account.Account{}, nil return []*account.Account{}, nil
} }
var followers []*account.Account var followers []*account.Account
if err := r.db.WithContext(ctx). if err := r.db.WithContext(ctx).
Model(&account.Account{}). Model(&account.Account{}).
Where("id IN ?", followerIDs). Where("id IN ?", followerIDs).
Find(&followers).Error; err != nil { Find(&followers).Error; err != nil {
return nil, err return nil, err
} }
return followers, nil return followers, nil
} }
func (r *SocialRepository) GetAllVloggers(ctx context.Context, FollowerID uint) ([]*account.Account, error) { func (r *SocialRepository) GetAllVloggers(ctx context.Context, FollowerID uint) ([]*account.Account, error) {
var relations []Social var relations []Social
if err := r.db.WithContext(ctx). if err := r.db.WithContext(ctx).
Model(&Social{}). Model(&Social{}).
Where("follower_id = ?", FollowerID). Where("follower_id = ?", FollowerID).
Limit(200). Limit(200).
Find(&relations).Error; err != nil { Find(&relations).Error; err != nil {
return nil, err return nil, err
} }
vloggerIDs := make([]uint, 0, len(relations)) vloggerIDs := make([]uint, 0, len(relations))
for _, rel := range relations { for _, rel := range relations {
vloggerIDs = append(vloggerIDs, rel.VloggerID) vloggerIDs = append(vloggerIDs, rel.VloggerID)
} }
if len(vloggerIDs) == 0 { if len(vloggerIDs) == 0 {
return []*account.Account{}, nil return []*account.Account{}, nil
} }
var vloggers []*account.Account var vloggers []*account.Account
if err := r.db.WithContext(ctx). if err := r.db.WithContext(ctx).
Model(&account.Account{}). Model(&account.Account{}).
Where("id IN ?", vloggerIDs). Where("id IN ?", vloggerIDs).
Find(&vloggers).Error; err != nil { Find(&vloggers).Error; err != nil {
return nil, err return nil, err
} }
return vloggers, nil return vloggers, nil
} }
func (r *SocialRepository) IsFollowed(ctx context.Context, social *Social) (bool, error) { func (r *SocialRepository) IsFollowed(ctx context.Context, social *Social) (bool, error) {
var count int64 var count int64
if err := r.db.WithContext(ctx). if err := r.db.WithContext(ctx).
Model(&Social{}). Model(&Social{}).
Where("follower_id = ? AND vlogger_id = ?", social.FollowerID, social.VloggerID). Where("follower_id = ? AND vlogger_id = ?", social.FollowerID, social.VloggerID).
Count(&count).Error; err != nil { Count(&count).Error; err != nil {
return false, err return false, err
} }
return count > 0, nil return count > 0, nil
} }
func (r *SocialRepository) CountFollowers(ctx context.Context, vloggerID uint) (int64, error) { func (r *SocialRepository) CountFollowers(ctx context.Context, vloggerID uint) (int64, error) {
var count int64 var count int64
if err := r.db.WithContext(ctx).Model(&Social{}).Where("vlogger_id = ?", vloggerID).Count(&count).Error; err != nil { if err := r.db.WithContext(ctx).Model(&Social{}).Where("vlogger_id = ?", vloggerID).Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return count, nil return count, nil
} }
func (r *SocialRepository) CountVloggers(ctx context.Context, followerID uint) (int64, error) { func (r *SocialRepository) CountVloggers(ctx context.Context, followerID uint) (int64, error) {
var count int64 var count int64
if err := r.db.WithContext(ctx).Model(&Social{}).Where("follower_id = ?", followerID).Count(&count).Error; err != nil { if err := r.db.WithContext(ctx).Model(&Social{}).Where("follower_id = ?", followerID).Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return count, nil return count, nil
} }

View File

@@ -1,101 +1,101 @@
package social package social
import ( import (
"context" "context"
"errors" "errors"
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/rabbitmq"
) )
type SocialService struct { type SocialService struct {
repo *SocialRepository repo *SocialRepository
accountrepo *account.AccountRepository accountrepo *account.AccountRepository
socialMQ *rabbitmq.SocialMQ socialMQ *rabbitmq.SocialMQ
} }
func NewSocialService(repo *SocialRepository, accountrepo *account.AccountRepository, socialMQ *rabbitmq.SocialMQ) *SocialService { func NewSocialService(repo *SocialRepository, accountrepo *account.AccountRepository, socialMQ *rabbitmq.SocialMQ) *SocialService {
return &SocialService{repo: repo, accountrepo: accountrepo, socialMQ: socialMQ} return &SocialService{repo: repo, accountrepo: accountrepo, socialMQ: socialMQ}
} }
func (s *SocialService) Follow(ctx context.Context, social *Social) error { func (s *SocialService) Follow(ctx context.Context, social *Social) error {
_, err := s.accountrepo.FindByID(ctx, social.FollowerID) _, err := s.accountrepo.FindByID(ctx, social.FollowerID)
if err != nil { if err != nil {
return err return err
} }
_, err = s.accountrepo.FindByID(ctx, social.VloggerID) _, err = s.accountrepo.FindByID(ctx, social.VloggerID)
if err != nil { if err != nil {
return err return err
} }
if social.FollowerID == social.VloggerID { if social.FollowerID == social.VloggerID {
return errors.New("can not follow self") return errors.New("can not follow self")
} }
isFollowed, err := s.repo.IsFollowed(ctx, social) isFollowed, err := s.repo.IsFollowed(ctx, social)
if err != nil { if err != nil {
return err return err
} }
if isFollowed { if isFollowed {
return errors.New("already followed") return errors.New("already followed")
} }
if s.socialMQ != nil { if s.socialMQ != nil {
s.socialMQ.Follow(ctx, social.FollowerID, social.VloggerID) s.socialMQ.Follow(ctx, social.FollowerID, social.VloggerID)
} }
return s.repo.Follow(ctx, social) return s.repo.Follow(ctx, social)
} }
func (s *SocialService) Unfollow(ctx context.Context, social *Social) error { func (s *SocialService) Unfollow(ctx context.Context, social *Social) error {
_, err := s.accountrepo.FindByID(ctx, social.FollowerID) _, err := s.accountrepo.FindByID(ctx, social.FollowerID)
if err != nil { if err != nil {
return err return err
} }
_, err = s.accountrepo.FindByID(ctx, social.VloggerID) _, err = s.accountrepo.FindByID(ctx, social.VloggerID)
if err != nil { if err != nil {
return err return err
} }
isFollowed, err := s.repo.IsFollowed(ctx, social) isFollowed, err := s.repo.IsFollowed(ctx, social)
if err != nil { if err != nil {
return err return err
} }
if !isFollowed { if !isFollowed {
return errors.New("not followed") return errors.New("not followed")
} }
if s.socialMQ != nil { if s.socialMQ != nil {
s.socialMQ.UnFollow(ctx, social.FollowerID, social.VloggerID) s.socialMQ.UnFollow(ctx, social.FollowerID, social.VloggerID)
} }
return s.repo.Unfollow(ctx, social) return s.repo.Unfollow(ctx, social)
} }
func (s *SocialService) GetAllFollowers(ctx context.Context, VloggerID uint) ([]*account.Account, error) { func (s *SocialService) GetAllFollowers(ctx context.Context, VloggerID uint) ([]*account.Account, error) {
_, err := s.accountrepo.FindByID(ctx, VloggerID) _, err := s.accountrepo.FindByID(ctx, VloggerID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return s.repo.GetAllFollowers(ctx, VloggerID) return s.repo.GetAllFollowers(ctx, VloggerID)
} }
func (s *SocialService) GetAllVloggers(ctx context.Context, FollowerID uint) ([]*account.Account, error) { func (s *SocialService) GetAllVloggers(ctx context.Context, FollowerID uint) ([]*account.Account, error) {
_, err := s.accountrepo.FindByID(ctx, FollowerID) _, err := s.accountrepo.FindByID(ctx, FollowerID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return s.repo.GetAllVloggers(ctx, FollowerID) return s.repo.GetAllVloggers(ctx, FollowerID)
} }
func (s *SocialService) CountFollowers(ctx context.Context, vloggerID uint) (int64, error) { func (s *SocialService) CountFollowers(ctx context.Context, vloggerID uint) (int64, error) {
return s.repo.CountFollowers(ctx, vloggerID) return s.repo.CountFollowers(ctx, vloggerID)
} }
func (s *SocialService) CountVloggers(ctx context.Context, followerID uint) (int64, error) { func (s *SocialService) CountVloggers(ctx context.Context, followerID uint) (int64, error) {
return s.repo.CountVloggers(ctx, followerID) return s.repo.CountVloggers(ctx, followerID)
} }
func (s *SocialService) IsFollowed(ctx context.Context, social *Social) (bool, error) { func (s *SocialService) IsFollowed(ctx context.Context, social *Social) (bool, error) {
_, err := s.accountrepo.FindByID(ctx, social.FollowerID) _, err := s.accountrepo.FindByID(ctx, social.FollowerID)
if err != nil { if err != nil {
return false, err return false, err
} }
_, err = s.accountrepo.FindByID(ctx, social.VloggerID) _, err = s.accountrepo.FindByID(ctx, social.VloggerID)
if err != nil { if err != nil {
return false, err return false, err
} }
return s.repo.IsFollowed(ctx, social) return s.repo.IsFollowed(ctx, social)
} }

View File

@@ -1,98 +1,98 @@
package video package video
import ( import (
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/apierror"
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/middleware/jwt"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
type CommentHandler struct { type CommentHandler struct {
service *CommentService service *CommentService
accountService *account.AccountService accountService *account.AccountService
} }
func NewCommentHandler(service *CommentService, accountService *account.AccountService) *CommentHandler { func NewCommentHandler(service *CommentService, accountService *account.AccountService) *CommentHandler {
return &CommentHandler{service: service, accountService: accountService} return &CommentHandler{service: service, accountService: accountService}
} }
func (h *CommentHandler) PublishComment(c *gin.Context) { func (h *CommentHandler) PublishComment(c *gin.Context) {
var req PublishCommentRequest var req PublishCommentRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.Content == "" { if req.Content == "" {
c.JSON(400, gin.H{"error": "content is required"}) c.JSON(400, gin.H{"error": "content is required"})
return return
} }
if req.VideoID <= 0 { if req.VideoID <= 0 {
c.JSON(400, gin.H{"error": "video_id is required"}) c.JSON(400, gin.H{"error": "video_id is required"})
return return
} }
authorId, err := jwt.GetAccountID(c) authorId, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
user, err := h.accountService.FindByID(c.Request.Context(), authorId) user, err := h.accountService.FindByID(c.Request.Context(), authorId)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
comment := &Comment{ comment := &Comment{
Username: user.Username, Username: user.Username,
VideoID: req.VideoID, VideoID: req.VideoID,
AuthorID: authorId, AuthorID: authorId,
Content: req.Content, Content: req.Content,
} }
if err := h.service.Publish(c.Request.Context(), comment); err != nil { if err := h.service.Publish(c.Request.Context(), comment); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "comment published successfully"}) c.JSON(200, gin.H{"message": "comment published successfully"})
} }
func (h *CommentHandler) DeleteComment(c *gin.Context) { func (h *CommentHandler) DeleteComment(c *gin.Context) {
var req DeleteCommentRequest var req DeleteCommentRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.CommentID <= 0 { if req.CommentID <= 0 {
c.JSON(400, gin.H{"error": "comment_id is required"}) c.JSON(400, gin.H{"error": "comment_id is required"})
return return
} }
if err := h.service.Delete(c.Request.Context(), req.CommentID, accountID); err != nil { if err := h.service.Delete(c.Request.Context(), req.CommentID, accountID); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "comment deleted successfully"}) c.JSON(200, gin.H{"message": "comment deleted successfully"})
} }
func (h *CommentHandler) GetAllComments(c *gin.Context) { func (h *CommentHandler) GetAllComments(c *gin.Context) {
var req GetAllCommentsRequest var req GetAllCommentsRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VideoID == 0 { if req.VideoID == 0 {
c.JSON(400, gin.H{"error": "video_id is required"}) c.JSON(400, gin.H{"error": "video_id is required"})
return return
} }
comments, err := h.service.GetAll(c.Request.Context(), req.VideoID) comments, err := h.service.GetAll(c.Request.Context(), req.VideoID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if comments == nil { if comments == nil {
comments = []Comment{} comments = []Comment{}
} }
c.JSON(200, comments) c.JSON(200, comments)
} }

View File

@@ -1,55 +1,55 @@
package video package video
import ( import (
"context" "context"
"gorm.io/gorm" "gorm.io/gorm"
) )
type CommentRepository struct { type CommentRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewCommentRepository(db *gorm.DB) *CommentRepository { func NewCommentRepository(db *gorm.DB) *CommentRepository {
return &CommentRepository{db: db} return &CommentRepository{db: db}
} }
func (r *CommentRepository) CreateComment(ctx context.Context, comment *Comment) error { func (r *CommentRepository) CreateComment(ctx context.Context, comment *Comment) error {
return r.db.WithContext(ctx).Create(comment).Error return r.db.WithContext(ctx).Create(comment).Error
} }
func (r *CommentRepository) DeleteComment(ctx context.Context, comment *Comment) error { func (r *CommentRepository) DeleteComment(ctx context.Context, comment *Comment) error {
return r.db.WithContext(ctx).Delete(comment).Error return r.db.WithContext(ctx).Delete(comment).Error
} }
func (r *CommentRepository) GetAllComments(ctx context.Context, videoID uint) ([]Comment, error) { func (r *CommentRepository) GetAllComments(ctx context.Context, videoID uint) ([]Comment, error) {
var comments []Comment var comments []Comment
err := r.db.WithContext(ctx). err := r.db.WithContext(ctx).
Where("video_id = ?", videoID). Where("video_id = ?", videoID).
Order("created_at asc"). Order("created_at asc").
Limit(200). Limit(200).
Find(&comments).Error Find(&comments).Error
return comments, err return comments, err
} }
func (r *CommentRepository) IsExist(ctx context.Context, id uint) (bool, error) { func (r *CommentRepository) IsExist(ctx context.Context, id uint) (bool, error) {
var comment Comment var comment Comment
if err := r.db.WithContext(ctx).First(&comment, id).Error; err != nil { if err := r.db.WithContext(ctx).First(&comment, id).Error; err != nil {
if err == gorm.ErrRecordNotFound { if err == gorm.ErrRecordNotFound {
return false, nil return false, nil
} }
return false, err return false, err
} }
return true, nil return true, nil
} }
func (r *CommentRepository) GetByID(ctx context.Context, id uint) (*Comment, error) { func (r *CommentRepository) GetByID(ctx context.Context, id uint) (*Comment, error) {
var comment Comment var comment Comment
if err := r.db.WithContext(ctx).First(&comment, id).Error; err != nil { if err := r.db.WithContext(ctx).First(&comment, id).Error; err != nil {
if err == gorm.ErrRecordNotFound { if err == gorm.ErrRecordNotFound {
return nil, nil return nil, nil
} }
return nil, err return nil, err
} }
return &comment, nil return &comment, nil
} }

View File

@@ -1,155 +1,155 @@
package video package video
import ( import (
"context" "context"
"errors" "errors"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/apierror"
rediscache "feedsystem_video_go/internal/middleware/redis" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/apierror" rediscache "feedsystem_video_go/internal/middleware/redis"
"regexp" "regexp"
"strings" "strings"
"gorm.io/gorm" "gorm.io/gorm"
) )
type CommentService struct { type CommentService struct {
repo *CommentRepository repo *CommentRepository
VideoRepository *VideoRepository VideoRepository *VideoRepository
cache *rediscache.Client cache *rediscache.Client
commentMQ *rabbitmq.CommentMQ commentMQ *rabbitmq.CommentMQ
popularityMQ *rabbitmq.PopularityMQ popularityMQ *rabbitmq.PopularityMQ
} }
func NewCommentService(repo *CommentRepository, videoRepo *VideoRepository, cache *rediscache.Client, commentMQ *rabbitmq.CommentMQ, popularityMQ *rabbitmq.PopularityMQ) *CommentService { func NewCommentService(repo *CommentRepository, videoRepo *VideoRepository, cache *rediscache.Client, commentMQ *rabbitmq.CommentMQ, popularityMQ *rabbitmq.PopularityMQ) *CommentService {
return &CommentService{repo: repo, VideoRepository: videoRepo, cache: cache, commentMQ: commentMQ, popularityMQ: popularityMQ} return &CommentService{repo: repo, VideoRepository: videoRepo, cache: cache, commentMQ: commentMQ, popularityMQ: popularityMQ}
} }
func (s *CommentService) Publish(ctx context.Context, comment *Comment) error { func (s *CommentService) Publish(ctx context.Context, comment *Comment) error {
if comment == nil { if comment == nil {
return errors.New("comment is nil") return errors.New("comment is nil")
} }
comment.Username = strings.TrimSpace(comment.Username) comment.Username = strings.TrimSpace(comment.Username)
comment.Content = strings.TrimSpace(comment.Content) comment.Content = strings.TrimSpace(comment.Content)
if comment.VideoID == 0 || comment.AuthorID == 0 { if comment.VideoID == 0 || comment.AuthorID == 0 {
return errors.New("video_id and author_id are required") return errors.New("video_id and author_id are required")
} }
if comment.Content == "" { if comment.Content == "" {
return errors.New("content is required") return errors.New("content is required")
} }
exists, err := s.VideoRepository.IsExist(ctx, comment.VideoID) exists, err := s.VideoRepository.IsExist(ctx, comment.VideoID)
if err != nil { if err != nil {
return err return err
} }
if !exists { if !exists {
return errors.New("video not found") return errors.New("video not found")
} }
mysqlEnqueued := false mysqlEnqueued := false
redisEnqueued := false redisEnqueued := false
if s.commentMQ != nil { if s.commentMQ != nil {
if err := s.commentMQ.Publish(ctx, comment.Username, comment.VideoID, comment.AuthorID, comment.Content); err == nil { if err := s.commentMQ.Publish(ctx, comment.Username, comment.VideoID, comment.AuthorID, comment.Content); err == nil {
mysqlEnqueued = true mysqlEnqueued = true
} }
} }
if s.popularityMQ != nil { if s.popularityMQ != nil {
if err := s.popularityMQ.Update(ctx, comment.VideoID, 1); err == nil { if err := s.popularityMQ.Update(ctx, comment.VideoID, 1); err == nil {
redisEnqueued = true redisEnqueued = true
} }
} }
if mysqlEnqueued && redisEnqueued { if mysqlEnqueued && redisEnqueued {
s.notifyMentions(ctx, comment) s.notifyMentions(ctx, comment)
return nil return nil
} }
// Fallback: direct MySQL write when comment MQ publish fails. // Fallback: direct MySQL write when comment MQ publish fails.
if !mysqlEnqueued { if !mysqlEnqueued {
if err := s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { if err := s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Select("id").First(&Video{}, comment.VideoID).Error; err != nil { if err := tx.Select("id").First(&Video{}, comment.VideoID).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) { if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("video not found") return errors.New("video not found")
} }
return err return err
} }
if err := tx.Create(comment).Error; err != nil { if err := tx.Create(comment).Error; err != nil {
return err return err
} }
return tx.Model(&Video{}).Where("id = ?", comment.VideoID). return tx.Model(&Video{}).Where("id = ?", comment.VideoID).
UpdateColumn("popularity", gorm.Expr("popularity + 1")).Error UpdateColumn("popularity", gorm.Expr("popularity + 1")).Error
}); err != nil { }); err != nil {
return err return err
} }
} }
// Fallback: direct Redis update when popularity MQ publish fails. // Fallback: direct Redis update when popularity MQ publish fails.
if !redisEnqueued { if !redisEnqueued {
UpdatePopularityCache(ctx, s.cache, comment.VideoID, 1) UpdatePopularityCache(ctx, s.cache, comment.VideoID, 1)
} }
s.notifyMentions(ctx, comment) s.notifyMentions(ctx, comment)
return nil return nil
} }
func (s *CommentService) Delete(ctx context.Context, commentID uint, accountID uint) error { func (s *CommentService) Delete(ctx context.Context, commentID uint, accountID uint) error {
comment, err := s.repo.GetByID(ctx, commentID) comment, err := s.repo.GetByID(ctx, commentID)
if err != nil { if err != nil {
return err return err
} }
if comment == nil { if comment == nil {
return errors.New("comment not found") return errors.New("comment not found")
} }
if comment.AuthorID != accountID { if comment.AuthorID != accountID {
return apierror.ErrUnauthorized return apierror.ErrUnauthorized
} }
if s.commentMQ != nil { if s.commentMQ != nil {
if err := s.commentMQ.Delete(ctx, commentID); err == nil { if err := s.commentMQ.Delete(ctx, commentID); err == nil {
return nil return nil
} }
} }
return s.repo.DeleteComment(ctx, comment) return s.repo.DeleteComment(ctx, comment)
} }
func (s *CommentService) GetAll(ctx context.Context, videoID uint) ([]Comment, error) { func (s *CommentService) GetAll(ctx context.Context, videoID uint) ([]Comment, error) {
exists, err := s.VideoRepository.IsExist(ctx, videoID) exists, err := s.VideoRepository.IsExist(ctx, videoID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if !exists { if !exists {
return nil, errors.New("video not found") return nil, errors.New("video not found")
} }
return s.repo.GetAllComments(ctx, videoID) return s.repo.GetAllComments(ctx, videoID)
} }
var mentionRegex = regexp.MustCompile(`@(\w+)`) var mentionRegex = regexp.MustCompile(`@(\w+)`)
func (s *CommentService) notifyMentions(ctx context.Context, comment *Comment) { func (s *CommentService) notifyMentions(ctx context.Context, comment *Comment) {
matches := mentionRegex.FindAllStringSubmatch(comment.Content, -1) matches := mentionRegex.FindAllStringSubmatch(comment.Content, -1)
if len(matches) == 0 { if len(matches) == 0 {
return return
} }
seen := make(map[string]bool) seen := make(map[string]bool)
for _, m := range matches { for _, m := range matches {
username := m[1] username := m[1]
if seen[username] || username == comment.Username { if seen[username] || username == comment.Username {
continue continue
} }
seen[username] = true seen[username] = true
var accID uint var accID uint
if err := s.repo.db.WithContext(ctx).Table("accounts").Where("username = ?", username).Select("id").Scan(&accID).Error; err != nil || accID == 0 { if err := s.repo.db.WithContext(ctx).Table("accounts").Where("username = ?", username).Select("id").Scan(&accID).Error; err != nil || accID == 0 {
continue continue
} }
notif := struct { notif := struct {
RecipientID uint RecipientID uint
SenderID uint SenderID uint
Type string Type string
TargetID uint TargetID uint
Content string Content string
}{ }{
RecipientID: accID, RecipientID: accID,
SenderID: comment.AuthorID, SenderID: comment.AuthorID,
Type: "mention", Type: "mention",
TargetID: comment.VideoID, TargetID: comment.VideoID,
Content: comment.Username + " 在评论中提到了你", Content: comment.Username + " 在评论中提到了你",
} }
s.repo.db.WithContext(ctx).Table("notifications").Create(&notif) s.repo.db.WithContext(ctx).Table("notifications").Create(&notif)
} }
} }

View File

@@ -1,114 +1,114 @@
package video package video
import ( import (
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/apierror"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/middleware/jwt"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
type LikeHandler struct { type LikeHandler struct {
service *LikeService service *LikeService
} }
func NewLikeHandler(service *LikeService) *LikeHandler { func NewLikeHandler(service *LikeService) *LikeHandler {
return &LikeHandler{service: service} return &LikeHandler{service: service}
} }
func (lh *LikeHandler) Like(c *gin.Context) { func (lh *LikeHandler) Like(c *gin.Context) {
var req LikeRequest var req LikeRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VideoID <= 0 { if req.VideoID <= 0 {
c.JSON(400, gin.H{"error": "video_id is required"}) c.JSON(400, gin.H{"error": "video_id is required"})
return return
} }
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
like := &Like{ like := &Like{
VideoID: req.VideoID, VideoID: req.VideoID,
AccountID: accountID, AccountID: accountID,
} }
if err := lh.service.Like(c.Request.Context(), like); err != nil { if err := lh.service.Like(c.Request.Context(), like); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "like success"}) c.JSON(200, gin.H{"message": "like success"})
} }
func (lh *LikeHandler) Unlike(c *gin.Context) { func (lh *LikeHandler) Unlike(c *gin.Context) {
var req LikeRequest var req LikeRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VideoID <= 0 { if req.VideoID <= 0 {
c.JSON(400, gin.H{"error": "video_id is required"}) c.JSON(400, gin.H{"error": "video_id is required"})
return return
} }
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
like := &Like{ like := &Like{
VideoID: req.VideoID, VideoID: req.VideoID,
AccountID: accountID, AccountID: accountID,
} }
if err := lh.service.Unlike(c.Request.Context(), like); err != nil { if err := lh.service.Unlike(c.Request.Context(), like); err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "unlike success"}) c.JSON(200, gin.H{"message": "unlike success"})
} }
func (lh *LikeHandler) IsLiked(c *gin.Context) { func (lh *LikeHandler) IsLiked(c *gin.Context) {
var req LikeRequest var req LikeRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if req.VideoID <= 0 { if req.VideoID <= 0 {
c.JSON(400, gin.H{"error": "video_id is required"}) c.JSON(400, gin.H{"error": "video_id is required"})
return return
} }
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
isLiked, err := lh.service.IsLiked(c.Request.Context(), req.VideoID, accountID) isLiked, err := lh.service.IsLiked(c.Request.Context(), req.VideoID, accountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"is_liked": isLiked}) c.JSON(200, gin.H{"is_liked": isLiked})
} }
func (lh *LikeHandler) ListMyLikedVideos(c *gin.Context) { func (lh *LikeHandler) ListMyLikedVideos(c *gin.Context) {
accountID, err := jwt.GetAccountID(c) accountID, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
videos, err := lh.service.ListLikedVideos(c.Request.Context(), accountID) videos, err := lh.service.ListLikedVideos(c.Request.Context(), accountID)
if err != nil { if err != nil {
c.JSON(500, gin.H{"error": err.Error()}) c.JSON(500, gin.H{"error": err.Error()})
return return
} }
if videos == nil { if videos == nil {
videos = []Video{} videos = []Video{}
} }
c.JSON(200, videos) c.JSON(200, videos)
} }

View File

@@ -1,102 +1,102 @@
package video package video
import ( import (
"context" "context"
"errors" "errors"
"github.com/go-sql-driver/mysql" "github.com/go-sql-driver/mysql"
"gorm.io/gorm" "gorm.io/gorm"
) )
type LikeRepository struct { type LikeRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewLikeRepository(db *gorm.DB) *LikeRepository { func NewLikeRepository(db *gorm.DB) *LikeRepository {
return &LikeRepository{db: db} return &LikeRepository{db: db}
} }
func (r *LikeRepository) Like(ctx context.Context, like *Like) error { func (r *LikeRepository) Like(ctx context.Context, like *Like) error {
return r.db.WithContext(ctx).Create(like).Error return r.db.WithContext(ctx).Create(like).Error
} }
func (r *LikeRepository) Unlike(ctx context.Context, like *Like) error { func (r *LikeRepository) Unlike(ctx context.Context, like *Like) error {
return r.db.WithContext(ctx). return r.db.WithContext(ctx).
Where("video_id = ? AND account_id = ?", like.VideoID, like.AccountID). Where("video_id = ? AND account_id = ?", like.VideoID, like.AccountID).
Delete(&Like{}).Error Delete(&Like{}).Error
} }
func (r *LikeRepository) LikeIgnoreDuplicate(ctx context.Context, like *Like) (created bool, err error) { func (r *LikeRepository) LikeIgnoreDuplicate(ctx context.Context, like *Like) (created bool, err error) {
if like == nil || like.VideoID == 0 || like.AccountID == 0 { if like == nil || like.VideoID == 0 || like.AccountID == 0 {
return false, nil return false, nil
} }
err = r.db.WithContext(ctx).Create(like).Error err = r.db.WithContext(ctx).Create(like).Error
if err == nil { if err == nil {
return true, nil return true, nil
} }
var mysqlErr *mysql.MySQLError var mysqlErr *mysql.MySQLError
if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 { if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
return false, nil return false, nil
} }
return false, err return false, err
} }
func (r *LikeRepository) DeleteByVideoAndAccount(ctx context.Context, videoID, accountID uint) (deleted bool, err error) { func (r *LikeRepository) DeleteByVideoAndAccount(ctx context.Context, videoID, accountID uint) (deleted bool, err error) {
if videoID == 0 || accountID == 0 { if videoID == 0 || accountID == 0 {
return false, nil return false, nil
} }
res := r.db.WithContext(ctx). res := r.db.WithContext(ctx).
Where("video_id = ? AND account_id = ?", videoID, accountID). Where("video_id = ? AND account_id = ?", videoID, accountID).
Delete(&Like{}) Delete(&Like{})
return res.RowsAffected > 0, res.Error return res.RowsAffected > 0, res.Error
} }
func (r *LikeRepository) IsLiked(ctx context.Context, videoID, accountID uint) (bool, error) { func (r *LikeRepository) IsLiked(ctx context.Context, videoID, accountID uint) (bool, error) {
var count int64 var count int64
err := r.db.WithContext(ctx).Model(&Like{}). err := r.db.WithContext(ctx).Model(&Like{}).
Where("video_id = ? AND account_id = ?", videoID, accountID). Where("video_id = ? AND account_id = ?", videoID, accountID).
Count(&count).Error Count(&count).Error
if err != nil { if err != nil {
return false, err return false, err
} }
return count > 0, nil return count > 0, nil
} }
func (r *LikeRepository) BatchGetLiked(ctx context.Context, videoIDs []uint, accountID uint) (map[uint]bool, error) { func (r *LikeRepository) BatchGetLiked(ctx context.Context, videoIDs []uint, accountID uint) (map[uint]bool, error) {
likeMap := make(map[uint]bool) likeMap := make(map[uint]bool)
if len(videoIDs) == 0 { if len(videoIDs) == 0 {
return likeMap, nil return likeMap, nil
} }
if accountID == 0 { if accountID == 0 {
return likeMap, nil return likeMap, nil
} }
var likes []Like var likes []Like
err := r.db.WithContext(ctx).Model(&Like{}). err := r.db.WithContext(ctx).Model(&Like{}).
Where("video_id IN ? AND account_id = ?", videoIDs, accountID). Where("video_id IN ? AND account_id = ?", videoIDs, accountID).
Find(&likes).Error Find(&likes).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
for _, like := range likes { for _, like := range likes {
likeMap[like.VideoID] = true likeMap[like.VideoID] = true
} }
return likeMap, nil return likeMap, nil
} }
func (r *LikeRepository) ListLikedVideos(ctx context.Context, accountID uint) ([]Video, error) { func (r *LikeRepository) ListLikedVideos(ctx context.Context, accountID uint) ([]Video, error) {
var videos []Video var videos []Video
if accountID == 0 { if accountID == 0 {
return videos, nil return videos, nil
} }
err := r.db.WithContext(ctx). err := r.db.WithContext(ctx).
Model(&Video{}). Model(&Video{}).
Joins("JOIN likes ON likes.video_id = videos.id"). Joins("JOIN likes ON likes.video_id = videos.id").
Where("likes.account_id = ?", accountID). Where("likes.account_id = ?", accountID).
Order("likes.created_at desc"). Order("likes.created_at desc").
Limit(200). Limit(200).
Find(&videos).Error Find(&videos).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }

View File

@@ -1,28 +1,28 @@
package video package video
import ( import (
"context" "context"
"strconv" "strconv"
"time" "time"
rediscache "feedsystem_video_go/internal/middleware/redis" rediscache "feedsystem_video_go/internal/middleware/redis"
) )
// 更新视频流行度缓存 // 更新视频流行度缓存
func UpdatePopularityCache(ctx context.Context, cache *rediscache.Client, id uint, change int64) { func UpdatePopularityCache(ctx context.Context, cache *rediscache.Client, id uint, change int64) {
if cache == nil || id == 0 || change == 0 { if cache == nil || id == 0 || change == 0 {
return return
} }
_ = cache.Del(context.Background(), cache.Key("video:detail:id=%d", id)) _ = cache.Del(context.Background(), cache.Key("video:detail:id=%d", id))
now := time.Now().UTC().Truncate(time.Minute) now := time.Now().UTC().Truncate(time.Minute)
windowKey := cache.Key("hot:video:1m:%s", now.Format("200601021504")) windowKey := cache.Key("hot:video:1m:%s", now.Format("200601021504"))
member := strconv.FormatUint(uint64(id), 10) member := strconv.FormatUint(uint64(id), 10)
opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
_ = cache.ZincrBy(opCtx, windowKey, member, float64(change)) _ = cache.ZincrBy(opCtx, windowKey, member, float64(change))
_ = cache.Expire(opCtx, windowKey, 2*time.Hour) _ = cache.Expire(opCtx, windowKey, 2*time.Hour)
} }

View File

@@ -1,48 +1,48 @@
package video package video
import "time" import "time"
type Video struct { type Video struct {
ID uint `gorm:"primaryKey" json:"id"` ID uint `gorm:"primaryKey" json:"id"`
AuthorID uint `gorm:"index;not null" json:"author_id"` AuthorID uint `gorm:"index;not null" json:"author_id"`
Username string `gorm:"type:varchar(255);not null" json:"username"` Username string `gorm:"type:varchar(255);not null" json:"username"`
Title string `gorm:"type:varchar(255);not null" json:"title"` Title string `gorm:"type:varchar(255);not null" json:"title"`
Description string `gorm:"type:varchar(255);" json:"description,omitempty"` Description string `gorm:"type:varchar(255);" json:"description,omitempty"`
PlayURL string `gorm:"type:varchar(255);not null" json:"play_url"` PlayURL string `gorm:"type:varchar(255);not null" json:"play_url"`
CoverURL string `gorm:"type:varchar(255);not null" json:"cover_url"` CoverURL string `gorm:"type:varchar(255);not null" json:"cover_url"`
CreateTime time.Time `gorm:"autoCreateTime;index:idx_videos_create_time,sort:desc;index:idx_videos_popularity_time_id,priority:2,sort:desc" json:"create_time"` CreateTime time.Time `gorm:"autoCreateTime;index:idx_videos_create_time,sort:desc;index:idx_videos_popularity_time_id,priority:2,sort:desc" json:"create_time"`
LikesCount int64 `gorm:"column:likes_count;not null;default:0;index:idx_videos_likes_count_id,priority:1,sort:desc" json:"likes_count"` LikesCount int64 `gorm:"column:likes_count;not null;default:0;index:idx_videos_likes_count_id,priority:1,sort:desc" json:"likes_count"`
Popularity int64 `gorm:"column:popularity;not null;default:0;index:idx_videos_popularity_time_id,priority:1,sort:desc" json:"popularity"` Popularity int64 `gorm:"column:popularity;not null;default:0;index:idx_videos_popularity_time_id,priority:1,sort:desc" json:"popularity"`
} }
type PublishVideoRequest struct { type PublishVideoRequest struct {
Title string `json:"title"` Title string `json:"title"`
Description string `json:"description"` Description string `json:"description"`
PlayURL string `json:"play_url"` PlayURL string `json:"play_url"`
CoverURL string `json:"cover_url"` CoverURL string `json:"cover_url"`
} }
type DeleteVideoRequest struct { type DeleteVideoRequest struct {
ID uint `json:"id"` ID uint `json:"id"`
} }
type ListByAuthorIDRequest struct { type ListByAuthorIDRequest struct {
AuthorID uint `json:"author_id"` AuthorID uint `json:"author_id"`
} }
type GetDetailRequest struct { type GetDetailRequest struct {
ID uint `json:"id"` ID uint `json:"id"`
} }
type UpdateLikesCountRequest struct { type UpdateLikesCountRequest struct {
ID uint `json:"id"` ID uint `json:"id"`
LikesCount int64 `json:"likes_count"` LikesCount int64 `json:"likes_count"`
} }
type OutboxMsg struct { type OutboxMsg struct {
ID uint `gorm:"primaryKey"` ID uint `gorm:"primaryKey"`
VideoID uint `gorm:"index"` VideoID uint `gorm:"index"`
EventType string `gorm:"type:varchar(50)"` EventType string `gorm:"type:varchar(50)"`
CreateTime time.Time `gorm:"autoCreateTime"` CreateTime time.Time `gorm:"autoCreateTime"`
Status string `gorm:"type:varchar(50);index"` Status string `gorm:"type:varchar(50);index"`
} }

View File

@@ -1,254 +1,254 @@
package video package video
import ( import (
"crypto/rand" "crypto/rand"
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"net/http" "net/http"
"os" "os"
"path" "path"
"path/filepath" "path/filepath"
"strings" "strings"
"time" "time"
"feedsystem_video_go/internal/account" "feedsystem_video_go/internal/account"
"feedsystem_video_go/internal/apierror" "feedsystem_video_go/internal/apierror"
"feedsystem_video_go/internal/middleware/jwt" "feedsystem_video_go/internal/middleware/jwt"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
type VideoHandler struct { type VideoHandler struct {
service *VideoService service *VideoService
accountService *account.AccountService accountService *account.AccountService
} }
func NewVideoHandler(service *VideoService, accountService *account.AccountService) *VideoHandler { func NewVideoHandler(service *VideoService, accountService *account.AccountService) *VideoHandler {
return &VideoHandler{service: service, accountService: accountService} return &VideoHandler{service: service, accountService: accountService}
} }
func (vh *VideoHandler) PublishVideo(c *gin.Context) { func (vh *VideoHandler) PublishVideo(c *gin.Context) {
var req PublishVideoRequest var req PublishVideoRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
authorId, err := jwt.GetAccountID(c) authorId, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
username, err := jwt.GetUsername(c) username, err := jwt.GetUsername(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
video := &Video{ video := &Video{
AuthorID: authorId, AuthorID: authorId,
Username: username, Username: username,
Title: req.Title, Title: req.Title,
Description: req.Description, Description: req.Description,
PlayURL: req.PlayURL, PlayURL: req.PlayURL,
CoverURL: req.CoverURL, CoverURL: req.CoverURL,
CreateTime: time.Now(), CreateTime: time.Now(),
} }
if err := vh.service.Publish(c.Request.Context(), video); err != nil { if err := vh.service.Publish(c.Request.Context(), video); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, video) c.JSON(200, video)
} }
func (vh *VideoHandler) UploadVideo(c *gin.Context) { func (vh *VideoHandler) UploadVideo(c *gin.Context) {
authorId, err := jwt.GetAccountID(c) authorId, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return return
} }
f, err := c.FormFile("file") f, err := c.FormFile("file")
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"}) c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"})
return return
} }
const maxSize = 200 << 20 const maxSize = 200 << 20
if f.Size <= 0 || f.Size > maxSize { if f.Size <= 0 || f.Size > maxSize {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"}) c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"})
return return
} }
ext := strings.ToLower(filepath.Ext(f.Filename)) ext := strings.ToLower(filepath.Ext(f.Filename))
if ext != ".mp4" { if ext != ".mp4" {
c.JSON(http.StatusBadRequest, gin.H{"error": "only .mp4 is allowed"}) c.JSON(http.StatusBadRequest, gin.H{"error": "only .mp4 is allowed"})
return return
} }
date := time.Now().Format("20060102") date := time.Now().Format("20060102")
relDir := filepath.Join("videos", fmt.Sprintf("%d", authorId), date) relDir := filepath.Join("videos", fmt.Sprintf("%d", authorId), date)
root := filepath.Join(".run", "uploads") root := filepath.Join(".run", "uploads")
absDir := filepath.Join(root, relDir) absDir := filepath.Join(root, relDir)
if err := os.MkdirAll(absDir, 0o755); err != nil { if err := os.MkdirAll(absDir, 0o755); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
filename, err := randHex(16) filename, err := randHex(16)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to generate filename"}) c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to generate filename"})
return return
} }
filename = filename + ext filename = filename + ext
absPath := filepath.Join(absDir, filename) absPath := filepath.Join(absDir, filename)
if err := c.SaveUploadedFile(f, absPath); err != nil { if err := c.SaveUploadedFile(f, absPath); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
urlPath := path.Join("/static", "videos", fmt.Sprintf("%d", authorId), date, filename) urlPath := path.Join("/static", "videos", fmt.Sprintf("%d", authorId), date, filename)
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"url": buildAbsoluteURL(c, urlPath), "url": buildAbsoluteURL(c, urlPath),
"play_url": buildAbsoluteURL(c, urlPath), "play_url": buildAbsoluteURL(c, urlPath),
}) })
} }
func (vh *VideoHandler) UploadCover(c *gin.Context) { func (vh *VideoHandler) UploadCover(c *gin.Context) {
authorId, err := jwt.GetAccountID(c) authorId, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return return
} }
f, err := c.FormFile("file") f, err := c.FormFile("file")
if err != nil { if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"}) c.JSON(http.StatusBadRequest, gin.H{"error": "missing file"})
return return
} }
const maxSize = 10 << 20 const maxSize = 10 << 20
if f.Size <= 0 || f.Size > maxSize { if f.Size <= 0 || f.Size > maxSize {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"}) c.JSON(http.StatusBadRequest, gin.H{"error": "invalid file size"})
return return
} }
ext := strings.ToLower(filepath.Ext(f.Filename)) ext := strings.ToLower(filepath.Ext(f.Filename))
switch ext { switch ext {
case ".jpg", ".jpeg", ".png", ".webp": case ".jpg", ".jpeg", ".png", ".webp":
default: default:
c.JSON(http.StatusBadRequest, gin.H{"error": "only .jpg/.jpeg/.png/.webp is allowed"}) c.JSON(http.StatusBadRequest, gin.H{"error": "only .jpg/.jpeg/.png/.webp is allowed"})
return return
} }
date := time.Now().Format("20060102") date := time.Now().Format("20060102")
relDir := filepath.Join("covers", fmt.Sprintf("%d", authorId), date) relDir := filepath.Join("covers", fmt.Sprintf("%d", authorId), date)
root := filepath.Join(".run", "uploads") root := filepath.Join(".run", "uploads")
absDir := filepath.Join(root, relDir) absDir := filepath.Join(root, relDir)
if err := os.MkdirAll(absDir, 0o755); err != nil { if err := os.MkdirAll(absDir, 0o755); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
filename, err := randHex(16) filename, err := randHex(16)
if err != nil { if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to generate filename"}) c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to generate filename"})
return return
} }
filename = filename + ext filename = filename + ext
absPath := filepath.Join(absDir, filename) absPath := filepath.Join(absDir, filename)
if err := c.SaveUploadedFile(f, absPath); err != nil { if err := c.SaveUploadedFile(f, absPath); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return return
} }
urlPath := path.Join("/static", "covers", fmt.Sprintf("%d", authorId), date, filename) urlPath := path.Join("/static", "covers", fmt.Sprintf("%d", authorId), date, filename)
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"url": buildAbsoluteURL(c, urlPath), "url": buildAbsoluteURL(c, urlPath),
"cover_url": buildAbsoluteURL(c, urlPath), "cover_url": buildAbsoluteURL(c, urlPath),
}) })
} }
func randHex(n int) (string, error) { func randHex(n int) (string, error) {
b := make([]byte, n) b := make([]byte, n)
if _, err := rand.Read(b); err != nil { if _, err := rand.Read(b); err != nil {
return "", fmt.Errorf("rand.Read: %w", err) return "", fmt.Errorf("rand.Read: %w", err)
} }
return hex.EncodeToString(b), nil return hex.EncodeToString(b), nil
} }
func buildAbsoluteURL(c *gin.Context, p string) string { func buildAbsoluteURL(c *gin.Context, p string) string {
scheme := "http" scheme := "http"
if c.Request.TLS != nil { if c.Request.TLS != nil {
scheme = "https" scheme = "https"
} }
if xf := c.GetHeader("X-Forwarded-Proto"); xf != "" { if xf := c.GetHeader("X-Forwarded-Proto"); xf != "" {
scheme = xf scheme = xf
} }
return fmt.Sprintf("%s://%s%s", scheme, c.Request.Host, p) return fmt.Sprintf("%s://%s%s", scheme, c.Request.Host, p)
} }
func (vh *VideoHandler) DeleteVideo(c *gin.Context) { func (vh *VideoHandler) DeleteVideo(c *gin.Context) {
var req DeleteVideoRequest var req DeleteVideoRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
authorId, err := jwt.GetAccountID(c) authorId, err := jwt.GetAccountID(c)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := vh.service.Delete(c.Request.Context(), req.ID, authorId); err != nil { if err := vh.service.Delete(c.Request.Context(), req.ID, authorId); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "video deleted"}) c.JSON(200, gin.H{"message": "video deleted"})
} }
func (vh *VideoHandler) ListByAuthorID(c *gin.Context) { func (vh *VideoHandler) ListByAuthorID(c *gin.Context) {
var req ListByAuthorIDRequest var req ListByAuthorIDRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
videos, err := vh.service.ListByAuthorID(c.Request.Context(), req.AuthorID) videos, err := vh.service.ListByAuthorID(c.Request.Context(), req.AuthorID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if videos == nil { if videos == nil {
videos = []Video{} videos = []Video{}
} }
c.JSON(200, videos) c.JSON(200, videos)
} }
func (vh *VideoHandler) GetDetail(c *gin.Context) { func (vh *VideoHandler) GetDetail(c *gin.Context) {
var req GetDetailRequest var req GetDetailRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
video, err := vh.service.GetDetail(c.Request.Context(), req.ID) video, err := vh.service.GetDetail(c.Request.Context(), req.ID)
if err != nil { if err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, video) c.JSON(200, video)
} }
func (vh *VideoHandler) UpdateLikesCount(c *gin.Context) { func (vh *VideoHandler) UpdateLikesCount(c *gin.Context) {
var req UpdateLikesCountRequest var req UpdateLikesCountRequest
if err := c.ShouldBindJSON(&req); err != nil { if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
if err := vh.service.UpdateLikesCount(c.Request.Context(), req.ID, req.LikesCount); err != nil { if err := vh.service.UpdateLikesCount(c.Request.Context(), req.ID, req.LikesCount); err != nil {
c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()}) c.JSON(apierror.ClassifyHTTPStatus(err), gin.H{"error": err.Error()})
return return
} }
c.JSON(200, gin.H{"message": "likes count updated"}) c.JSON(200, gin.H{"message": "likes count updated"})
} }

View File

@@ -1,120 +1,120 @@
package video package video
import ( import (
"context" "context"
"errors" "errors"
"gorm.io/gorm" "gorm.io/gorm"
) )
type VideoRepository struct { type VideoRepository struct {
db *gorm.DB db *gorm.DB
} }
func NewVideoRepository(db *gorm.DB) *VideoRepository { func NewVideoRepository(db *gorm.DB) *VideoRepository {
return &VideoRepository{db: db} return &VideoRepository{db: db}
} }
func (vr *VideoRepository) CreateVideo(ctx context.Context, video *Video) error { func (vr *VideoRepository) CreateVideo(ctx context.Context, video *Video) error {
if err := vr.db.WithContext(ctx).Create(video).Error; err != nil { if err := vr.db.WithContext(ctx).Create(video).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) CreateMsg(ctx context.Context, Msg *OutboxMsg) error { func (vr *VideoRepository) CreateMsg(ctx context.Context, Msg *OutboxMsg) error {
if err := vr.db.WithContext(ctx).Create(Msg).Error; err != nil { if err := vr.db.WithContext(ctx).Create(Msg).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) DeleteVideo(ctx context.Context, id uint) error { func (vr *VideoRepository) DeleteVideo(ctx context.Context, id uint) error {
if err := vr.db.WithContext(ctx).Delete(&Video{}, id).Error; err != nil { if err := vr.db.WithContext(ctx).Delete(&Video{}, id).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) ListByAuthorID(ctx context.Context, authorID int64) ([]Video, error) { func (vr *VideoRepository) ListByAuthorID(ctx context.Context, authorID int64) ([]Video, error) {
var videos []Video var videos []Video
if err := vr.db.WithContext(ctx). if err := vr.db.WithContext(ctx).
Where("author_id = ?", authorID). Where("author_id = ?", authorID).
Order("create_time desc"). Order("create_time desc").
Limit(200). Limit(200).
Find(&videos).Error; err != nil { Find(&videos).Error; err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (vr *VideoRepository) GetByID(ctx context.Context, id uint) (*Video, error) { func (vr *VideoRepository) GetByID(ctx context.Context, id uint) (*Video, error) {
var video Video var video Video
if err := vr.db.WithContext(ctx).First(&video, id).Error; err != nil { if err := vr.db.WithContext(ctx).First(&video, id).Error; err != nil {
return (*Video)(nil), err return (*Video)(nil), err
} }
return &video, nil return &video, nil
} }
func (vr *VideoRepository) UpdateLikesCount(ctx context.Context, id uint, likesCount int64) error { func (vr *VideoRepository) UpdateLikesCount(ctx context.Context, id uint, likesCount int64) error {
if err := vr.db.WithContext(ctx).Model(&Video{}). if err := vr.db.WithContext(ctx).Model(&Video{}).
Where("id = ?", id). Where("id = ?", id).
Update("likes_count", likesCount).Error; err != nil { Update("likes_count", likesCount).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) IsExist(ctx context.Context, id uint) (bool, error) { func (vr *VideoRepository) IsExist(ctx context.Context, id uint) (bool, error) {
var video Video var video Video
if err := vr.db.WithContext(ctx).First(&video, id).Error; err != nil { if err := vr.db.WithContext(ctx).First(&video, id).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) { if errors.Is(err, gorm.ErrRecordNotFound) {
return false, nil return false, nil
} }
return false, err return false, err
} }
return true, nil return true, nil
} }
func (vr *VideoRepository) UpdatePopularity(ctx context.Context, id uint, change int64) error { func (vr *VideoRepository) UpdatePopularity(ctx context.Context, id uint, change int64) error {
if err := vr.db.WithContext(ctx).Model(&Video{}). if err := vr.db.WithContext(ctx).Model(&Video{}).
Where("id = ?", id). Where("id = ?", id).
Update("popularity", gorm.Expr("popularity + ?", change)).Error; err != nil { Update("popularity", gorm.Expr("popularity + ?", change)).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) ChangeLikesCount(ctx context.Context, id uint, change int64) error { func (vr *VideoRepository) ChangeLikesCount(ctx context.Context, id uint, change int64) error {
if err := vr.db.WithContext(ctx).Model(&Video{}). if err := vr.db.WithContext(ctx).Model(&Video{}).
Where("id = ?", id). Where("id = ?", id).
UpdateColumn("likes_count", gorm.Expr("GREATEST(likes_count + ?, 0)", change)).Error; err != nil { UpdateColumn("likes_count", gorm.Expr("GREATEST(likes_count + ?, 0)", change)).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) ChangePopularity(ctx context.Context, id uint, change int64) error { func (vr *VideoRepository) ChangePopularity(ctx context.Context, id uint, change int64) error {
if err := vr.db.WithContext(ctx).Model(&Video{}). if err := vr.db.WithContext(ctx).Model(&Video{}).
Where("id = ?", id). Where("id = ?", id).
UpdateColumn("popularity", gorm.Expr("GREATEST(popularity + ?, 0)", change)).Error; err != nil { UpdateColumn("popularity", gorm.Expr("GREATEST(popularity + ?, 0)", change)).Error; err != nil {
return err return err
} }
return nil return nil
} }
func (vr *VideoRepository) CountByAuthor(ctx context.Context, authorID uint) (int64, error) { func (vr *VideoRepository) CountByAuthor(ctx context.Context, authorID uint) (int64, error) {
var count int64 var count int64
if err := vr.db.WithContext(ctx).Model(&Video{}).Where("author_id = ?", authorID).Count(&count).Error; err != nil { if err := vr.db.WithContext(ctx).Model(&Video{}).Where("author_id = ?", authorID).Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return count, nil return count, nil
} }
func (vr *VideoRepository) TotalLikesByAuthor(ctx context.Context, authorID uint) (int64, error) { func (vr *VideoRepository) TotalLikesByAuthor(ctx context.Context, authorID uint) (int64, error) {
var total int64 var total int64
if err := vr.db.WithContext(ctx).Model(&Video{}).Where("author_id = ?", authorID).Select("COALESCE(SUM(likes_count), 0)").Scan(&total).Error; err != nil { if err := vr.db.WithContext(ctx).Model(&Video{}).Where("author_id = ?", authorID).Select("COALESCE(SUM(likes_count), 0)").Scan(&total).Error; err != nil {
return 0, err return 0, err
} }
return total, nil return total, nil
} }

View File

@@ -1,226 +1,226 @@
package video package video
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors" "errors"
"strconv" "strconv"
"strings" "strings"
"time" "time"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/apierror"
rediscache "feedsystem_video_go/internal/middleware/redis" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/apierror" rediscache "feedsystem_video_go/internal/middleware/redis"
"gorm.io/gorm" "gorm.io/gorm"
) )
type VideoService struct { type VideoService struct {
repo *VideoRepository repo *VideoRepository
cache *rediscache.Client cache *rediscache.Client
cacheTTL time.Duration cacheTTL time.Duration
popularityMQ *rabbitmq.PopularityMQ popularityMQ *rabbitmq.PopularityMQ
} }
func NewVideoService(repo *VideoRepository, cache *rediscache.Client, popularityMQ *rabbitmq.PopularityMQ) *VideoService { func NewVideoService(repo *VideoRepository, cache *rediscache.Client, popularityMQ *rabbitmq.PopularityMQ) *VideoService {
return &VideoService{repo: repo, cache: cache, cacheTTL: 5 * time.Minute, popularityMQ: popularityMQ} return &VideoService{repo: repo, cache: cache, cacheTTL: 5 * time.Minute, popularityMQ: popularityMQ}
} }
func (vs *VideoService) Publish(ctx context.Context, video *Video) error { func (vs *VideoService) Publish(ctx context.Context, video *Video) error {
if video == nil { if video == nil {
return errors.New("video is nil") return errors.New("video is nil")
} }
video.Title = strings.TrimSpace(video.Title) video.Title = strings.TrimSpace(video.Title)
video.PlayURL = strings.TrimSpace(video.PlayURL) video.PlayURL = strings.TrimSpace(video.PlayURL)
video.CoverURL = strings.TrimSpace(video.CoverURL) video.CoverURL = strings.TrimSpace(video.CoverURL)
if video.Title == "" { if video.Title == "" {
return errors.New("title is required") return errors.New("title is required")
} }
if video.PlayURL == "" { if video.PlayURL == "" {
return errors.New("play url is required") return errors.New("play url is required")
} }
if video.CoverURL == "" { if video.CoverURL == "" {
return errors.New("cover url is required") return errors.New("cover url is required")
} }
//事务保证视频写入库和消息写入本地消息表的一致性 //事务保证视频写入库和消息写入本地消息表的一致性
err := vs.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { err := vs.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(video).Error; err != nil { if err := tx.Create(video).Error; err != nil {
return err return err
} }
msg := OutboxMsg{ msg := OutboxMsg{
VideoID: video.ID, VideoID: video.ID,
EventType: "video_published", EventType: "video_published",
Status: "pending", Status: "pending",
CreateTime: video.CreateTime, CreateTime: video.CreateTime,
} }
if err := tx.Create(&msg).Error; err != nil { if err := tx.Create(&msg).Error; err != nil {
return err return err
} }
tags := ExtractTags(video.Title + " " + video.Description) tags := ExtractTags(video.Title + " " + video.Description)
for _, tagName := range tags { for _, tagName := range tags {
var tag Tag var tag Tag
tx.Where("name = ?", tagName).FirstOrCreate(&tag, Tag{Name: tagName}) tx.Where("name = ?", tagName).FirstOrCreate(&tag, Tag{Name: tagName})
tx.Create(&VideoTag{VideoID: video.ID, TagID: tag.ID}) tx.Create(&VideoTag{VideoID: video.ID, TagID: tag.ID})
} }
return nil return nil
}) })
return err return err
} }
func (vs *VideoService) Delete(ctx context.Context, id uint, authorID uint) error { func (vs *VideoService) Delete(ctx context.Context, id uint, authorID uint) error {
video, err := vs.repo.GetByID(ctx, id) video, err := vs.repo.GetByID(ctx, id)
if err != nil { if err != nil {
return err return err
} }
if video == nil { if video == nil {
return errors.New("video not found") return errors.New("video not found")
} }
if video.AuthorID != authorID { if video.AuthorID != authorID {
return apierror.ErrUnauthorized return apierror.ErrUnauthorized
} }
if err := vs.repo.DeleteVideo(ctx, id); err != nil { if err := vs.repo.DeleteVideo(ctx, id); err != nil {
return err return err
} }
if vs.cache != nil { if vs.cache != nil {
cacheKey := vs.cache.Key("video:detail:id=%d", id) cacheKey := vs.cache.Key("video:detail:id=%d", id)
_ = vs.cache.Del(context.Background(), cacheKey) _ = vs.cache.Del(context.Background(), cacheKey)
} }
return nil return nil
} }
func (vs *VideoService) ListByAuthorID(ctx context.Context, authorID uint) ([]Video, error) { func (vs *VideoService) ListByAuthorID(ctx context.Context, authorID uint) ([]Video, error) {
videos, err := vs.repo.ListByAuthorID(ctx, int64(authorID)) videos, err := vs.repo.ListByAuthorID(ctx, int64(authorID))
if err != nil { if err != nil {
return nil, err return nil, err
} }
return videos, nil return videos, nil
} }
func (vs *VideoService) GetDetail(ctx context.Context, id uint) (*Video, error) { func (vs *VideoService) GetDetail(ctx context.Context, id uint) (*Video, error) {
cacheKey := vs.cache.Key("video:detail:id=%d", id) cacheKey := vs.cache.Key("video:detail:id=%d", id)
getCached := func() (*Video, bool) { getCached := func() (*Video, bool) {
opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
b, err := vs.cache.GetBytes(opCtx, cacheKey) b, err := vs.cache.GetBytes(opCtx, cacheKey)
if err != nil { if err != nil {
return nil, false return nil, false
} }
var cached Video var cached Video
if err := json.Unmarshal(b, &cached); err != nil { if err := json.Unmarshal(b, &cached); err != nil {
return nil, false return nil, false
} }
return &cached, true return &cached, true
} }
setCached := func(video *Video) { setCached := func(video *Video) {
b, err := json.Marshal(video) b, err := json.Marshal(video)
if err != nil { if err != nil {
return return
} }
opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
_ = vs.cache.SetBytes(opCtx, cacheKey, b, vs.cacheTTL) _ = vs.cache.SetBytes(opCtx, cacheKey, b, vs.cacheTTL)
} }
if vs.cache != nil { if vs.cache != nil {
if v, ok := getCached(); ok { if v, ok := getCached(); ok {
return v, nil return v, nil
} }
opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
b, err := vs.cache.GetBytes(opCtx, cacheKey) b, err := vs.cache.GetBytes(opCtx, cacheKey)
cancel() cancel()
if err == nil { if err == nil {
var cached Video var cached Video
if err := json.Unmarshal(b, &cached); err == nil { if err := json.Unmarshal(b, &cached); err == nil {
return &cached, nil return &cached, nil
} }
} else if rediscache.IsMiss(err) { } else if rediscache.IsMiss(err) {
lockKey := "lock:" + cacheKey lockKey := "lock:" + cacheKey
lockCtx, lockCancel := context.WithTimeout(ctx, 50*time.Millisecond) lockCtx, lockCancel := context.WithTimeout(ctx, 50*time.Millisecond)
token, locked, lockErr := vs.cache.Lock(lockCtx, lockKey, 2*time.Second) token, locked, lockErr := vs.cache.Lock(lockCtx, lockKey, 2*time.Second)
lockCancel() lockCancel()
if lockErr == nil && locked { if lockErr == nil && locked {
defer func() { _ = vs.cache.Unlock(context.Background(), lockKey, token) }() defer func() { _ = vs.cache.Unlock(context.Background(), lockKey, token) }()
if v, ok := getCached(); ok { if v, ok := getCached(); ok {
return v, nil return v, nil
} }
video, err := vs.repo.GetByID(ctx, id) video, err := vs.repo.GetByID(ctx, id)
if err != nil { if err != nil {
return nil, err return nil, err
} }
setCached(video) setCached(video)
return video, nil return video, nil
} }
// 没拿到锁:等待别人回填缓存 // 没拿到锁:等待别人回填缓存
for i := 0; i < 5; i++ { for i := 0; i < 5; i++ {
select { select {
case <-ctx.Done(): case <-ctx.Done():
return nil, ctx.Err() return nil, ctx.Err()
case <-time.After(20 * time.Millisecond): case <-time.After(20 * time.Millisecond):
} }
if v, ok := getCached(); ok { if v, ok := getCached(); ok {
return v, nil return v, nil
} }
} }
} }
} }
video, err := vs.repo.GetByID(ctx, id) video, err := vs.repo.GetByID(ctx, id)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if vs.cache != nil { if vs.cache != nil {
setCached(video) setCached(video)
} }
return video, nil return video, nil
} }
func (vs *VideoService) UpdateLikesCount(ctx context.Context, id uint, likesCount int64) error { func (vs *VideoService) UpdateLikesCount(ctx context.Context, id uint, likesCount int64) error {
if err := vs.repo.UpdateLikesCount(ctx, id, likesCount); err != nil { if err := vs.repo.UpdateLikesCount(ctx, id, likesCount); err != nil {
return err return err
} }
return nil return nil
} }
func (vs *VideoService) UpdatePopularity(ctx context.Context, id uint, change int64) error { func (vs *VideoService) UpdatePopularity(ctx context.Context, id uint, change int64) error {
if err := vs.repo.UpdatePopularity(ctx, id, change); err != nil { if err := vs.repo.UpdatePopularity(ctx, id, change); err != nil {
return err return err
} }
if vs.popularityMQ != nil { if vs.popularityMQ != nil {
if err := vs.popularityMQ.Update(ctx, id, change); err == nil { if err := vs.popularityMQ.Update(ctx, id, change); err == nil {
return nil return nil
} }
} }
if vs.cache != nil { if vs.cache != nil {
// 1) 详情缓存:直接失效(最简单靠谱) // 1) 详情缓存:直接失效(最简单靠谱)
_ = vs.cache.Del(context.Background(), vs.cache.Key("video:detail:id=%d", id)) _ = vs.cache.Del(context.Background(), vs.cache.Key("video:detail:id=%d", id))
// 2) 热榜:写到“时间窗ZSET”,不要用 detail key // 2) 热榜:写到“时间窗ZSET”,不要用 detail key
now := time.Now().UTC().Truncate(time.Minute) now := time.Now().UTC().Truncate(time.Minute)
windowKey := vs.cache.Key("hot:video:1m:%s", now.Format("200601021504")) windowKey := vs.cache.Key("hot:video:1m:%s", now.Format("200601021504"))
member := strconv.FormatUint(uint64(id), 10) member := strconv.FormatUint(uint64(id), 10)
opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond) opCtx, cancel := context.WithTimeout(ctx, 50*time.Millisecond)
defer cancel() defer cancel()
_ = vs.cache.ZincrBy(opCtx, windowKey, member, float64(change)) _ = vs.cache.ZincrBy(opCtx, windowKey, member, float64(change))
_ = vs.cache.Expire(opCtx, windowKey, 2*time.Hour) _ = vs.cache.Expire(opCtx, windowKey, 2*time.Hour)
} }
return nil return nil
} }

View File

@@ -1,128 +1,127 @@
package worker package worker
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors" "errors"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"log" "log"
"strings" "strings"
amqp "github.com/rabbitmq/amqp091-go" amqp "github.com/rabbitmq/amqp091-go"
) )
type CommentWorker struct { type CommentWorker struct {
ch *amqp.Channel ch *amqp.Channel
comments *video.CommentRepository comments *video.CommentRepository
videos *video.VideoRepository videos *video.VideoRepository
queue string queue string
} }
func NewCommentWorker(ch *amqp.Channel, comments *video.CommentRepository, videos *video.VideoRepository, queue string) *CommentWorker { func NewCommentWorker(ch *amqp.Channel, comments *video.CommentRepository, videos *video.VideoRepository, queue string) *CommentWorker {
return &CommentWorker{ch: ch, comments: comments, videos: videos, queue: queue} return &CommentWorker{ch: ch, comments: comments, videos: videos, queue: queue}
} }
func (w *CommentWorker) Run(ctx context.Context) error { func (w *CommentWorker) Run(ctx context.Context) error {
if w == nil || w.ch == nil || w.comments == nil || w.videos == nil { if w == nil || w.ch == nil || w.comments == nil || w.videos == nil {
return errors.New("comment worker is not initialized") return errors.New("comment worker is not initialized")
} }
if w.queue == "" { if w.queue == "" {
return errors.New("queue is required") return errors.New("queue is required")
} }
deliveries, err := w.ch.Consume( deliveries, err := w.ch.Consume(
w.queue, w.queue,
"", "",
false, false,
false, false,
false, false,
false, false,
nil, nil,
) )
if err != nil { if err != nil {
return err return err
} }
for { for {
select { select {
case <-ctx.Done(): case <-ctx.Done():
return ctx.Err() return ctx.Err()
case d, ok := <-deliveries: case d, ok := <-deliveries:
if !ok { if !ok {
return errors.New("deliveries channel closed") return errors.New("deliveries channel closed")
} }
w.handleDelivery(ctx, d) w.handleDelivery(ctx, d)
} }
} }
} }
func (w *CommentWorker) handleDelivery(ctx context.Context, d amqp.Delivery) { func (w *CommentWorker) handleDelivery(ctx context.Context, d amqp.Delivery) {
if err := w.process(ctx, d.Body); err != nil { if err := w.process(ctx, d.Body); err != nil {
retryCount := rabbitmq.GetRetryCount(d) retryCount := rabbitmq.GetRetryCount(d)
if retryCount >= rabbitmq.MaxRetryCount { if retryCount >= rabbitmq.MaxRetryCount {
log.Printf("comment worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err) log.Printf("comment worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err)
_ = d.Ack(false) _ = d.Ack(false)
return return
} }
log.Printf("comment worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err) log.Printf("comment worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err)
_ = d.Nack(false, true) _ = d.Nack(false, true)
return return
} }
_ = d.Ack(false) _ = d.Ack(false)
} }
func (w *CommentWorker) process(ctx context.Context, body []byte) error { func (w *CommentWorker) process(ctx context.Context, body []byte) error {
var evt rabbitmq.CommentEvent var evt rabbitmq.CommentEvent
if err := json.Unmarshal(body, &evt); err != nil { if err := json.Unmarshal(body, &evt); err != nil {
return nil return nil
} }
switch evt.Action { switch evt.Action {
case "publish": case "publish":
return w.applyPublish(ctx, &evt) return w.applyPublish(ctx, &evt)
case "delete": case "delete":
return w.applyDelete(ctx, &evt) return w.applyDelete(ctx, &evt)
default: default:
return nil return nil
} }
} }
func (w *CommentWorker) applyPublish(ctx context.Context, evt *rabbitmq.CommentEvent) error { func (w *CommentWorker) applyPublish(ctx context.Context, evt *rabbitmq.CommentEvent) error {
if evt == nil || evt.VideoID == 0 || evt.AuthorID == 0 || strings.TrimSpace(evt.Content) == "" { if evt == nil || evt.VideoID == 0 || evt.AuthorID == 0 || strings.TrimSpace(evt.Content) == "" {
return nil return nil
} }
ok, err := w.videos.IsExist(ctx, evt.VideoID) ok, err := w.videos.IsExist(ctx, evt.VideoID)
if err != nil { if err != nil {
return err return err
} }
if !ok { if !ok {
return nil return nil
} }
c := &video.Comment{ c := &video.Comment{
Username: strings.TrimSpace(evt.Username), Username: strings.TrimSpace(evt.Username),
VideoID: evt.VideoID, VideoID: evt.VideoID,
AuthorID: evt.AuthorID, AuthorID: evt.AuthorID,
Content: strings.TrimSpace(evt.Content), Content: strings.TrimSpace(evt.Content),
} }
if err := w.comments.CreateComment(ctx, c); err != nil { if err := w.comments.CreateComment(ctx, c); err != nil {
return err return err
} }
return w.videos.ChangePopularity(ctx, evt.VideoID, 1) return w.videos.ChangePopularity(ctx, evt.VideoID, 1)
} }
func (w *CommentWorker) applyDelete(ctx context.Context, evt *rabbitmq.CommentEvent) error { func (w *CommentWorker) applyDelete(ctx context.Context, evt *rabbitmq.CommentEvent) error {
if evt == nil || evt.CommentID == 0 { if evt == nil || evt.CommentID == 0 {
return nil return nil
} }
c, err := w.comments.GetByID(ctx, evt.CommentID) c, err := w.comments.GetByID(ctx, evt.CommentID)
if err != nil { if err != nil {
return err return err
} }
if c == nil { if c == nil {
return nil return nil
} }
return w.comments.DeleteComment(ctx, c) return w.comments.DeleteComment(ctx, c)
} }

View File

@@ -1,142 +1,142 @@
package worker package worker
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors" "errors"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"log" amqp "github.com/rabbitmq/amqp091-go"
amqp "github.com/rabbitmq/amqp091-go" "log"
"time" "time"
) )
type LikeWorker struct { type LikeWorker struct {
ch *amqp.Channel ch *amqp.Channel
likes *video.LikeRepository likes *video.LikeRepository
videos *video.VideoRepository videos *video.VideoRepository
queue string queue string
} }
func NewLikeWorker(ch *amqp.Channel, likes *video.LikeRepository, videos *video.VideoRepository, queue string) *LikeWorker { func NewLikeWorker(ch *amqp.Channel, likes *video.LikeRepository, videos *video.VideoRepository, queue string) *LikeWorker {
return &LikeWorker{ch: ch, likes: likes, videos: videos, queue: queue} return &LikeWorker{ch: ch, likes: likes, videos: videos, queue: queue}
} }
func (w *LikeWorker) Run(ctx context.Context) error { func (w *LikeWorker) Run(ctx context.Context) error {
if w == nil || w.ch == nil || w.likes == nil || w.videos == nil { if w == nil || w.ch == nil || w.likes == nil || w.videos == nil {
return errors.New("like worker is not initialized") return errors.New("like worker is not initialized")
} }
if w.queue == "" { if w.queue == "" {
return errors.New("queue is required") return errors.New("queue is required")
} }
deliveries, err := w.ch.Consume( deliveries, err := w.ch.Consume(
w.queue, w.queue,
"", "",
false, false,
false, false,
false, false,
false, false,
nil, nil,
) )
if err != nil { if err != nil {
return err return err
} }
for { for {
select { select {
case <-ctx.Done(): case <-ctx.Done():
return ctx.Err() return ctx.Err()
case d, ok := <-deliveries: case d, ok := <-deliveries:
if !ok { if !ok {
return errors.New("deliveries channel closed") return errors.New("deliveries channel closed")
} }
w.handleDelivery(ctx, d) w.handleDelivery(ctx, d)
} }
} }
} }
func (w *LikeWorker) handleDelivery(ctx context.Context, d amqp.Delivery) { func (w *LikeWorker) handleDelivery(ctx context.Context, d amqp.Delivery) {
if err := w.process(ctx, d.Body); err != nil { if err := w.process(ctx, d.Body); err != nil {
retryCount := rabbitmq.GetRetryCount(d) retryCount := rabbitmq.GetRetryCount(d)
if retryCount >= rabbitmq.MaxRetryCount { if retryCount >= rabbitmq.MaxRetryCount {
log.Printf("like worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err) log.Printf("like worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err)
_ = d.Ack(false) _ = d.Ack(false)
return return
} }
log.Printf("like worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err) log.Printf("like worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err)
_ = d.Nack(false, true) _ = d.Nack(false, true)
return return
} }
_ = d.Ack(false) _ = d.Ack(false)
} }
func (w *LikeWorker) process(ctx context.Context, body []byte) error { func (w *LikeWorker) process(ctx context.Context, body []byte) error {
var evt rabbitmq.LikeEvent var evt rabbitmq.LikeEvent
if err := json.Unmarshal(body, &evt); err != nil { if err := json.Unmarshal(body, &evt); err != nil {
// 解析事件失败,直接丢弃 // 解析事件失败,直接丢弃
return nil return nil
} }
if evt.UserID == 0 || evt.VideoID == 0 { if evt.UserID == 0 || evt.VideoID == 0 {
return nil return nil
} }
switch evt.Action { switch evt.Action {
case "like": case "like":
return w.applyLike(ctx, evt.UserID, evt.VideoID) return w.applyLike(ctx, evt.UserID, evt.VideoID)
case "unlike": case "unlike":
return w.applyUnlike(ctx, evt.UserID, evt.VideoID) return w.applyUnlike(ctx, evt.UserID, evt.VideoID)
default: default:
return nil return nil
} }
} }
func (w *LikeWorker) applyLike(ctx context.Context, userID, videoID uint) error { func (w *LikeWorker) applyLike(ctx context.Context, userID, videoID uint) error {
ok, err := w.videos.IsExist(ctx, videoID) ok, err := w.videos.IsExist(ctx, videoID)
if err != nil { if err != nil {
return err return err
} }
if !ok { if !ok {
return nil return nil
} }
created, err := w.likes.LikeIgnoreDuplicate(ctx, &video.Like{ created, err := w.likes.LikeIgnoreDuplicate(ctx, &video.Like{
VideoID: videoID, VideoID: videoID,
AccountID: userID, AccountID: userID,
CreatedAt: time.Now(), CreatedAt: time.Now(),
}) })
if err != nil { if err != nil {
return err return err
} }
if !created { if !created {
return nil return nil
} }
if err := w.videos.ChangeLikesCount(ctx, videoID, 1); err != nil { if err := w.videos.ChangeLikesCount(ctx, videoID, 1); err != nil {
return err return err
} }
return w.videos.ChangePopularity(ctx, videoID, 1) return w.videos.ChangePopularity(ctx, videoID, 1)
} }
func (w *LikeWorker) applyUnlike(ctx context.Context, userID, videoID uint) error { func (w *LikeWorker) applyUnlike(ctx context.Context, userID, videoID uint) error {
ok, err := w.videos.IsExist(ctx, videoID) ok, err := w.videos.IsExist(ctx, videoID)
if err != nil { if err != nil {
return err return err
} }
if !ok { if !ok {
return nil return nil
} }
deleted, err := w.likes.DeleteByVideoAndAccount(ctx, videoID, userID) deleted, err := w.likes.DeleteByVideoAndAccount(ctx, videoID, userID)
if err != nil { if err != nil {
return err return err
} }
if !deleted { if !deleted {
return nil return nil
} }
if err := w.videos.ChangeLikesCount(ctx, videoID, -1); err != nil { if err := w.videos.ChangeLikesCount(ctx, videoID, -1); err != nil {
return err return err
} }
return w.videos.ChangePopularity(ctx, videoID, -1) return w.videos.ChangePopularity(ctx, videoID, -1)
} }

View File

@@ -13,21 +13,21 @@ import (
) )
type Notification struct { type Notification struct {
ID uint `gorm:"primaryKey" json:"id"` ID uint `gorm:"primaryKey" json:"id"`
RecipientID uint `gorm:"index;not null" json:"recipient_id"` RecipientID uint `gorm:"index;not null" json:"recipient_id"`
SenderID uint `gorm:"not null" json:"sender_id"` SenderID uint `gorm:"not null" json:"sender_id"`
Type string `gorm:"type:varchar(50);not null" json:"type"` Type string `gorm:"type:varchar(50);not null" json:"type"`
TargetID uint `json:"target_id"` TargetID uint `json:"target_id"`
Content string `gorm:"type:varchar(255)" json:"content"` Content string `gorm:"type:varchar(255)" json:"content"`
IsRead bool `gorm:"default:false" json:"is_read"` IsRead bool `gorm:"default:false" json:"is_read"`
CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"` CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"`
} }
type NotificationWorker struct { type NotificationWorker struct {
ch *amqp.Channel ch *amqp.Channel
db *gorm.DB db *gorm.DB
queue string queue string
hub NotificationHub hub NotificationHub
} }
type NotificationHub interface { type NotificationHub interface {
@@ -96,7 +96,10 @@ func (w *NotificationWorker) process(ctx context.Context, d amqp.Delivery) error
return nil return nil
} }
var authorID uint var authorID uint
w.db.WithContext(ctx).Model(&struct{ ID uint; AuthorID uint }{}).Table("videos").Where("id = ?", evt.VideoID).Select("author_id").Scan(&authorID) w.db.WithContext(ctx).Model(&struct {
ID uint
AuthorID uint
}{}).Table("videos").Where("id = ?", evt.VideoID).Select("author_id").Scan(&authorID)
if authorID == 0 || authorID == evt.UserID { if authorID == 0 || authorID == evt.UserID {
return nil return nil
} }
@@ -111,7 +114,10 @@ func (w *NotificationWorker) process(ctx context.Context, d amqp.Delivery) error
return nil return nil
} }
var authorID uint var authorID uint
w.db.WithContext(ctx).Model(&struct{ ID uint; AuthorID uint }{}).Table("videos").Where("id = ?", evt.VideoID).Select("author_id").Scan(&authorID) w.db.WithContext(ctx).Model(&struct {
ID uint
AuthorID uint
}{}).Table("videos").Where("id = ?", evt.VideoID).Select("author_id").Scan(&authorID)
if authorID == 0 || authorID == evt.AuthorID { if authorID == 0 || authorID == evt.AuthorID {
return nil return nil
} }

View File

@@ -1,85 +1,84 @@
package worker package worker
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors" "errors"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/rabbitmq"
rediscache "feedsystem_video_go/internal/middleware/redis" rediscache "feedsystem_video_go/internal/middleware/redis"
"feedsystem_video_go/internal/video" "feedsystem_video_go/internal/video"
"log" "log"
amqp "github.com/rabbitmq/amqp091-go" amqp "github.com/rabbitmq/amqp091-go"
) )
type PopularityWorker struct { type PopularityWorker struct {
ch *amqp.Channel ch *amqp.Channel
cache *rediscache.Client cache *rediscache.Client
queue string queue string
} }
func NewPopularityWorker(ch *amqp.Channel, cache *rediscache.Client, queue string) *PopularityWorker { func NewPopularityWorker(ch *amqp.Channel, cache *rediscache.Client, queue string) *PopularityWorker {
return &PopularityWorker{ch: ch, cache: cache, queue: queue} return &PopularityWorker{ch: ch, cache: cache, queue: queue}
} }
func (w *PopularityWorker) Run(ctx context.Context) error { func (w *PopularityWorker) Run(ctx context.Context) error {
if w == nil || w.ch == nil || w.cache == nil { if w == nil || w.ch == nil || w.cache == nil {
return errors.New("popularity worker is not initialized") return errors.New("popularity worker is not initialized")
} }
if w.queue == "" { if w.queue == "" {
return errors.New("queue is required") return errors.New("queue is required")
} }
deliveries, err := w.ch.Consume( deliveries, err := w.ch.Consume(
w.queue, w.queue,
"", "",
false, false,
false, false,
false, false,
false, false,
nil, nil,
) )
if err != nil { if err != nil {
return err return err
} }
for { for {
select { select {
case <-ctx.Done(): case <-ctx.Done():
return ctx.Err() return ctx.Err()
case d, ok := <-deliveries: case d, ok := <-deliveries:
if !ok { if !ok {
return errors.New("deliveries channel closed") return errors.New("deliveries channel closed")
} }
w.handleDelivery(ctx, d) w.handleDelivery(ctx, d)
} }
} }
} }
func (w *PopularityWorker) handleDelivery(ctx context.Context, d amqp.Delivery) { func (w *PopularityWorker) handleDelivery(ctx context.Context, d amqp.Delivery) {
if err := w.process(ctx, d.Body); err != nil { if err := w.process(ctx, d.Body); err != nil {
retryCount := rabbitmq.GetRetryCount(d) retryCount := rabbitmq.GetRetryCount(d)
if retryCount >= rabbitmq.MaxRetryCount { if retryCount >= rabbitmq.MaxRetryCount {
log.Printf("popularity worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err) log.Printf("popularity worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err)
_ = d.Ack(false) _ = d.Ack(false)
return return
} }
log.Printf("popularity worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err) log.Printf("popularity worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err)
_ = d.Nack(false, true) _ = d.Nack(false, true)
return return
} }
_ = d.Ack(false) _ = d.Ack(false)
} }
func (w *PopularityWorker) process(ctx context.Context, body []byte) error { func (w *PopularityWorker) process(ctx context.Context, body []byte) error {
var evt rabbitmq.PopularityEvent var evt rabbitmq.PopularityEvent
if err := json.Unmarshal(body, &evt); err != nil { if err := json.Unmarshal(body, &evt); err != nil {
return nil return nil
} }
if evt.VideoID == 0 || evt.Change == 0 { if evt.VideoID == 0 || evt.Change == 0 {
return nil return nil
} }
video.UpdatePopularityCache(ctx, w.cache, evt.VideoID, evt.Change) video.UpdatePopularityCache(ctx, w.cache, evt.VideoID, evt.Change)
return nil return nil
} }

View File

@@ -1,106 +1,106 @@
package worker package worker
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"errors" "errors"
"feedsystem_video_go/internal/middleware/rabbitmq" "feedsystem_video_go/internal/middleware/rabbitmq"
"feedsystem_video_go/internal/social" "feedsystem_video_go/internal/social"
"log" "log"
"github.com/go-sql-driver/mysql" "github.com/go-sql-driver/mysql"
amqp "github.com/rabbitmq/amqp091-go" amqp "github.com/rabbitmq/amqp091-go"
) )
type SocialWorker struct { type SocialWorker struct {
ch *amqp.Channel ch *amqp.Channel
repo *social.SocialRepository repo *social.SocialRepository
queue string queue string
} }
func NewSocialWorker(ch *amqp.Channel, repo *social.SocialRepository, queue string) *SocialWorker { func NewSocialWorker(ch *amqp.Channel, repo *social.SocialRepository, queue string) *SocialWorker {
return &SocialWorker{ch: ch, repo: repo, queue: queue} return &SocialWorker{ch: ch, repo: repo, queue: queue}
} }
func (w *SocialWorker) Run(ctx context.Context) error { func (w *SocialWorker) Run(ctx context.Context) error {
if w == nil || w.ch == nil || w.repo == nil { if w == nil || w.ch == nil || w.repo == nil {
return errors.New("social worker is not initialized") return errors.New("social worker is not initialized")
} }
if w.queue == "" { if w.queue == "" {
return errors.New("queue is required") return errors.New("queue is required")
} }
deliveries, err := w.ch.Consume( deliveries, err := w.ch.Consume(
w.queue, w.queue,
"", "",
false, false,
false, false,
false, false,
false, false,
nil, nil,
) )
if err != nil { if err != nil {
return err return err
} }
for { for {
select { select {
case <-ctx.Done(): case <-ctx.Done():
return ctx.Err() return ctx.Err()
case d, ok := <-deliveries: case d, ok := <-deliveries:
if !ok { if !ok {
return errors.New("deliveries channel closed") return errors.New("deliveries channel closed")
} }
w.handleDelivery(ctx, d) w.handleDelivery(ctx, d)
} }
} }
} }
func (w *SocialWorker) handleDelivery(ctx context.Context, d amqp.Delivery) { func (w *SocialWorker) handleDelivery(ctx context.Context, d amqp.Delivery) {
if err := w.process(ctx, d.Body); err != nil { if err := w.process(ctx, d.Body); err != nil {
retryCount := rabbitmq.GetRetryCount(d) retryCount := rabbitmq.GetRetryCount(d)
if retryCount >= rabbitmq.MaxRetryCount { if retryCount >= rabbitmq.MaxRetryCount {
log.Printf("social worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err) log.Printf("social worker: max retries exceeded (%d), moving to DLX: %v", retryCount, err)
_ = d.Ack(false) _ = d.Ack(false)
return return
} }
log.Printf("social worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err) log.Printf("social worker: failed (retry %d/%d): %v", retryCount+1, rabbitmq.MaxRetryCount, err)
_ = d.Nack(false, true) _ = d.Nack(false, true)
return return
} }
_ = d.Ack(false) _ = d.Ack(false)
} }
func (w *SocialWorker) process(ctx context.Context, body []byte) error { func (w *SocialWorker) process(ctx context.Context, body []byte) error {
var evt rabbitmq.SocialEvent var evt rabbitmq.SocialEvent
if err := json.Unmarshal(body, &evt); err != nil { if err := json.Unmarshal(body, &evt); err != nil {
// 解析事件失败,直接丢弃 // 解析事件失败,直接丢弃
return nil return nil
} }
if evt.FollowerID == 0 || evt.VloggerID == 0 { if evt.FollowerID == 0 || evt.VloggerID == 0 {
return nil return nil
} }
switch evt.Action { switch evt.Action {
case "follow": case "follow":
err := w.repo.Follow(ctx, &social.Social{ err := w.repo.Follow(ctx, &social.Social{
FollowerID: evt.FollowerID, FollowerID: evt.FollowerID,
VloggerID: evt.VloggerID, VloggerID: evt.VloggerID,
}) })
if err == nil { if err == nil {
return nil return nil
} }
var mysqlErr *mysql.MySQLError var mysqlErr *mysql.MySQLError
if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 { if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
return nil return nil
} }
return err return err
case "unfollow": case "unfollow":
return w.repo.Unfollow(ctx, &social.Social{ return w.repo.Unfollow(ctx, &social.Social{
FollowerID: evt.FollowerID, FollowerID: evt.FollowerID,
VloggerID: evt.VloggerID, VloggerID: evt.VloggerID,
}) })
default: default:
return nil return nil
} }
} }

View File

@@ -14,9 +14,9 @@ import (
) )
type SSEHub struct { type SSEHub struct {
mu sync.RWMutex mu sync.RWMutex
clients map[uint][]chan *Notification clients map[uint][]chan *Notification
db *gorm.DB db *gorm.DB
} }
func NewSSEHub(db *gorm.DB) *SSEHub { func NewSSEHub(db *gorm.DB) *SSEHub {

View File

@@ -1,64 +1,64 @@
services: services:
mysql: mysql:
image: mysql:8.0 image: mysql:8.0
restart: always restart: always
environment: environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-123456} MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-123456}
MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem} MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem}
TZ: "Asia/Shanghai" TZ: "Asia/Shanghai"
ports: ports:
- "3307:3306" - "3307:3306"
volumes: volumes:
- mysql_data:/var/lib/mysql - mysql_data:/var/lib/mysql
command: command:
- --default-authentication-plugin=mysql_native_password - --default-authentication-plugin=mysql_native_password
- --character-set-server=utf8mb4 - --character-set-server=utf8mb4
- --collation-server=utf8mb4_0900_ai_ci - --collation-server=utf8mb4_0900_ai_ci
healthcheck: healthcheck:
test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -uroot -p$${MYSQL_ROOT_PASSWORD} --silent"] test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -uroot -p$${MYSQL_ROOT_PASSWORD} --silent"]
interval: 5s interval: 5s
timeout: 5s timeout: 5s
retries: 20 retries: 20
redis: redis:
image: redis:7-alpine image: redis:7-alpine
restart: always restart: always
environment: environment:
REDIS_PASSWORD: ${REDIS_PASSWORD:-123456} REDIS_PASSWORD: ${REDIS_PASSWORD:-123456}
command: ["redis-server", "--appendonly", "yes", "--requirepass", "${REDIS_PASSWORD:-123456}"] command: ["redis-server", "--appendonly", "yes", "--requirepass", "${REDIS_PASSWORD:-123456}"]
ports: ports:
- "6379:6379" - "6379:6379"
volumes: volumes:
- redis_data:/data - redis_data:/data
healthcheck: healthcheck:
test: ["CMD-SHELL", "redis-cli -a \"$${REDIS_PASSWORD}\" ping"] test: ["CMD-SHELL", "redis-cli -a \"$${REDIS_PASSWORD}\" ping"]
interval: 5s interval: 5s
timeout: 3s timeout: 3s
retries: 20 retries: 20
rabbitmq: rabbitmq:
image: rabbitmq:3-management image: rabbitmq:3-management
restart: always restart: always
ports: ports:
- "5672:5672" - "5672:5672"
- "15672:15672" - "15672:15672"
environment: environment:
RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-admin} RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-admin}
RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS:-password123} RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS:-password123}
volumes: volumes:
- rabbitmq_data:/var/lib/rabbitmq - rabbitmq_data:/var/lib/rabbitmq
healthcheck: healthcheck:
test: ["CMD-SHELL", "rabbitmq-diagnostics -q ping"] test: ["CMD-SHELL", "rabbitmq-diagnostics -q ping"]
interval: 5s interval: 5s
timeout: 5s timeout: 5s
retries: 20 retries: 20
backend: backend:
build: build:
context: . context: .
dockerfile: backend/Dockerfile dockerfile: backend/Dockerfile
target: api target: api
restart: always restart: always
environment: environment:
JWT_SECRET: ${JWT_SECRET:-feedsystem-dev-secret-key} JWT_SECRET: ${JWT_SECRET:-feedsystem-dev-secret-key}
MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem} MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem}
@@ -66,30 +66,30 @@ services:
REDIS_PASSWORD: ${REDIS_PASSWORD:-123456} REDIS_PASSWORD: ${REDIS_PASSWORD:-123456}
RABBITMQ_USER: ${RABBITMQ_USER:-admin} RABBITMQ_USER: ${RABBITMQ_USER:-admin}
RABBITMQ_PASS: ${RABBITMQ_PASS:-password123} RABBITMQ_PASS: ${RABBITMQ_PASS:-password123}
ports: ports:
- "8080:8080" - "8080:8080"
volumes: volumes:
- ./backend/configs/config.docker.yaml:/app/configs/config.yaml:ro - ./backend/configs/config.docker.yaml:/app/configs/config.yaml:ro
- backend_uploads:/app/.run/uploads - backend_uploads:/app/.run/uploads
depends_on: depends_on:
mysql: mysql:
condition: service_healthy condition: service_healthy
redis: redis:
condition: service_healthy condition: service_healthy
rabbitmq: rabbitmq:
condition: service_healthy condition: service_healthy
healthcheck: healthcheck:
test: ["CMD-SHELL", "pgrep api || exit 1"] test: ["CMD-SHELL", "pgrep api || exit 1"]
interval: 10s interval: 10s
timeout: 5s timeout: 5s
retries: 3 retries: 3
worker: worker:
build: build:
context: . context: .
dockerfile: backend/Dockerfile dockerfile: backend/Dockerfile
target: worker target: worker
restart: always restart: always
environment: environment:
JWT_SECRET: ${JWT_SECRET:-feedsystem-dev-secret-key} JWT_SECRET: ${JWT_SECRET:-feedsystem-dev-secret-key}
MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem} MYSQL_DATABASE: ${MYSQL_DATABASE:-feedsystem}
@@ -97,39 +97,39 @@ services:
REDIS_PASSWORD: ${REDIS_PASSWORD:-123456} REDIS_PASSWORD: ${REDIS_PASSWORD:-123456}
RABBITMQ_USER: ${RABBITMQ_USER:-admin} RABBITMQ_USER: ${RABBITMQ_USER:-admin}
RABBITMQ_PASS: ${RABBITMQ_PASS:-password123} RABBITMQ_PASS: ${RABBITMQ_PASS:-password123}
volumes: volumes:
- ./backend/configs/config.docker.yaml:/app/configs/config.yaml:ro - ./backend/configs/config.docker.yaml:/app/configs/config.yaml:ro
depends_on: depends_on:
mysql: mysql:
condition: service_healthy condition: service_healthy
redis: redis:
condition: service_healthy condition: service_healthy
rabbitmq: rabbitmq:
condition: service_healthy condition: service_healthy
healthcheck: healthcheck:
test: ["CMD-SHELL", "pgrep worker || exit 1"] test: ["CMD-SHELL", "pgrep worker || exit 1"]
interval: 15s interval: 15s
timeout: 5s timeout: 5s
retries: 3 retries: 3
frontend: frontend:
build: build:
context: . context: .
dockerfile: frontend/Dockerfile dockerfile: frontend/Dockerfile
restart: always restart: always
ports: ports:
- "5173:80" - "5173:80"
depends_on: depends_on:
- backend - backend
healthcheck: healthcheck:
test: ["CMD-SHELL", "wget -qO- http://localhost:80/ || exit 1"] test: ["CMD-SHELL", "wget -qO- http://localhost:80/ || exit 1"]
interval: 10s interval: 10s
timeout: 5s timeout: 5s
retries: 3 retries: 3
volumes: volumes:
mysql_data: mysql_data:
redis_data: redis_data:
rabbitmq_data: rabbitmq_data:
backend_uploads: backend_uploads:

View File

@@ -1,3 +1,3 @@
<template> <template>
<RouterView /> <RouterView />
</template> </template>

View File

@@ -1,48 +1,48 @@
import { postForm, postJson } from './client' import { postForm, postJson } from './client'
import type { Account, MessageResponse, TokenResponse } from './types' import type { Account, MessageResponse, TokenResponse } from './types'
export function register(username: string, password: string) { export function register(username: string, password: string) {
return postJson<MessageResponse>('/account/register', { username, password }) return postJson<MessageResponse>('/account/register', { username, password })
} }
export function login(username: string, password: string) { export function login(username: string, password: string) {
return postJson<TokenResponse>('/account/login', { username, password }) return postJson<TokenResponse>('/account/login', { username, password })
} }
export function logout() { export function logout() {
return postJson<MessageResponse>('/account/logout', {}, { authRequired: true }) return postJson<MessageResponse>('/account/logout', {}, { authRequired: true })
} }
export function rename(newUsername: string) { export function rename(newUsername: string) {
return postJson<TokenResponse>('/account/rename', { new_username: newUsername }, { authRequired: true }) return postJson<TokenResponse>('/account/rename', { new_username: newUsername }, { authRequired: true })
} }
export function changePassword(username: string, oldPassword: string, newPassword: string) { export function changePassword(username: string, oldPassword: string, newPassword: string) {
return postJson<MessageResponse>('/account/changePassword', { return postJson<MessageResponse>('/account/changePassword', {
username, username,
old_password: oldPassword, old_password: oldPassword,
new_password: newPassword, new_password: newPassword,
}) })
} }
export function findById(id: number) { export function findById(id: number) {
return postJson<Account>('/account/findByID', { id }) return postJson<Account>('/account/findByID', { id })
} }
export function findByUsername(username: string) { export function findByUsername(username: string) {
return postJson<Account>('/account/findByUsername', { username }) return postJson<Account>('/account/findByUsername', { username })
} }
export function uploadAvatar(file: File) { export function uploadAvatar(file: File) {
const fd = new FormData() const fd = new FormData()
fd.append('file', file) fd.append('file', file)
return postForm<{ avatar_url: string }>('/account/uploadAvatar', fd, { authRequired: true }) return postForm<{ avatar_url: string }>('/account/uploadAvatar', fd, { authRequired: true })
} }
export function updateProfile(data: { avatar_url?: string; bio?: string }) { export function updateProfile(data: { avatar_url?: string; bio?: string }) {
return postJson<MessageResponse>('/account/updateProfile', data, { authRequired: true }) return postJson<MessageResponse>('/account/updateProfile', data, { authRequired: true })
} }
export function refresh(refreshToken: string) { export function refresh(refreshToken: string) {
return postJson<TokenResponse>('/account/refresh', { refresh_token: refreshToken }) return postJson<TokenResponse>('/account/refresh', { refresh_token: refreshToken })
} }

View File

@@ -1,16 +1,16 @@
import { postJson } from './client' import { postJson } from './client'
import { normalizeCommentList } from './normalize' import { normalizeCommentList } from './normalize'
import type { Comment, MessageResponse } from './types' import type { Comment, MessageResponse } from './types'
export async function listAll(videoId: number) { export async function listAll(videoId: number) {
const comments = await postJson<Comment[] | null>('/comment/listAll', { video_id: videoId }) const comments = await postJson<Comment[] | null>('/comment/listAll', { video_id: videoId })
return normalizeCommentList(comments) return normalizeCommentList(comments)
} }
export function publish(videoId: number, content: string) { export function publish(videoId: number, content: string) {
return postJson<MessageResponse>('/comment/publish', { video_id: videoId, content }, { authRequired: true }) return postJson<MessageResponse>('/comment/publish', { video_id: videoId, content }, { authRequired: true })
} }
export function remove(commentId: number) { export function remove(commentId: number) {
return postJson<MessageResponse>('/comment/delete', { comment_id: commentId }, { authRequired: true }) return postJson<MessageResponse>('/comment/delete', { comment_id: commentId }, { authRequired: true })
} }

View File

@@ -1,28 +1,28 @@
import { postJson } from './client' import { postJson } from './client'
import { normalizeFeedVideoList } from './normalize' import { normalizeFeedVideoList } from './normalize'
import type { ListByFollowingResponse, ListByPopularityResponse, ListLatestResponse, ListLikesCountResponse } from './types' import type { ListByFollowingResponse, ListByPopularityResponse, ListLatestResponse, ListLikesCountResponse } from './types'
export async function listLatest(input: { limit: number; latest_time: number }) { export async function listLatest(input: { limit: number; latest_time: number }) {
const res = await postJson<ListLatestResponse>('/feed/listLatest', input) const res = await postJson<ListLatestResponse>('/feed/listLatest', input)
return { ...res, video_list: normalizeFeedVideoList(res.video_list) } return { ...res, video_list: normalizeFeedVideoList(res.video_list) }
} }
export async function listLikesCount(input: { limit: number; likes_count_before?: number; id_before?: number }) { export async function listLikesCount(input: { limit: number; likes_count_before?: number; id_before?: number }) {
const body: Record<string, unknown> = { limit: input.limit } const body: Record<string, unknown> = { limit: input.limit }
if (typeof input.likes_count_before === 'number' || typeof input.id_before === 'number') { if (typeof input.likes_count_before === 'number' || typeof input.id_before === 'number') {
body.likes_count_before = input.likes_count_before ?? 0 body.likes_count_before = input.likes_count_before ?? 0
body.id_before = input.id_before ?? 0 body.id_before = input.id_before ?? 0
} }
const res = await postJson<ListLikesCountResponse>('/feed/listLikesCount', body) const res = await postJson<ListLikesCountResponse>('/feed/listLikesCount', body)
return { ...res, video_list: normalizeFeedVideoList(res.video_list) } return { ...res, video_list: normalizeFeedVideoList(res.video_list) }
} }
export async function listByPopularity(input: { limit: number; as_of: number; offset: number }) { export async function listByPopularity(input: { limit: number; as_of: number; offset: number }) {
const res = await postJson<ListByPopularityResponse>('/feed/listByPopularity', input) const res = await postJson<ListByPopularityResponse>('/feed/listByPopularity', input)
return { ...res, video_list: normalizeFeedVideoList(res.video_list) } return { ...res, video_list: normalizeFeedVideoList(res.video_list) }
} }
export async function listByFollowing(input: { limit: number; latest_time: number }) { export async function listByFollowing(input: { limit: number; latest_time: number }) {
const res = await postJson<ListByFollowingResponse>('/feed/listByFollowing', input, { authRequired: true }) const res = await postJson<ListByFollowingResponse>('/feed/listByFollowing', input, { authRequired: true })
return { ...res, video_list: normalizeFeedVideoList(res.video_list) } return { ...res, video_list: normalizeFeedVideoList(res.video_list) }
} }

View File

@@ -1,18 +1,18 @@
import { postJson } from './client' import { postJson } from './client'
import type { IsLikedResponse, MessageResponse, Video } from './types' import type { IsLikedResponse, MessageResponse, Video } from './types'
export function like(videoId: number) { export function like(videoId: number) {
return postJson<MessageResponse>('/like/like', { video_id: videoId }, { authRequired: true }) return postJson<MessageResponse>('/like/like', { video_id: videoId }, { authRequired: true })
} }
export function unlike(videoId: number) { export function unlike(videoId: number) {
return postJson<MessageResponse>('/like/unlike', { video_id: videoId }, { authRequired: true }) return postJson<MessageResponse>('/like/unlike', { video_id: videoId }, { authRequired: true })
} }
export function isLiked(videoId: number) { export function isLiked(videoId: number) {
return postJson<IsLikedResponse>('/like/isLiked', { video_id: videoId }, { authRequired: true }) return postJson<IsLikedResponse>('/like/isLiked', { video_id: videoId }, { authRequired: true })
} }
export function listMyLikedVideos() { export function listMyLikedVideos() {
return postJson<Video[]>('/like/listMyLikedVideos', {}, { authRequired: true }) return postJson<Video[]>('/like/listMyLikedVideos', {}, { authRequired: true })
} }

View File

@@ -1,57 +1,57 @@
import type { Account, Comment, FeedAuthor, FeedVideoItem, Video } from './types' import type { Account, Comment, FeedAuthor, FeedVideoItem, Video } from './types'
export function listOrEmpty<T>(value: T[] | null | undefined): T[] { export function listOrEmpty<T>(value: T[] | null | undefined): T[] {
return Array.isArray(value) ? value : [] return Array.isArray(value) ? value : []
} }
export function normalizeAccount(value: Account | null | undefined): Account { export function normalizeAccount(value: Account | null | undefined): Account {
return { return {
id: Number(value?.id ?? 0), id: Number(value?.id ?? 0),
username: value?.username || '匿名用户', username: value?.username || '匿名用户',
} }
} }
function normalizeAuthor(value: FeedAuthor | null | undefined): FeedAuthor { function normalizeAuthor(value: FeedAuthor | null | undefined): FeedAuthor {
return { return {
id: Number(value?.id ?? 0), id: Number(value?.id ?? 0),
username: value?.username || '匿名用户', username: value?.username || '匿名用户',
} }
} }
export function normalizeFeedVideoItem(value: FeedVideoItem): FeedVideoItem { export function normalizeFeedVideoItem(value: FeedVideoItem): FeedVideoItem {
return { return {
...value, ...value,
author: normalizeAuthor(value.author), author: normalizeAuthor(value.author),
title: value.title || '未命名视频', title: value.title || '未命名视频',
description: value.description || '', description: value.description || '',
play_url: value.play_url || '', play_url: value.play_url || '',
cover_url: value.cover_url || '', cover_url: value.cover_url || '',
create_time: Number(value.create_time ?? 0), create_time: Number(value.create_time ?? 0),
likes_count: Number(value.likes_count ?? 0), likes_count: Number(value.likes_count ?? 0),
is_liked: Boolean(value.is_liked), is_liked: Boolean(value.is_liked),
} }
} }
export function normalizeFeedVideoList(value: FeedVideoItem[] | null | undefined): FeedVideoItem[] { export function normalizeFeedVideoList(value: FeedVideoItem[] | null | undefined): FeedVideoItem[] {
return listOrEmpty(value).map(normalizeFeedVideoItem) return listOrEmpty(value).map(normalizeFeedVideoItem)
} }
export function normalizeVideoList(value: Video[] | null | undefined): Video[] { export function normalizeVideoList(value: Video[] | null | undefined): Video[] {
return listOrEmpty(value).map((video) => ({ return listOrEmpty(value).map((video) => ({
...video, ...video,
username: video.username || '匿名用户', username: video.username || '匿名用户',
title: video.title || '未命名视频', title: video.title || '未命名视频',
description: video.description || '', description: video.description || '',
play_url: video.play_url || '', play_url: video.play_url || '',
cover_url: video.cover_url || '', cover_url: video.cover_url || '',
likes_count: Number(video.likes_count ?? 0), likes_count: Number(video.likes_count ?? 0),
})) }))
} }
export function normalizeCommentList(value: Comment[] | null | undefined): Comment[] { export function normalizeCommentList(value: Comment[] | null | undefined): Comment[] {
return listOrEmpty(value).map((comment) => ({ return listOrEmpty(value).map((comment) => ({
...comment, ...comment,
username: comment.username || '匿名用户', username: comment.username || '匿名用户',
content: comment.content || '', content: comment.content || '',
})) }))
} }

View File

@@ -1,29 +1,29 @@
import { postJson } from './client' import { postJson } from './client'
import { listOrEmpty, normalizeAccount } from './normalize' import { listOrEmpty, normalizeAccount } from './normalize'
import type { GetAllFollowersResponse, GetAllVloggersResponse, MessageResponse } from './types' import type { GetAllFollowersResponse, GetAllVloggersResponse, MessageResponse } from './types'
export function follow(vloggerId: number) { export function follow(vloggerId: number) {
return postJson<MessageResponse>('/social/follow', { vlogger_id: vloggerId }, { authRequired: true }) return postJson<MessageResponse>('/social/follow', { vlogger_id: vloggerId }, { authRequired: true })
} }
export function unfollow(vloggerId: number) { export function unfollow(vloggerId: number) {
return postJson<MessageResponse>('/social/unfollow', { vlogger_id: vloggerId }, { authRequired: true }) return postJson<MessageResponse>('/social/unfollow', { vlogger_id: vloggerId }, { authRequired: true })
} }
export async function getAllFollowers(vloggerId?: number) { export async function getAllFollowers(vloggerId?: number) {
const res = await postJson<GetAllFollowersResponse>( const res = await postJson<GetAllFollowersResponse>(
'/social/getAllFollowers', '/social/getAllFollowers',
vloggerId ? { vlogger_id: vloggerId } : {}, vloggerId ? { vlogger_id: vloggerId } : {},
{ authRequired: true }, { authRequired: true },
) )
return { ...res, followers: listOrEmpty(res.followers).map(normalizeAccount) } return { ...res, followers: listOrEmpty(res.followers).map(normalizeAccount) }
} }
export async function getAllVloggers(followerId?: number) { export async function getAllVloggers(followerId?: number) {
const res = await postJson<GetAllVloggersResponse>( const res = await postJson<GetAllVloggersResponse>(
'/social/getAllVloggers', '/social/getAllVloggers',
followerId ? { follower_id: followerId } : {}, followerId ? { follower_id: followerId } : {},
{ authRequired: true }, { authRequired: true },
) )
return { ...res, vloggers: listOrEmpty(res.vloggers).map(normalizeAccount) } return { ...res, vloggers: listOrEmpty(res.vloggers).map(normalizeAccount) }
} }

View File

@@ -14,89 +14,89 @@ export type ListMessagesResponse = {
} }
export type TokenResponse = { token: string; refresh_token?: string; account_id?: number; username?: string } export type TokenResponse = { token: string; refresh_token?: string; account_id?: number; username?: string }
export type Account = { export type Account = {
id: number id: number
username: string username: string
avatar_url?: string avatar_url?: string
bio?: string bio?: string
} }
export type Video = { export type Video = {
id: number id: number
author_id: number author_id: number
username: string username: string
title: string title: string
description?: string description?: string
play_url: string play_url: string
cover_url: string cover_url: string
create_time: string create_time: string
likes_count: number likes_count: number
} }
export type Comment = { export type Comment = {
id: number id: number
username: string username: string
video_id: number video_id: number
author_id: number author_id: number
content: string content: string
created_at: string created_at: string
} }
export type FeedAuthor = { export type FeedAuthor = {
id: number id: number
username: string username: string
} }
export type FeedVideoItem = { export type FeedVideoItem = {
id: number id: number
author: FeedAuthor author: FeedAuthor
title: string title: string
description?: string description?: string
play_url: string play_url: string
cover_url: string cover_url: string
create_time: number create_time: number
likes_count: number likes_count: number
is_liked: boolean is_liked: boolean
} }
export type ListLatestResponse = { export type ListLatestResponse = {
video_list: FeedVideoItem[] video_list: FeedVideoItem[]
next_time: number next_time: number
has_more: boolean has_more: boolean
} }
export type ListLikesCountResponse = { export type ListLikesCountResponse = {
video_list: FeedVideoItem[] video_list: FeedVideoItem[]
next_likes_count_before?: number next_likes_count_before?: number
next_id_before?: number next_id_before?: number
has_more: boolean has_more: boolean
} }
export type ListByPopularityResponse = { export type ListByPopularityResponse = {
video_list: FeedVideoItem[] video_list: FeedVideoItem[]
as_of: number as_of: number
next_offset: number next_offset: number
has_more: boolean has_more: boolean
next_latest_popularity?: number next_latest_popularity?: number
next_latest_before?: string next_latest_before?: string
next_latest_id_before?: number next_latest_id_before?: number
} }
export type ListByFollowingResponse = { export type ListByFollowingResponse = {
video_list: FeedVideoItem[] video_list: FeedVideoItem[]
next_time: number next_time: number
has_more: boolean has_more: boolean
} }
export type IsLikedResponse = { export type IsLikedResponse = {
is_liked: boolean is_liked: boolean
} }
export type GetAllFollowersResponse = { export type GetAllFollowersResponse = {
followers: Account[] followers: Account[]
} }
export type GetAllVloggersResponse = { export type GetAllVloggersResponse = {
vloggers: Account[] vloggers: Account[]
} }

View File

@@ -1,93 +1,93 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, ref, watch } from 'vue' import { computed, ref, watch } from 'vue'
import { RouterLink, useRoute, useRouter } from 'vue-router' import { RouterLink, useRoute, useRouter } from 'vue-router'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
import { useSocialStore } from '../stores/social' import { useSocialStore } from '../stores/social'
import Toaster from './Toaster.vue' import Toaster from './Toaster.vue'
const props = defineProps<{ full?: boolean }>() const props = defineProps<{ full?: boolean }>()
const auth = useAuthStore() const auth = useAuthStore()
const social = useSocialStore() const social = useSocialStore()
const router = useRouter() const router = useRouter()
const route = useRoute() const route = useRoute()
const search = ref(typeof route.query.q === 'string' ? route.query.q : '') const search = ref(typeof route.query.q === 'string' ? route.query.q : '')
watch( watch(
() => route.query.q, () => route.query.q,
(v) => { (v) => {
search.value = typeof v === 'string' ? v : '' search.value = typeof v === 'string' ? v : ''
}, },
) )
watch( watch(
() => auth.isLoggedIn, () => auth.isLoggedIn,
(v) => { (v) => {
if (v) void social.refreshMine() if (v) void social.refreshMine()
else social.clear() else social.clear()
}, },
{ immediate: true }, { immediate: true },
) )
const userLabel = computed(() => { const userLabel = computed(() => {
if (!auth.isLoggedIn) return '未登录' if (!auth.isLoggedIn) return '未登录'
const username = auth.claims?.username ?? '(unknown)' const username = auth.claims?.username ?? '(unknown)'
const accountId = auth.claims?.account_id const accountId = auth.claims?.account_id
return accountId ? `${username} #${accountId}` : username return accountId ? `${username} #${accountId}` : username
}) })
async function onSearch() { async function onSearch() {
const q = search.value.trim() const q = search.value.trim()
await router.push({ path: '/', query: q ? { q } : {} }) await router.push({ path: '/', query: q ? { q } : {} })
} }
async function goLogin() { async function goLogin() {
await router.push('/account') await router.push('/account')
} }
async function goSettings() { async function goSettings() {
await router.push('/settings') await router.push('/settings')
} }
</script> </script>
<template> <template>
<div class="dy-shell"> <div class="dy-shell">
<aside class="dy-aside"> <aside class="dy-aside">
<RouterLink class="dy-logo" to="/">ShortVideo</RouterLink> <RouterLink class="dy-logo" to="/">ShortVideo</RouterLink>
<nav class="dy-nav"> <nav class="dy-nav">
<RouterLink class="dy-nav-link" to="/">推荐</RouterLink> <RouterLink class="dy-nav-link" to="/">推荐</RouterLink>
<RouterLink class="dy-nav-link" to="/hot">热榜</RouterLink> <RouterLink class="dy-nav-link" to="/hot">热榜</RouterLink>
<RouterLink class="dy-nav-link" to="/video">发布</RouterLink> <RouterLink class="dy-nav-link" to="/video">发布</RouterLink>
<RouterLink class="dy-nav-link" to="/account">账号</RouterLink> <RouterLink class="dy-nav-link" to="/account">账号</RouterLink>
<RouterLink v-if="auth.isLoggedIn" class="dy-nav-link" to="/messages">私信</RouterLink> <RouterLink v-if="auth.isLoggedIn" class="dy-nav-link" to="/messages">私信</RouterLink>
<RouterLink class="dy-nav-link" to="/settings">设置</RouterLink> <RouterLink class="dy-nav-link" to="/settings">设置</RouterLink>
</nav> </nav>
<div class="dy-aside-foot"> <div class="dy-aside-foot">
<div class="dy-user"> <div class="dy-user">
<span class="dy-user-dot" :class="auth.isLoggedIn ? 'ok' : 'bad'" /> <span class="dy-user-dot" :class="auth.isLoggedIn ? 'ok' : 'bad'" />
<span class="dy-user-name">{{ userLabel }}</span> <span class="dy-user-name">{{ userLabel }}</span>
</div> </div>
<div class="dy-user-actions"> <div class="dy-user-actions">
<button v-if="!auth.isLoggedIn" class="dy-btn dy-btn-primary" type="button" @click="goLogin">登录</button> <button v-if="!auth.isLoggedIn" class="dy-btn dy-btn-primary" type="button" @click="goLogin">登录</button>
<button v-else class="dy-btn dy-btn-primary" type="button" @click="goSettings">设置</button> <button v-else class="dy-btn dy-btn-primary" type="button" @click="goSettings">设置</button>
</div> </div>
</div> </div>
</aside> </aside>
<div class="dy-main"> <div class="dy-main">
<header class="dy-topbar"> <header class="dy-topbar">
<div class="dy-top-left"> <div class="dy-top-left">
<div class="dy-tabs-hint">{{ route.name }}</div> <div class="dy-tabs-hint">{{ route.name }}</div>
</div> </div>
<div class="dy-search"> <div class="dy-search">
<input v-model="search" class="dy-search-input" placeholder="搜索标题 / 作者(本地过滤)" @keydown.enter="onSearch" /> <input v-model="search" class="dy-search-input" placeholder="搜索标题 / 作者(本地过滤)" @keydown.enter="onSearch" />
<button class="dy-btn dy-btn-primary" type="button" @click="onSearch">搜索</button> <button class="dy-btn dy-btn-primary" type="button" @click="onSearch">搜索</button>
</div> </div>
<div class="dy-top-right"> <div class="dy-top-right">
<RouterLink class="dy-btn dy-btn-ghost" to="/video">+ 发布视频</RouterLink> <RouterLink class="dy-btn dy-btn-ghost" to="/video">+ 发布视频</RouterLink>
</div> </div>
@@ -100,24 +100,24 @@ async function goSettings() {
<RouterLink v-if="auth.isLoggedIn" class="dy-mobile-link" to="/messages">私信</RouterLink> <RouterLink v-if="auth.isLoggedIn" class="dy-mobile-link" to="/messages">私信</RouterLink>
<RouterLink class="dy-mobile-link" to="/account">账号</RouterLink> <RouterLink class="dy-mobile-link" to="/account">账号</RouterLink>
</nav> </nav>
<div class="dy-content" :class="props.full ? 'full' : 'padded'"> <div class="dy-content" :class="props.full ? 'full' : 'padded'">
<template v-if="props.full"> <template v-if="props.full">
<slot /> <slot />
</template> </template>
<template v-else> <template v-else>
<div class="container"> <div class="container">
<slot /> <slot />
</div> </div>
</template> </template>
</div> </div>
</div> </div>
<Toaster /> <Toaster />
</div> </div>
</template> </template>
<style scoped> <style scoped>
.dy-shell { .dy-shell {
height: 100vh; height: 100vh;
display: grid; display: grid;
@@ -132,10 +132,10 @@ async function goSettings() {
padding: 14px 12px; padding: 14px 12px;
display: flex; display: flex;
flex-direction: column; flex-direction: column;
gap: 14px; gap: 14px;
} }
.dy-logo { .dy-logo {
font-weight: 900; font-weight: 900;
letter-spacing: 0; letter-spacing: 0;
font-size: 18px; font-size: 18px;
@@ -145,12 +145,12 @@ async function goSettings() {
border: 1px solid rgba(43, 161, 255, 0.22); border: 1px solid rgba(43, 161, 255, 0.22);
text-decoration: none; text-decoration: none;
} }
.dy-nav { .dy-nav {
display: grid; display: grid;
gap: 8px; gap: 8px;
} }
.dy-nav-link { .dy-nav-link {
padding: 10px 10px; padding: 10px 10px;
border-radius: 8px; border-radius: 8px;
@@ -165,34 +165,34 @@ async function goSettings() {
background: rgba(43, 161, 255, 0.14); background: rgba(43, 161, 255, 0.14);
color: rgba(246, 248, 251, 0.96); color: rgba(246, 248, 251, 0.96);
} }
.dy-aside-foot { .dy-aside-foot {
margin-top: auto; margin-top: auto;
display: grid; display: grid;
gap: 10px; gap: 10px;
padding-top: 12px; padding-top: 12px;
border-top: 1px solid var(--border); border-top: 1px solid var(--border);
} }
.dy-user { .dy-user {
display: flex; display: flex;
gap: 10px; gap: 10px;
align-items: center; align-items: center;
} }
.dy-user-dot { .dy-user-dot {
width: 10px; width: 10px;
height: 10px; height: 10px;
border-radius: 999px; border-radius: 999px;
background: rgba(255, 255, 255, 0.25); background: rgba(255, 255, 255, 0.25);
box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.06); box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.06);
} }
.dy-user-dot.ok { .dy-user-dot.ok {
background: rgba(34, 197, 94, 1); background: rgba(34, 197, 94, 1);
box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.14); box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.14);
} }
.dy-user-dot.bad { .dy-user-dot.bad {
background: rgba(255, 93, 115, 1); background: rgba(255, 93, 115, 1);
box-shadow: 0 0 0 3px rgba(255, 93, 115, 0.14); box-shadow: 0 0 0 3px rgba(255, 93, 115, 0.14);
@@ -201,36 +201,36 @@ async function goSettings() {
.dy-user-name { .dy-user-name {
font-size: 13px; font-size: 13px;
color: var(--text); color: var(--text);
overflow: hidden; overflow: hidden;
text-overflow: ellipsis; text-overflow: ellipsis;
white-space: nowrap; white-space: nowrap;
} }
.dy-user-actions { .dy-user-actions {
display: flex; display: flex;
gap: 10px; gap: 10px;
} }
.dy-btn { .dy-btn {
appearance: none; appearance: none;
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
color: var(--text); color: var(--text);
border-radius: 8px; border-radius: 8px;
padding: 10px 12px; padding: 10px 12px;
cursor: pointer; cursor: pointer;
text-decoration: none; text-decoration: none;
display: inline-flex; display: inline-flex;
align-items: center; align-items: center;
gap: 8px; gap: 8px;
justify-content: center; justify-content: center;
font-size: 13px; font-size: 13px;
} }
.dy-btn:hover { .dy-btn:hover {
background: rgba(255, 255, 255, 0.1); background: rgba(255, 255, 255, 0.1);
} }
.dy-btn-primary { .dy-btn-primary {
border-color: rgba(43, 161, 255, 0.5); border-color: rgba(43, 161, 255, 0.5);
background: rgba(43, 161, 255, 0.16); background: rgba(43, 161, 255, 0.16);
@@ -244,72 +244,72 @@ async function goSettings() {
border-color: var(--border); border-color: var(--border);
background: rgba(255, 255, 255, 0.045); background: rgba(255, 255, 255, 0.045);
} }
.dy-main { .dy-main {
height: 100vh; height: 100vh;
display: flex; display: flex;
flex-direction: column; flex-direction: column;
min-width: 0; min-width: 0;
} }
.dy-topbar { .dy-topbar {
height: 56px; height: 56px;
border-bottom: 1px solid var(--border); border-bottom: 1px solid var(--border);
background: rgba(12, 16, 23, 0.68); background: rgba(12, 16, 23, 0.68);
backdrop-filter: blur(18px); backdrop-filter: blur(18px);
display: grid; display: grid;
grid-template-columns: 180px 1fr 180px; grid-template-columns: 180px 1fr 180px;
gap: 12px; gap: 12px;
align-items: center; align-items: center;
padding: 0 14px; padding: 0 14px;
} }
.dy-tabs-hint { .dy-tabs-hint {
font-size: 12px; font-size: 12px;
color: var(--muted); color: var(--muted);
text-transform: uppercase; text-transform: uppercase;
letter-spacing: 0; letter-spacing: 0;
} }
.dy-search { .dy-search {
display: grid; display: grid;
grid-template-columns: 1fr auto; grid-template-columns: 1fr auto;
gap: 10px; gap: 10px;
align-items: center; align-items: center;
max-width: 680px; max-width: 680px;
width: 100%; width: 100%;
justify-self: center; justify-self: center;
} }
.dy-search-input { .dy-search-input {
width: 100%; width: 100%;
background: rgba(255, 255, 255, 0.055); background: rgba(255, 255, 255, 0.055);
border: 1px solid var(--border); border: 1px solid var(--border);
border-radius: 8px; border-radius: 8px;
color: var(--text); color: var(--text);
padding: 10px 14px; padding: 10px 14px;
outline: none; outline: none;
} }
.dy-search-input:focus { .dy-search-input:focus {
border-color: rgba(43, 161, 255, 0.52); border-color: rgba(43, 161, 255, 0.52);
box-shadow: 0 0 0 3px rgba(43, 161, 255, 0.14); box-shadow: 0 0 0 3px rgba(43, 161, 255, 0.14);
} }
.dy-top-right { .dy-top-right {
display: flex; display: flex;
justify-content: flex-end; justify-content: flex-end;
} }
.dy-content { .dy-content {
flex: 1; flex: 1;
min-height: 0; min-height: 0;
} }
.dy-content.padded { .dy-content.padded {
overflow: auto; overflow: auto;
} }
.dy-content.full { .dy-content.full {
overflow: hidden; overflow: hidden;
} }
@@ -320,18 +320,18 @@ async function goSettings() {
@media (max-width: 900px) { @media (max-width: 900px) {
.dy-shell { .dy-shell {
grid-template-columns: 1fr; grid-template-columns: 1fr;
} }
.dy-aside { .dy-aside {
display: none; display: none;
} }
.dy-topbar { .dy-topbar {
grid-template-columns: 1fr; grid-template-columns: 1fr;
padding: 0 10px; padding: 0 10px;
} }
.dy-top-left { .dy-top-left {
display: none; display: none;
} }
.dy-top-right { .dy-top-right {
display: none; display: none;
} }

View File

@@ -1,89 +1,89 @@
<script setup lang="ts"> <script setup lang="ts">
import type { FeedVideoItem } from '../api/types' import type { FeedVideoItem } from '../api/types'
const props = defineProps<{ const props = defineProps<{
item: FeedVideoItem item: FeedVideoItem
canLike: boolean canLike: boolean
busy?: boolean busy?: boolean
}>() }>()
const emit = defineEmits<{ const emit = defineEmits<{
(e: 'toggle-like', item: FeedVideoItem): void (e: 'toggle-like', item: FeedVideoItem): void
}>() }>()
function onToggle() { function onToggle() {
emit('toggle-like', props.item) emit('toggle-like', props.item)
} }
</script> </script>
<template> <template>
<div class="feed-card"> <div class="feed-card">
<div class="cover"> <div class="cover">
<img :src="item.cover_url" :alt="item.title" loading="lazy" /> <img :src="item.cover_url" :alt="item.title" loading="lazy" />
</div> </div>
<div class="content"> <div class="content">
<div class="row" style="justify-content: space-between"> <div class="row" style="justify-content: space-between">
<div> <div>
<div class="title"> <div class="title">
<RouterLink :to="`/video/${item.id}`">{{ item.title }}</RouterLink> <RouterLink :to="`/video/${item.id}`">{{ item.title }}</RouterLink>
</div> </div>
<div class="subtle"> <div class="subtle">
作者:{{ item.author.username }} (#{{ item.author.id }}) · 创建时间:{{ new Date(item.create_time * 1000).toLocaleString() }} 作者:{{ item.author.username }} (#{{ item.author.id }}) · 创建时间:{{ new Date(item.create_time * 1000).toLocaleString() }}
</div> </div>
</div> </div>
<div class="row"> <div class="row">
<span class="pill mono">❤️ {{ item.likes_count }}</span> <span class="pill mono">❤️ {{ item.likes_count }}</span>
<button <button
v-if="canLike" v-if="canLike"
class="primary" class="primary"
type="button" type="button"
:disabled="busy" :disabled="busy"
@click="onToggle" @click="onToggle"
:title="item.is_liked ? '取消点赞' : '点赞'" :title="item.is_liked ? '取消点赞' : '点赞'"
> >
{{ item.is_liked ? '已赞' : '点赞' }} {{ item.is_liked ? '已赞' : '点赞' }}
</button> </button>
</div> </div>
</div> </div>
<div v-if="item.description" class="muted" style="margin-top: 8px">{{ item.description }}</div> <div v-if="item.description" class="muted" style="margin-top: 8px">{{ item.description }}</div>
<div class="row" style="margin-top: 10px"> <div class="row" style="margin-top: 10px">
<a class="pill mono" :href="item.play_url" target="_blank" rel="noreferrer">播放地址</a> <a class="pill mono" :href="item.play_url" target="_blank" rel="noreferrer">播放地址</a>
<RouterLink class="pill" :to="`/video/${item.id}`">查看详情 / 评论</RouterLink> <RouterLink class="pill" :to="`/video/${item.id}`">查看详情 / 评论</RouterLink>
</div> </div>
</div> </div>
</div> </div>
</template> </template>
<style scoped> <style scoped>
.feed-card { .feed-card {
display: grid; display: grid;
grid-template-columns: 240px minmax(0, 1fr); grid-template-columns: 240px minmax(0, 1fr);
gap: 14px; gap: 14px;
border: 1px solid rgba(255, 255, 255, 0.12); border: 1px solid rgba(255, 255, 255, 0.12);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
border-radius: 16px; border-radius: 16px;
overflow: hidden; overflow: hidden;
} }
.cover { .cover {
background: rgba(0, 0, 0, 0.25); background: rgba(0, 0, 0, 0.25);
aspect-ratio: 16/9; aspect-ratio: 16/9;
} }
.cover img { .cover img {
width: 100%; width: 100%;
height: 100%; height: 100%;
object-fit: cover; object-fit: cover;
display: block; display: block;
} }
.content { .content {
padding: 12px 12px 14px; padding: 12px 12px 14px;
} }
@media (max-width: 900px) { @media (max-width: 900px) {
.feed-card { .feed-card {
grid-template-columns: 1fr; grid-template-columns: 1fr;
} }
} }
</style> </style>

View File

@@ -1,17 +1,17 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed } from 'vue' import { computed } from 'vue'
const props = defineProps<{ value: unknown }>() const props = defineProps<{ value: unknown }>()
const text = computed(() => { const text = computed(() => {
try { try {
return JSON.stringify(props.value, null, 2) return JSON.stringify(props.value, null, 2)
} catch { } catch {
return String(props.value) return String(props.value)
} }
}) })
</script> </script>
<template> <template>
<pre class="pre mono">{{ text }}</pre> <pre class="pre mono">{{ text }}</pre>
</template> </template>

View File

@@ -1,73 +1,73 @@
<script setup lang="ts"> <script setup lang="ts">
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const toast = useToastStore() const toast = useToastStore()
</script> </script>
<template> <template>
<div class="toast-wrap" aria-live="polite" aria-relevant="additions removals"> <div class="toast-wrap" aria-live="polite" aria-relevant="additions removals">
<div v-for="t in toast.toasts" :key="t.id" class="toast" :class="t.type"> <div v-for="t in toast.toasts" :key="t.id" class="toast" :class="t.type">
<div class="toast-msg">{{ t.message }}</div> <div class="toast-msg">{{ t.message }}</div>
<button class="toast-x" type="button" aria-label="关闭" @click="toast.remove(t.id)">×</button> <button class="toast-x" type="button" aria-label="关闭" @click="toast.remove(t.id)">×</button>
</div> </div>
</div> </div>
</template> </template>
<style scoped> <style scoped>
.toast-wrap { .toast-wrap {
position: fixed; position: fixed;
top: 16px; top: 16px;
left: 50%; left: 50%;
transform: translateX(-50%); transform: translateX(-50%);
display: grid; display: grid;
gap: 10px; gap: 10px;
z-index: 200; z-index: 200;
width: min(520px, calc(100vw - 24px)); width: min(520px, calc(100vw - 24px));
pointer-events: none; pointer-events: none;
} }
.toast { .toast {
pointer-events: auto; pointer-events: auto;
display: grid; display: grid;
grid-template-columns: 1fr auto; grid-template-columns: 1fr auto;
gap: 10px; gap: 10px;
align-items: center; align-items: center;
border-radius: 14px; border-radius: 14px;
padding: 10px 12px; padding: 10px 12px;
backdrop-filter: blur(12px); backdrop-filter: blur(12px);
border: 1px solid rgba(255, 255, 255, 0.12); border: 1px solid rgba(255, 255, 255, 0.12);
background: rgba(0, 0, 0, 0.55); background: rgba(0, 0, 0, 0.55);
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.35); box-shadow: 0 10px 30px rgba(0, 0, 0, 0.35);
} }
.toast.success { .toast.success {
border-color: rgba(34, 197, 94, 0.35); border-color: rgba(34, 197, 94, 0.35);
} }
.toast.error { .toast.error {
border-color: rgba(254, 44, 85, 0.45); border-color: rgba(254, 44, 85, 0.45);
} }
.toast.info { .toast.info {
border-color: rgba(37, 244, 238, 0.3); border-color: rgba(37, 244, 238, 0.3);
} }
.toast-msg { .toast-msg {
font-size: 13px; font-size: 13px;
line-height: 1.35; line-height: 1.35;
color: rgba(255, 255, 255, 0.92); color: rgba(255, 255, 255, 0.92);
} }
.toast-x { .toast-x {
width: 30px; width: 30px;
height: 30px; height: 30px;
border-radius: 10px; border-radius: 10px;
border: 1px solid rgba(255, 255, 255, 0.14); border: 1px solid rgba(255, 255, 255, 0.14);
background: rgba(255, 255, 255, 0.08); background: rgba(255, 255, 255, 0.08);
color: rgba(255, 255, 255, 0.88); color: rgba(255, 255, 255, 0.88);
cursor: pointer; cursor: pointer;
font-size: 18px; font-size: 18px;
line-height: 1; line-height: 1;
padding: 0; padding: 0;
} }
</style> </style>

View File

@@ -1,57 +1,57 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed } from 'vue' import { computed } from 'vue'
const props = defineProps<{ const props = defineProps<{
username: string username: string
id?: number id?: number
size?: number size?: number
src?: string src?: string
}>() }>()
function hashToHue(input: string) { function hashToHue(input: string) {
let h = 0 let h = 0
for (let i = 0; i < input.length; i += 1) { for (let i = 0; i < input.length; i += 1) {
h = (h * 31 + input.charCodeAt(i)) >>> 0 h = (h * 31 + input.charCodeAt(i)) >>> 0
} }
return h % 360 return h % 360
} }
const initial = computed(() => { const initial = computed(() => {
const s = (props.username ?? '').trim() const s = (props.username ?? '').trim()
if (!s) return '?' if (!s) return '?'
return s.slice(0, 1).toUpperCase() return s.slice(0, 1).toUpperCase()
}) })
const sizePx = computed(() => `${props.size ?? 40}px`) const sizePx = computed(() => `${props.size ?? 40}px`)
const bg = computed(() => { const bg = computed(() => {
const seed = typeof props.id === 'number' ? String(props.id) : props.username const seed = typeof props.id === 'number' ? String(props.id) : props.username
const hue = hashToHue(seed || '0') const hue = hashToHue(seed || '0')
const h1 = hue const h1 = hue
const h2 = (hue + 40) % 360 const h2 = (hue + 40) % 360
return `linear-gradient(135deg, hsl(${h1} 90% 55%), hsl(${h2} 90% 55%))` return `linear-gradient(135deg, hsl(${h1} 90% 55%), hsl(${h2} 90% 55%))`
}) })
</script> </script>
<template> <template>
<img v-if="src" :src="src" class="avatar" :style="{ width: sizePx, height: sizePx }" alt="" /> <img v-if="src" :src="src" class="avatar" :style="{ width: sizePx, height: sizePx }" alt="" />
<div v-else class="avatar" :style="{ width: sizePx, height: sizePx, backgroundImage: bg }" aria-hidden="true"> <div v-else class="avatar" :style="{ width: sizePx, height: sizePx, backgroundImage: bg }" aria-hidden="true">
{{ initial }} {{ initial }}
</div> </div>
</template> </template>
<style scoped> <style scoped>
.avatar { .avatar {
display: grid; display: grid;
place-items: center; place-items: center;
border-radius: 999px; border-radius: 999px;
border: 1px solid rgba(255, 255, 255, 0.12); border: 1px solid rgba(255, 255, 255, 0.12);
box-shadow: 0 12px 30px rgba(0, 0, 0, 0.25); box-shadow: 0 12px 30px rgba(0, 0, 0, 0.25);
color: rgba(255, 255, 255, 0.92); color: rgba(255, 255, 255, 0.92);
font-weight: 900; font-weight: 900;
letter-spacing: 0.2px; letter-spacing: 0.2px;
user-select: none; user-select: none;
object-fit: cover; object-fit: cover;
} }
</style> </style>

View File

@@ -1,16 +1,16 @@
import { createApp } from 'vue' import { createApp } from 'vue'
import { createPinia } from 'pinia' import { createPinia } from 'pinia'
import './style.css' import './style.css'
import App from './App.vue' import App from './App.vue'
import router from './router' import router from './router'
import { reportError } from './utils/error-reporter' import { reportError } from './utils/error-reporter'
const app = createApp(App) const app = createApp(App)
app.use(createPinia()) app.use(createPinia())
app.use(router) app.use(router)
app.config.errorHandler = (err, _instance, info) => { app.config.errorHandler = (err, _instance, info) => {
reportError(err instanceof Error ? err : new Error(String(err)), { info }) reportError(err instanceof Error ? err : new Error(String(err)), { info })
} }
app.mount('#app') app.mount('#app')

View File

@@ -1,42 +1,42 @@
import { createRouter, createWebHistory } from 'vue-router' import { createRouter, createWebHistory } from 'vue-router'
import HomeView from '../views/HomeView.vue' import HomeView from '../views/HomeView.vue'
import HotView from '../views/HotView.vue' import HotView from '../views/HotView.vue'
import VideoView from '../views/VideoView.vue' import VideoView from '../views/VideoView.vue'
import VideoDetailView from '../views/VideoDetailView.vue' import VideoDetailView from '../views/VideoDetailView.vue'
import AccountView from '../views/AccountView.vue' import AccountView from '../views/AccountView.vue'
import ChangePasswordView from '../views/ChangePasswordView.vue' import ChangePasswordView from '../views/ChangePasswordView.vue'
import RegisterView from '../views/RegisterView.vue' import RegisterView from '../views/RegisterView.vue'
import SettingsView from '../views/SettingsView.vue' import SettingsView from '../views/SettingsView.vue'
import UserProfileView from '../views/UserProfileView.vue' import UserProfileView from '../views/UserProfileView.vue'
import MessageView from '../views/MessageView.vue' import MessageView from '../views/MessageView.vue'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
const router = createRouter({ const router = createRouter({
history: createWebHistory(), history: createWebHistory(),
routes: [ routes: [
{ path: '/', name: 'home', component: HomeView }, { path: '/', name: 'home', component: HomeView },
{ path: '/feed', redirect: '/' }, { path: '/feed', redirect: '/' },
{ path: '/hot', name: 'hot', component: HotView }, { path: '/hot', name: 'hot', component: HotView },
{ path: '/video', name: 'video', component: VideoView, meta: { requiresAuth: true } }, { path: '/video', name: 'video', component: VideoView, meta: { requiresAuth: true } },
{ path: '/video/:id', name: 'video-detail', component: VideoDetailView, props: true }, { path: '/video/:id', name: 'video-detail', component: VideoDetailView, props: true },
{ path: '/account', name: 'account', component: AccountView }, { path: '/account', name: 'account', component: AccountView },
{ path: '/account/register', name: 'account-register', component: RegisterView }, { path: '/account/register', name: 'account-register', component: RegisterView },
{ path: '/account/change-password', name: 'account-change-password', component: ChangePasswordView }, { path: '/account/change-password', name: 'account-change-password', component: ChangePasswordView },
{ path: '/settings', name: 'settings', component: SettingsView, meta: { requiresAuth: true } }, { path: '/settings', name: 'settings', component: SettingsView, meta: { requiresAuth: true } },
{ path: '/u/:id', name: 'user-profile', component: UserProfileView, props: true }, { path: '/u/:id', name: 'user-profile', component: UserProfileView, props: true },
{ path: '/messages', name: 'message-list', component: MessageView, meta: { requiresAuth: true } }, { path: '/messages', name: 'message-list', component: MessageView, meta: { requiresAuth: true } },
{ path: '/messages/:peerId', name: 'messages', component: MessageView, meta: { requiresAuth: true } }, { path: '/messages/:peerId', name: 'messages', component: MessageView, meta: { requiresAuth: true } },
], ],
}) })
router.beforeEach((to, _from, next) => { router.beforeEach((to, _from, next) => {
const auth = useAuthStore() const auth = useAuthStore()
if (to.meta.requiresAuth && !auth.isLoggedIn) { if (to.meta.requiresAuth && !auth.isLoggedIn) {
next({ path: '/account', query: { redirect: to.fullPath } }) next({ path: '/account', query: { redirect: to.fullPath } })
return return
} }
next() next()
}) })
export default router export default router

View File

@@ -1,48 +1,48 @@
import { defineStore } from 'pinia' import { defineStore } from 'pinia'
import { computed, ref } from 'vue' import { computed, ref } from 'vue'
import { decodeJwtPayload, type JwtPayload } from '../utils/jwt' import { decodeJwtPayload, type JwtPayload } from '../utils/jwt'
const ACCESS_KEY = 'access_token' const ACCESS_KEY = 'access_token'
const REFRESH_KEY = 'refresh_token' const REFRESH_KEY = 'refresh_token'
function readStored(key: string): string | null { function readStored(key: string): string | null {
try { return localStorage.getItem(key) } catch { return null } try { return localStorage.getItem(key) } catch { return null }
} }
function writeStored(key: string, value: string) { function writeStored(key: string, value: string) {
localStorage.setItem(key, value) localStorage.setItem(key, value)
} }
function removeStored(key: string) { function removeStored(key: string) {
localStorage.removeItem(key) localStorage.removeItem(key)
} }
export const useAuthStore = defineStore('auth', () => { export const useAuthStore = defineStore('auth', () => {
const token = ref<string | null>(readStored(ACCESS_KEY)) const token = ref<string | null>(readStored(ACCESS_KEY))
const refreshToken = ref<string | null>(readStored(REFRESH_KEY)) const refreshToken = ref<string | null>(readStored(REFRESH_KEY))
const isLoggedIn = computed(() => !!token.value) const isLoggedIn = computed(() => !!token.value)
const claims = computed<JwtPayload | null>(() => (token.value ? decodeJwtPayload(token.value) : null)) const claims = computed<JwtPayload | null>(() => (token.value ? decodeJwtPayload(token.value) : null))
function setToken(newToken: string) { function setToken(newToken: string) {
token.value = newToken token.value = newToken
writeStored(ACCESS_KEY, newToken) writeStored(ACCESS_KEY, newToken)
} }
function setTokens(access: string, refresh: string) { function setTokens(access: string, refresh: string) {
token.value = access token.value = access
refreshToken.value = refresh refreshToken.value = refresh
writeStored(ACCESS_KEY, access) writeStored(ACCESS_KEY, access)
writeStored(REFRESH_KEY, refresh) writeStored(REFRESH_KEY, refresh)
} }
function clearTokens() { function clearTokens() {
token.value = null token.value = null
refreshToken.value = null refreshToken.value = null
removeStored(ACCESS_KEY) removeStored(ACCESS_KEY)
removeStored(REFRESH_KEY) removeStored(REFRESH_KEY)
} }
return { token, refreshToken, isLoggedIn, claims, setToken, setTokens, clearTokens } return { token, refreshToken, isLoggedIn, claims, setToken, setTokens, clearTokens }
}) })

View File

@@ -1,109 +1,109 @@
import { defineStore } from 'pinia' import { defineStore } from 'pinia'
import { computed, ref } from 'vue' import { computed, ref } from 'vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import type { Account } from '../api/types' import type { Account } from '../api/types'
import * as socialApi from '../api/social' import * as socialApi from '../api/social'
import { useAuthStore } from './auth' import { useAuthStore } from './auth'
export const useSocialStore = defineStore('social', () => { export const useSocialStore = defineStore('social', () => {
const auth = useAuthStore() const auth = useAuthStore()
const followers = ref<Account[]>([]) const followers = ref<Account[]>([])
const vloggers = ref<Account[]>([]) const vloggers = ref<Account[]>([])
const followersLoading = ref(false) const followersLoading = ref(false)
const vloggersLoading = ref(false) const vloggersLoading = ref(false)
const followersError = ref('') const followersError = ref('')
const vloggersError = ref('') const vloggersError = ref('')
const followerCount = computed(() => followers.value.length) const followerCount = computed(() => followers.value.length)
const followingCount = computed(() => vloggers.value.length) const followingCount = computed(() => vloggers.value.length)
function clear() { function clear() {
followers.value = [] followers.value = []
vloggers.value = [] vloggers.value = []
followersError.value = '' followersError.value = ''
vloggersError.value = '' vloggersError.value = ''
followersLoading.value = false followersLoading.value = false
vloggersLoading.value = false vloggersLoading.value = false
} }
function isFollowing(accountId: number) { function isFollowing(accountId: number) {
return vloggers.value.some((a) => a.id === accountId) return vloggers.value.some((a) => a.id === accountId)
} }
async function refreshFollowers(vloggerId?: number) { async function refreshFollowers(vloggerId?: number) {
if (!auth.isLoggedIn) { if (!auth.isLoggedIn) {
clear() clear()
return return
} }
followersLoading.value = true followersLoading.value = true
followersError.value = '' followersError.value = ''
try { try {
const res = await socialApi.getAllFollowers(vloggerId) const res = await socialApi.getAllFollowers(vloggerId)
followers.value = res.followers followers.value = res.followers
} catch (e) { } catch (e) {
followersError.value = e instanceof ApiError ? e.message : String(e) followersError.value = e instanceof ApiError ? e.message : String(e)
followers.value = [] followers.value = []
} finally { } finally {
followersLoading.value = false followersLoading.value = false
} }
} }
async function refreshVloggers(followerId?: number) { async function refreshVloggers(followerId?: number) {
if (!auth.isLoggedIn) { if (!auth.isLoggedIn) {
clear() clear()
return return
} }
vloggersLoading.value = true vloggersLoading.value = true
vloggersError.value = '' vloggersError.value = ''
try { try {
const res = await socialApi.getAllVloggers(followerId) const res = await socialApi.getAllVloggers(followerId)
vloggers.value = res.vloggers vloggers.value = res.vloggers
} catch (e) { } catch (e) {
vloggersError.value = e instanceof ApiError ? e.message : String(e) vloggersError.value = e instanceof ApiError ? e.message : String(e)
vloggers.value = [] vloggers.value = []
} finally { } finally {
vloggersLoading.value = false vloggersLoading.value = false
} }
} }
async function refreshMine() { async function refreshMine() {
await Promise.all([refreshFollowers(), refreshVloggers()]) await Promise.all([refreshFollowers(), refreshVloggers()])
} }
async function follow(vloggerId: number) { async function follow(vloggerId: number) {
if (!auth.isLoggedIn) throw new ApiError('需要先登录', 401) if (!auth.isLoggedIn) throw new ApiError('需要先登录', 401)
await socialApi.follow(vloggerId) await socialApi.follow(vloggerId)
await refreshVloggers() await refreshVloggers()
} }
async function unfollow(vloggerId: number) { async function unfollow(vloggerId: number) {
if (!auth.isLoggedIn) throw new ApiError('需要先登录', 401) if (!auth.isLoggedIn) throw new ApiError('需要先登录', 401)
await socialApi.unfollow(vloggerId) await socialApi.unfollow(vloggerId)
await refreshVloggers() await refreshVloggers()
} }
return { return {
followers, followers,
vloggers, vloggers,
followerCount, followerCount,
followingCount, followingCount,
followersLoading, followersLoading,
vloggersLoading, vloggersLoading,
followersError, followersError,
vloggersError, vloggersError,
clear, clear,
isFollowing, isFollowing,
refreshMine, refreshMine,
refreshFollowers, refreshFollowers,
refreshVloggers, refreshVloggers,
follow, follow,
unfollow, unfollow,
} }
}) })

View File

@@ -1,40 +1,40 @@
import { defineStore } from 'pinia' import { defineStore } from 'pinia'
import { ref } from 'vue' import { ref } from 'vue'
export type ToastType = 'success' | 'error' | 'info' export type ToastType = 'success' | 'error' | 'info'
export type Toast = { export type Toast = {
id: number id: number
type: ToastType type: ToastType
message: string message: string
} }
let nextId = 1 let nextId = 1
export const useToastStore = defineStore('toast', () => { export const useToastStore = defineStore('toast', () => {
const toasts = ref<Toast[]>([]) const toasts = ref<Toast[]>([])
function remove(id: number) { function remove(id: number) {
toasts.value = toasts.value.filter((t) => t.id !== id) toasts.value = toasts.value.filter((t) => t.id !== id)
} }
function push(type: ToastType, message: string, ttlMs = 2600) { function push(type: ToastType, message: string, ttlMs = 2600) {
const id = nextId++ const id = nextId++
toasts.value.push({ id, type, message }) toasts.value.push({ id, type, message })
window.setTimeout(() => remove(id), ttlMs) window.setTimeout(() => remove(id), ttlMs)
} }
function success(message: string) { function success(message: string) {
push('success', message) push('success', message)
} }
function error(message: string) { function error(message: string) {
push('error', message, 3600) push('error', message, 3600)
} }
function info(message: string) { function info(message: string) {
push('info', message) push('info', message)
} }
return { toasts, push, remove, success, error, info } return { toasts, push, remove, success, error, info }
}) })

View File

@@ -14,19 +14,19 @@
--shadow: 0 18px 48px rgba(0, 0, 0, 0.28); --shadow: 0 18px 48px rgba(0, 0, 0, 0.28);
font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, 'Apple Color Emoji', font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, 'Apple Color Emoji',
'Segoe UI Emoji'; 'Segoe UI Emoji';
line-height: 1.5; line-height: 1.5;
font-synthesis: none; font-synthesis: none;
text-rendering: optimizeLegibility; text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased; -webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale; -moz-osx-font-smoothing: grayscale;
} }
*, *,
*::before, *::before,
*::after { *::after {
box-sizing: border-box; box-sizing: border-box;
} }
* { * {
scrollbar-width: thin; scrollbar-width: thin;
scrollbar-color: rgba(155, 171, 195, 0.35) transparent; scrollbar-color: rgba(155, 171, 195, 0.35) transparent;
@@ -58,12 +58,12 @@ body {
linear-gradient(180deg, #10141d 0%, var(--bg) 42%, #0b0e14 100%); linear-gradient(180deg, #10141d 0%, var(--bg) 42%, #0b0e14 100%);
color: var(--text); color: var(--text);
} }
a { a {
color: inherit; color: inherit;
text-decoration: none; text-decoration: none;
} }
a:hover { a:hover {
color: #dceeff; color: #dceeff;
} }
@@ -86,57 +86,57 @@ a:hover {
.card + .card { .card + .card {
margin-top: 16px; margin-top: 16px;
} }
.grid { .grid {
display: grid; display: grid;
gap: 12px; gap: 12px;
} }
.grid.two { .grid.two {
grid-template-columns: repeat(2, minmax(0, 1fr)); grid-template-columns: repeat(2, minmax(0, 1fr));
} }
.grid.three { .grid.three {
grid-template-columns: repeat(3, minmax(0, 1fr)); grid-template-columns: repeat(3, minmax(0, 1fr));
} }
@media (max-width: 900px) { @media (max-width: 900px) {
.grid.two, .grid.two,
.grid.three { .grid.three {
grid-template-columns: 1fr; grid-template-columns: 1fr;
} }
} }
.row { .row {
display: flex; display: flex;
gap: 10px; gap: 10px;
flex-wrap: wrap; flex-wrap: wrap;
align-items: center; align-items: center;
} }
.muted { .muted {
color: var(--muted); color: var(--muted);
} }
.title { .title {
font-size: 18px; font-size: 18px;
font-weight: 800; font-weight: 800;
margin: 0 0 6px; margin: 0 0 6px;
letter-spacing: 0; letter-spacing: 0;
} }
.subtle { .subtle {
font-size: 13px; font-size: 13px;
color: var(--muted); color: var(--muted);
} }
label { label {
font-size: 13px; font-size: 13px;
color: var(--muted); color: var(--muted);
display: inline-block; display: inline-block;
margin-bottom: 6px; margin-bottom: 6px;
} }
input, input,
textarea, textarea,
select { select {
@@ -149,12 +149,12 @@ select {
outline: none; outline: none;
transition: border-color 140ms ease, box-shadow 140ms ease, background 140ms ease; transition: border-color 140ms ease, box-shadow 140ms ease, background 140ms ease;
} }
textarea { textarea {
min-height: 88px; min-height: 88px;
resize: vertical; resize: vertical;
} }
input:focus, input:focus,
textarea:focus, textarea:focus,
select:focus { select:focus {
@@ -174,11 +174,11 @@ button {
transition: 120ms ease; transition: 120ms ease;
font: inherit; font: inherit;
} }
button:hover { button:hover {
background: rgba(255, 255, 255, 0.12); background: rgba(255, 255, 255, 0.12);
} }
button.primary { button.primary {
border-color: rgba(43, 161, 255, 0.55); border-color: rgba(43, 161, 255, 0.55);
background: rgba(43, 161, 255, 0.18); background: rgba(43, 161, 255, 0.18);
@@ -187,53 +187,53 @@ button.primary {
button.primary:hover { button.primary:hover {
background: rgba(43, 161, 255, 0.26); background: rgba(43, 161, 255, 0.26);
} }
button.danger { button.danger {
border-color: rgba(255, 77, 109, 0.65); border-color: rgba(255, 77, 109, 0.65);
background: rgba(255, 77, 109, 0.18); background: rgba(255, 77, 109, 0.18);
} }
button.danger:hover { button.danger:hover {
background: rgba(255, 77, 109, 0.26); background: rgba(255, 77, 109, 0.26);
} }
button:disabled { button:disabled {
opacity: 0.5; opacity: 0.5;
cursor: not-allowed; cursor: not-allowed;
} }
.pill { .pill {
display: inline-flex; display: inline-flex;
align-items: center; align-items: center;
gap: 8px; gap: 8px;
padding: 6px 10px; padding: 6px 10px;
border-radius: 8px; border-radius: 8px;
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
font-size: 13px; font-size: 13px;
} }
.pill.ok { .pill.ok {
border-color: rgba(34, 197, 94, 0.5); border-color: rgba(34, 197, 94, 0.5);
background: rgba(34, 197, 94, 0.12); background: rgba(34, 197, 94, 0.12);
} }
.pill.bad { .pill.bad {
border-color: rgba(255, 77, 109, 0.55); border-color: rgba(255, 77, 109, 0.55);
background: rgba(255, 77, 109, 0.12); background: rgba(255, 77, 109, 0.12);
} }
.mono { .mono {
font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace;
} }
.pre { .pre {
white-space: pre-wrap; white-space: pre-wrap;
word-break: break-word; word-break: break-word;
font-size: 13px; font-size: 13px;
line-height: 1.45; line-height: 1.45;
background: rgba(0, 0, 0, 0.25); background: rgba(0, 0, 0, 0.25);
border: 1px solid rgba(255, 255, 255, 0.1); border: 1px solid rgba(255, 255, 255, 0.1);
border-radius: 8px; border-radius: 8px;
padding: 12px; padding: 12px;
margin: 0; margin: 0;

View File

@@ -1,35 +1,35 @@
export type JwtPayload = { export type JwtPayload = {
account_id?: number account_id?: number
username?: string username?: string
exp?: number exp?: number
iat?: number iat?: number
nbf?: number nbf?: number
[key: string]: unknown [key: string]: unknown
} }
function base64UrlToBase64(input: string) { function base64UrlToBase64(input: string) {
const base64 = input.replace(/-/g, '+').replace(/_/g, '/') const base64 = input.replace(/-/g, '+').replace(/_/g, '/')
const pad = base64.length % 4 const pad = base64.length % 4
return pad === 0 ? base64 : base64 + '='.repeat(4 - pad) return pad === 0 ? base64 : base64 + '='.repeat(4 - pad)
} }
function base64ToUtf8String(base64: string) { function base64ToUtf8String(base64: string) {
const binary = atob(base64) const binary = atob(base64)
const bytes = new Uint8Array(binary.length) const bytes = new Uint8Array(binary.length)
for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i) for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i)
return new TextDecoder().decode(bytes) return new TextDecoder().decode(bytes)
} }
export function decodeJwtPayload(token: string): JwtPayload | null { export function decodeJwtPayload(token: string): JwtPayload | null {
const [, payload] = token.split('.') const [, payload] = token.split('.')
if (!payload) return null if (!payload) return null
try { try {
const json = base64ToUtf8String(base64UrlToBase64(payload)) const json = base64ToUtf8String(base64UrlToBase64(payload))
const parsed = JSON.parse(json) const parsed = JSON.parse(json)
if (!parsed || typeof parsed !== 'object') return null if (!parsed || typeof parsed !== 'object') return null
return parsed as JwtPayload return parsed as JwtPayload
} catch { } catch {
return null return null
} }
} }

File diff suppressed because it is too large Load Diff

View File

@@ -1,72 +1,72 @@
<script setup lang="ts"> <script setup lang="ts">
import { reactive, ref } from 'vue' import { reactive, ref } from 'vue'
import { useRouter } from 'vue-router' import { useRouter } from 'vue-router'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as accountApi from '../api/account' import * as accountApi from '../api/account'
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const router = useRouter() const router = useRouter()
const toast = useToastStore() const toast = useToastStore()
const busy = ref(false) const busy = ref(false)
const form = reactive({ username: '', oldPassword: '', newPassword: '' }) const form = reactive({ username: '', oldPassword: '', newPassword: '' })
async function submit() { async function submit() {
if (busy.value) return if (busy.value) return
const username = form.username.trim() const username = form.username.trim()
const oldPassword = form.oldPassword.trim() const oldPassword = form.oldPassword.trim()
const newPassword = form.newPassword.trim() const newPassword = form.newPassword.trim()
if (!username || !oldPassword || !newPassword) { if (!username || !oldPassword || !newPassword) {
toast.error('请把信息填完整') toast.error('请把信息填完整')
return return
} }
busy.value = true busy.value = true
try { try {
await accountApi.changePassword(username, oldPassword, newPassword) await accountApi.changePassword(username, oldPassword, newPassword)
toast.success('密码已修改,请重新登录') toast.success('密码已修改,请重新登录')
await router.push('/account') await router.push('/account')
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(msg) toast.error(msg)
} finally { } finally {
busy.value = false busy.value = false
} }
} }
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div class="grid two"> <div class="grid two">
<div class="card"> <div class="card">
<p class="title">修改密码</p> <p class="title">修改密码</p>
<p class="subtle">不需要登录(对应后端 `/account/changePassword`)。</p> <p class="subtle">不需要登录(对应后端 `/account/changePassword`)。</p>
<div class="grid" style="margin-top: 12px"> <div class="grid" style="margin-top: 12px">
<div> <div>
<label>username</label> <label>username</label>
<input v-model.trim="form.username" autocomplete="username" /> <input v-model.trim="form.username" autocomplete="username" />
</div> </div>
<div> <div>
<label>old_password</label> <label>old_password</label>
<input v-model.trim="form.oldPassword" type="password" autocomplete="current-password" /> <input v-model.trim="form.oldPassword" type="password" autocomplete="current-password" />
</div> </div>
<div> <div>
<label>new_password</label> <label>new_password</label>
<input v-model.trim="form.newPassword" type="password" autocomplete="new-password" /> <input v-model.trim="form.newPassword" type="password" autocomplete="new-password" />
</div> </div>
<div class="row" style="justify-content: flex-end"> <div class="row" style="justify-content: flex-end">
<button class="primary" type="button" :disabled="busy" @click="submit">提交</button> <button class="primary" type="button" :disabled="busy" @click="submit">提交</button>
</div> </div>
</div> </div>
</div> </div>
<div class="card"> <div class="card">
<p class="title">提示</p> <p class="title">提示</p>
<p class="muted">改密成功后后端会让旧 token 失效;请在「账号」页重新登录。</p> <p class="muted">改密成功后后端会让旧 token 失效;请在「账号」页重新登录。</p>
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>

View File

@@ -1,262 +1,262 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, onMounted, reactive, watch } from 'vue' import { computed, onMounted, reactive, watch } from 'vue'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import JsonBox from '../components/JsonBox.vue' import JsonBox from '../components/JsonBox.vue'
import FeedVideoCard from '../components/FeedVideoCard.vue' import FeedVideoCard from '../components/FeedVideoCard.vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as feedApi from '../api/feed' import * as feedApi from '../api/feed'
import * as likeApi from '../api/like' import * as likeApi from '../api/like'
import type { FeedVideoItem } from '../api/types' import type { FeedVideoItem } from '../api/types'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
const auth = useAuthStore() const auth = useAuthStore()
type ListState = { type ListState = {
loading: boolean loading: boolean
error: string error: string
items: FeedVideoItem[] items: FeedVideoItem[]
has_more: boolean has_more: boolean
} }
const latest = reactive<ListState & { limit: number; next_time: number }>({ const latest = reactive<ListState & { limit: number; next_time: number }>({
loading: false, loading: false,
error: '', error: '',
items: [], items: [],
has_more: false, has_more: false,
limit: 10, limit: 10,
next_time: 0, next_time: 0,
}) })
const likesCount = reactive<ListState & { limit: number; next_likes_count_before?: number; next_id_before?: number }>({ const likesCount = reactive<ListState & { limit: number; next_likes_count_before?: number; next_id_before?: number }>({
loading: false, loading: false,
error: '', error: '',
items: [], items: [],
has_more: false, has_more: false,
limit: 10, limit: 10,
next_likes_count_before: undefined, next_likes_count_before: undefined,
next_id_before: undefined, next_id_before: undefined,
}) })
const following = reactive<ListState & { limit: number; next_time: number }>({ const following = reactive<ListState & { limit: number; next_time: number }>({
loading: false, loading: false,
error: '', error: '',
items: [], items: [],
has_more: false, has_more: false,
limit: 10, limit: 10,
next_time: 0, next_time: 0,
}) })
const action = reactive<{ loading: boolean; error: string; payload: unknown; name: string }>({ const action = reactive<{ loading: boolean; error: string; payload: unknown; name: string }>({
loading: false, loading: false,
error: '', error: '',
payload: null, payload: null,
name: '', name: '',
}) })
const canLike = computed(() => auth.isLoggedIn) const canLike = computed(() => auth.isLoggedIn)
async function runAction(name: string, fn: () => Promise<unknown>) { async function runAction(name: string, fn: () => Promise<unknown>) {
action.name = name action.name = name
action.loading = true action.loading = true
action.error = '' action.error = ''
action.payload = null action.payload = null
try { try {
action.payload = await fn() action.payload = await fn()
} catch (e) { } catch (e) {
action.error = e instanceof ApiError ? e.message : String(e) action.error = e instanceof ApiError ? e.message : String(e)
action.payload = e instanceof ApiError ? e.payload : null action.payload = e instanceof ApiError ? e.payload : null
} finally { } finally {
action.loading = false action.loading = false
} }
} }
async function loadLatest(reset: boolean) { async function loadLatest(reset: boolean) {
latest.loading = true latest.loading = true
latest.error = '' latest.error = ''
try { try {
const latest_time = reset ? 0 : latest.next_time const latest_time = reset ? 0 : latest.next_time
const res = await feedApi.listLatest({ limit: latest.limit, latest_time }) const res = await feedApi.listLatest({ limit: latest.limit, latest_time })
latest.has_more = res.has_more latest.has_more = res.has_more
latest.next_time = res.next_time latest.next_time = res.next_time
latest.items = reset ? res.video_list : latest.items.concat(res.video_list) latest.items = reset ? res.video_list : latest.items.concat(res.video_list)
} catch (e) { } catch (e) {
latest.error = e instanceof ApiError ? e.message : String(e) latest.error = e instanceof ApiError ? e.message : String(e)
} finally { } finally {
latest.loading = false latest.loading = false
} }
} }
async function loadLikesCount(reset: boolean) { async function loadLikesCount(reset: boolean) {
likesCount.loading = true likesCount.loading = true
likesCount.error = '' likesCount.error = ''
try { try {
const res = await feedApi.listLikesCount({ const res = await feedApi.listLikesCount({
limit: likesCount.limit, limit: likesCount.limit,
likes_count_before: reset ? undefined : likesCount.next_likes_count_before, likes_count_before: reset ? undefined : likesCount.next_likes_count_before,
id_before: reset ? undefined : likesCount.next_id_before, id_before: reset ? undefined : likesCount.next_id_before,
}) })
likesCount.has_more = res.has_more likesCount.has_more = res.has_more
likesCount.next_likes_count_before = res.next_likes_count_before likesCount.next_likes_count_before = res.next_likes_count_before
likesCount.next_id_before = res.next_id_before likesCount.next_id_before = res.next_id_before
likesCount.items = reset ? res.video_list : likesCount.items.concat(res.video_list) likesCount.items = reset ? res.video_list : likesCount.items.concat(res.video_list)
} catch (e) { } catch (e) {
likesCount.error = e instanceof ApiError ? e.message : String(e) likesCount.error = e instanceof ApiError ? e.message : String(e)
} finally { } finally {
likesCount.loading = false likesCount.loading = false
} }
} }
async function loadFollowing(reset: boolean) { async function loadFollowing(reset: boolean) {
following.loading = true following.loading = true
following.error = '' following.error = ''
try { try {
const latest_time = reset ? 0 : following.next_time const latest_time = reset ? 0 : following.next_time
const res = await feedApi.listByFollowing({ limit: following.limit, latest_time }) const res = await feedApi.listByFollowing({ limit: following.limit, latest_time })
following.has_more = res.has_more following.has_more = res.has_more
following.next_time = res.next_time following.next_time = res.next_time
following.items = reset ? res.video_list : following.items.concat(res.video_list) following.items = reset ? res.video_list : following.items.concat(res.video_list)
} catch (e) { } catch (e) {
following.error = e instanceof ApiError ? e.message : String(e) following.error = e instanceof ApiError ? e.message : String(e)
} finally { } finally {
following.loading = false following.loading = false
} }
} }
async function toggleLike(item: FeedVideoItem) { async function toggleLike(item: FeedVideoItem) {
if (!auth.isLoggedIn) return if (!auth.isLoggedIn) return
await runAction(item.is_liked ? '取消点赞' : '点赞', async () => { await runAction(item.is_liked ? '取消点赞' : '点赞', async () => {
if (item.is_liked) await likeApi.unlike(item.id) if (item.is_liked) await likeApi.unlike(item.id)
else await likeApi.like(item.id) else await likeApi.like(item.id)
item.is_liked = !item.is_liked item.is_liked = !item.is_liked
item.likes_count = Math.max(0, item.likes_count + (item.is_liked ? 1 : -1)) item.likes_count = Math.max(0, item.likes_count + (item.is_liked ? 1 : -1))
return { ok: true, is_liked: item.is_liked, likes_count: item.likes_count } return { ok: true, is_liked: item.is_liked, likes_count: item.likes_count }
}) })
} }
onMounted(async () => { onMounted(async () => {
await loadLatest(true) await loadLatest(true)
await loadLikesCount(true) await loadLikesCount(true)
if (auth.isLoggedIn) { if (auth.isLoggedIn) {
await loadFollowing(true) await loadFollowing(true)
} }
}) })
watch( watch(
() => auth.isLoggedIn, () => auth.isLoggedIn,
async (v) => { async (v) => {
if (v && following.items.length === 0) { if (v && following.items.length === 0) {
await loadFollowing(true) await loadFollowing(true)
} }
}, },
) )
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div class="grid two"> <div class="grid two">
<div class="card"> <div class="card">
<p class="title">Feed</p> <p class="title">Feed</p>
<p class="subtle">`/feed/listLatest` 与 `/feed/listLikesCount` 支持匿名(可选 JWT);`/feed/listByFollowing` 需要 JWT。</p> <p class="subtle">`/feed/listLatest` 与 `/feed/listLikesCount` 支持匿名(可选 JWT);`/feed/listByFollowing` 需要 JWT。</p>
<div class="card" style="margin-top: 12px"> <div class="card" style="margin-top: 12px">
<div class="row" style="justify-content: space-between"> <div class="row" style="justify-content: space-between">
<div> <div>
<p class="title">最新流(listLatest)</p> <p class="title">最新流(listLatest)</p>
<div class="subtle">limit:{{ latest.limit }} · next_time:{{ latest.next_time }} · has_more:{{ latest.has_more }}</div> <div class="subtle">limit:{{ latest.limit }} · next_time:{{ latest.next_time }} · has_more:{{ latest.has_more }}</div>
</div> </div>
<div class="row"> <div class="row">
<label class="subtle" style="margin: 0">limit</label> <label class="subtle" style="margin: 0">limit</label>
<input v-model.number="latest.limit" type="number" min="1" max="50" style="width: 90px" /> <input v-model.number="latest.limit" type="number" min="1" max="50" style="width: 90px" />
<button class="primary" type="button" :disabled="latest.loading" @click="loadLatest(true)">刷新</button> <button class="primary" type="button" :disabled="latest.loading" @click="loadLatest(true)">刷新</button>
<button type="button" :disabled="latest.loading || !latest.has_more" @click="loadLatest(false)">加载更多</button> <button type="button" :disabled="latest.loading || !latest.has_more" @click="loadLatest(false)">加载更多</button>
</div> </div>
</div> </div>
<div v-if="latest.error" class="pill bad" style="margin-top: 10px">错误:{{ latest.error }}</div> <div v-if="latest.error" class="pill bad" style="margin-top: 10px">错误:{{ latest.error }}</div>
<div class="grid" style="gap: 10px; margin-top: 12px"> <div class="grid" style="gap: 10px; margin-top: 12px">
<FeedVideoCard <FeedVideoCard
v-for="item in latest.items" v-for="item in latest.items"
:key="`latest-${item.id}`" :key="`latest-${item.id}`"
:item="item" :item="item"
:can-like="canLike" :can-like="canLike"
:busy="action.loading" :busy="action.loading"
@toggle-like="toggleLike" @toggle-like="toggleLike"
/> />
</div> </div>
</div> </div>
<div class="card" style="margin-top: 12px"> <div class="card" style="margin-top: 12px">
<div class="row" style="justify-content: space-between"> <div class="row" style="justify-content: space-between">
<div> <div>
<p class="title">点赞数流(listLikesCount)</p> <p class="title">点赞数流(listLikesCount)</p>
<div class="subtle"> <div class="subtle">
limit:{{ likesCount.limit }} · next=(likes={{ likesCount.next_likes_count_before }}, id={{ likesCount.next_id_before }}) limit:{{ likesCount.limit }} · next=(likes={{ likesCount.next_likes_count_before }}, id={{ likesCount.next_id_before }})
· has_more:{{ likesCount.has_more }} · has_more:{{ likesCount.has_more }}
</div> </div>
</div> </div>
<div class="row"> <div class="row">
<label class="subtle" style="margin: 0">limit</label> <label class="subtle" style="margin: 0">limit</label>
<input v-model.number="likesCount.limit" type="number" min="1" max="50" style="width: 90px" /> <input v-model.number="likesCount.limit" type="number" min="1" max="50" style="width: 90px" />
<button class="primary" type="button" :disabled="likesCount.loading" @click="loadLikesCount(true)">刷新</button> <button class="primary" type="button" :disabled="likesCount.loading" @click="loadLikesCount(true)">刷新</button>
<button type="button" :disabled="likesCount.loading || !likesCount.has_more" @click="loadLikesCount(false)"> <button type="button" :disabled="likesCount.loading || !likesCount.has_more" @click="loadLikesCount(false)">
加载更多 加载更多
</button> </button>
</div> </div>
</div> </div>
<div v-if="likesCount.error" class="pill bad" style="margin-top: 10px">错误:{{ likesCount.error }}</div> <div v-if="likesCount.error" class="pill bad" style="margin-top: 10px">错误:{{ likesCount.error }}</div>
<div class="grid" style="gap: 10px; margin-top: 12px"> <div class="grid" style="gap: 10px; margin-top: 12px">
<FeedVideoCard <FeedVideoCard
v-for="item in likesCount.items" v-for="item in likesCount.items"
:key="`likes-${item.id}`" :key="`likes-${item.id}`"
:item="item" :item="item"
:can-like="canLike" :can-like="canLike"
:busy="action.loading" :busy="action.loading"
@toggle-like="toggleLike" @toggle-like="toggleLike"
/> />
</div> </div>
</div> </div>
<div class="card" style="margin-top: 12px"> <div class="card" style="margin-top: 12px">
<div class="row" style="justify-content: space-between"> <div class="row" style="justify-content: space-between">
<div> <div>
<p class="title">关注流(listByFollowing,JWT)</p> <p class="title">关注流(listByFollowing,JWT)</p>
<div class="subtle"> <div class="subtle">
limit:{{ following.limit }} · next_time:{{ following.next_time }} · has_more:{{ following.has_more }} limit:{{ following.limit }} · next_time:{{ following.next_time }} · has_more:{{ following.has_more }}
</div> </div>
</div> </div>
<div class="row"> <div class="row">
<label class="subtle" style="margin: 0">limit</label> <label class="subtle" style="margin: 0">limit</label>
<input v-model.number="following.limit" type="number" min="1" max="50" style="width: 90px" /> <input v-model.number="following.limit" type="number" min="1" max="50" style="width: 90px" />
<button class="primary" type="button" :disabled="following.loading" @click="loadFollowing(true)">刷新</button> <button class="primary" type="button" :disabled="following.loading" @click="loadFollowing(true)">刷新</button>
<button type="button" :disabled="following.loading || !following.has_more" @click="loadFollowing(false)">加载更多</button> <button type="button" :disabled="following.loading || !following.has_more" @click="loadFollowing(false)">加载更多</button>
</div> </div>
</div> </div>
<div v-if="!auth.isLoggedIn" class="pill bad" style="margin-top: 10px">未登录:无法访问关注流</div> <div v-if="!auth.isLoggedIn" class="pill bad" style="margin-top: 10px">未登录:无法访问关注流</div>
<div v-if="following.error" class="pill bad" style="margin-top: 10px">错误:{{ following.error }}</div> <div v-if="following.error" class="pill bad" style="margin-top: 10px">错误:{{ following.error }}</div>
<div class="grid" style="gap: 10px; margin-top: 12px"> <div class="grid" style="gap: 10px; margin-top: 12px">
<FeedVideoCard <FeedVideoCard
v-for="item in following.items" v-for="item in following.items"
:key="`following-${item.id}`" :key="`following-${item.id}`"
:item="item" :item="item"
:can-like="canLike" :can-like="canLike"
:busy="action.loading" :busy="action.loading"
@toggle-like="toggleLike" @toggle-like="toggleLike"
/> />
</div> </div>
</div> </div>
</div> </div>
<div class="card"> <div class="card">
<p class="title">动作输出(点赞等)</p> <p class="title">动作输出(点赞等)</p>
<div class="row" style="margin-bottom: 10px"> <div class="row" style="margin-bottom: 10px">
<span class="pill">动作:{{ action.name || '-' }}</span> <span class="pill">动作:{{ action.name || '-' }}</span>
<span v-if="action.loading" class="pill">请求中…</span> <span v-if="action.loading" class="pill">请求中…</span>
<span v-if="action.error" class="pill bad">错误:{{ action.error }}</span> <span v-if="action.error" class="pill bad">错误:{{ action.error }}</span>
</div> </div>
<JsonBox :value="action.payload" /> <JsonBox :value="action.payload" />
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>

View File

@@ -1,157 +1,157 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, onMounted, reactive } from 'vue' import { computed, onMounted, reactive } from 'vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as feedApi from '../api/feed' import * as feedApi from '../api/feed'
import * as likeApi from '../api/like' import * as likeApi from '../api/like'
import type { FeedVideoItem } from '../api/types' import type { FeedVideoItem } from '../api/types'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import FeedVideoCard from '../components/FeedVideoCard.vue' import FeedVideoCard from '../components/FeedVideoCard.vue'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const auth = useAuthStore() const auth = useAuthStore()
const toast = useToastStore() const toast = useToastStore()
const canLike = computed(() => auth.isLoggedIn) const canLike = computed(() => auth.isLoggedIn)
const state = reactive({ const state = reactive({
loading: false, loading: false,
error: '', error: '',
items: [] as FeedVideoItem[], items: [] as FeedVideoItem[],
hasMore: false, hasMore: false,
limit: 10, limit: 10,
asOf: 0, asOf: 0,
nextOffset: 0, nextOffset: 0,
}) })
const likeBusy = reactive<Record<string, boolean>>({}) const likeBusy = reactive<Record<string, boolean>>({})
async function loadHot(reset: boolean) { async function loadHot(reset: boolean) {
if (state.loading) return if (state.loading) return
state.loading = true state.loading = true
state.error = '' state.error = ''
try { try {
const res = await feedApi.listByPopularity({ const res = await feedApi.listByPopularity({
limit: state.limit, limit: state.limit,
as_of: reset ? 0 : state.asOf, as_of: reset ? 0 : state.asOf,
offset: reset ? 0 : state.nextOffset, offset: reset ? 0 : state.nextOffset,
}) })
state.hasMore = res.has_more state.hasMore = res.has_more
state.asOf = res.as_of state.asOf = res.as_of
state.nextOffset = res.next_offset state.nextOffset = res.next_offset
state.items = reset ? res.video_list : state.items.concat(res.video_list) state.items = reset ? res.video_list : state.items.concat(res.video_list)
} catch (e) { } catch (e) {
state.error = e instanceof ApiError ? e.message : String(e) state.error = e instanceof ApiError ? e.message : String(e)
} finally { } finally {
state.loading = false state.loading = false
} }
} }
async function toggleLike(item: FeedVideoItem) { async function toggleLike(item: FeedVideoItem) {
if (!auth.isLoggedIn) { if (!auth.isLoggedIn) {
toast.error('请先登录') toast.error('请先登录')
return return
} }
const key = String(item.id) const key = String(item.id)
if (likeBusy[key]) return if (likeBusy[key]) return
likeBusy[key] = true likeBusy[key] = true
try { try {
if (item.is_liked) await likeApi.unlike(item.id) if (item.is_liked) await likeApi.unlike(item.id)
else await likeApi.like(item.id) else await likeApi.like(item.id)
item.is_liked = !item.is_liked item.is_liked = !item.is_liked
item.likes_count = Math.max(0, item.likes_count + (item.is_liked ? 1 : -1)) item.likes_count = Math.max(0, item.likes_count + (item.is_liked ? 1 : -1))
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(msg) toast.error(msg)
} finally { } finally {
likeBusy[key] = false likeBusy[key] = false
} }
} }
onMounted(async () => { onMounted(async () => {
await loadHot(true) await loadHot(true)
}) })
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div class="card"> <div class="card">
<div class="row" style="justify-content: space-between; align-items: baseline"> <div class="row" style="justify-content: space-between; align-items: baseline">
<div> <div>
<p class="title" style="margin: 0">热榜</p> <p class="title" style="margin: 0">热榜</p>
<p class="subtle" style="margin: 6px 0 0">按热度排序(/feed/listByPopularity)</p> <p class="subtle" style="margin: 6px 0 0">按热度排序(/feed/listByPopularity)</p>
</div> </div>
<div class="row"> <div class="row">
<label class="subtle" style="margin: 0">limit</label> <label class="subtle" style="margin: 0">limit</label>
<input v-model.number="state.limit" type="number" min="1" max="50" style="width: 90px" :disabled="state.loading" /> <input v-model.number="state.limit" type="number" min="1" max="50" style="width: 90px" :disabled="state.loading" />
<button class="primary" type="button" :disabled="state.loading" @click="loadHot(true)">刷新</button> <button class="primary" type="button" :disabled="state.loading" @click="loadHot(true)">刷新</button>
<button type="button" :disabled="state.loading || !state.hasMore" @click="loadHot(false)">加载更多</button> <button type="button" :disabled="state.loading || !state.hasMore" @click="loadHot(false)">加载更多</button>
</div> </div>
</div> </div>
<div v-if="state.error" class="pill bad" style="margin-top: 12px">错误:{{ state.error }}</div> <div v-if="state.error" class="pill bad" style="margin-top: 12px">错误:{{ state.error }}</div>
<div v-else-if="state.loading && state.items.length === 0" class="subtle" style="margin-top: 12px">加载中…</div> <div v-else-if="state.loading && state.items.length === 0" class="subtle" style="margin-top: 12px">加载中…</div>
<div v-else-if="state.items.length === 0" class="subtle" style="margin-top: 12px">暂无内容</div> <div v-else-if="state.items.length === 0" class="subtle" style="margin-top: 12px">暂无内容</div>
<div v-if="state.items.length" class="rank-list" style="margin-top: 14px"> <div v-if="state.items.length" class="rank-list" style="margin-top: 14px">
<div v-for="(item, idx) in state.items" :key="`hot-${item.id}`" class="rank-row"> <div v-for="(item, idx) in state.items" :key="`hot-${item.id}`" class="rank-row">
<div class="rank-num" :class="idx < 3 ? 'top' : ''">{{ idx + 1 }}</div> <div class="rank-num" :class="idx < 3 ? 'top' : ''">{{ idx + 1 }}</div>
<FeedVideoCard <FeedVideoCard
:item="item" :item="item"
:can-like="canLike" :can-like="canLike"
:busy="!!likeBusy[String(item.id)]" :busy="!!likeBusy[String(item.id)]"
@toggle-like="toggleLike" @toggle-like="toggleLike"
/> />
</div> </div>
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>
<style scoped> <style scoped>
.rank-list { .rank-list {
display: grid; display: grid;
gap: 12px; gap: 12px;
} }
.rank-row { .rank-row {
display: grid; display: grid;
grid-template-columns: 44px minmax(0, 1fr); grid-template-columns: 44px minmax(0, 1fr);
gap: 12px; gap: 12px;
align-items: start; align-items: start;
} }
.rank-num { .rank-num {
height: 44px; height: 44px;
width: 44px; width: 44px;
border-radius: 16px; border-radius: 16px;
display: grid; display: grid;
place-items: center; place-items: center;
font-weight: 900; font-weight: 900;
letter-spacing: 0.2px; letter-spacing: 0.2px;
border: 1px solid rgba(255, 255, 255, 0.12); border: 1px solid rgba(255, 255, 255, 0.12);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
color: rgba(255, 255, 255, 0.86); color: rgba(255, 255, 255, 0.86);
user-select: none; user-select: none;
} }
.rank-num.top { .rank-num.top {
border-color: rgba(254, 44, 85, 0.55); border-color: rgba(254, 44, 85, 0.55);
background: rgba(254, 44, 85, 0.18); background: rgba(254, 44, 85, 0.18);
color: rgba(255, 255, 255, 0.96); color: rgba(255, 255, 255, 0.96);
} }
@media (max-width: 900px) { @media (max-width: 900px) {
.rank-row { .rank-row {
grid-template-columns: 38px minmax(0, 1fr); grid-template-columns: 38px minmax(0, 1fr);
gap: 10px; gap: 10px;
} }
.rank-num { .rank-num {
height: 38px; height: 38px;
width: 38px; width: 38px;
border-radius: 14px; border-radius: 14px;
} }
} }
</style> </style>

View File

@@ -1,67 +1,67 @@
<script setup lang="ts"> <script setup lang="ts">
import { reactive, ref } from 'vue' import { reactive, ref } from 'vue'
import { useRouter } from 'vue-router' import { useRouter } from 'vue-router'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as accountApi from '../api/account' import * as accountApi from '../api/account'
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const router = useRouter() const router = useRouter()
const toast = useToastStore() const toast = useToastStore()
const busy = ref(false) const busy = ref(false)
const form = reactive({ username: '', password: '' }) const form = reactive({ username: '', password: '' })
async function submit() { async function submit() {
if (busy.value) return if (busy.value) return
const username = form.username.trim() const username = form.username.trim()
const password = form.password.trim() const password = form.password.trim()
if (!username || !password) { if (!username || !password) {
toast.error('请输入 username 和 password') toast.error('请输入 username 和 password')
return return
} }
busy.value = true busy.value = true
try { try {
await accountApi.register(username, password) await accountApi.register(username, password)
toast.success('注册成功,请登录') toast.success('注册成功,请登录')
await router.push('/account') await router.push('/account')
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(msg) toast.error(msg)
} finally { } finally {
busy.value = false busy.value = false
} }
} }
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div class="grid two"> <div class="grid two">
<div class="card"> <div class="card">
<p class="title">注册</p> <p class="title">注册</p>
<p class="subtle">创建新账号(对应后端 `/account/register`)。</p> <p class="subtle">创建新账号(对应后端 `/account/register`)。</p>
<div class="grid" style="margin-top: 12px"> <div class="grid" style="margin-top: 12px">
<div> <div>
<label>username</label> <label>username</label>
<input v-model.trim="form.username" autocomplete="username" /> <input v-model.trim="form.username" autocomplete="username" />
</div> </div>
<div> <div>
<label>password</label> <label>password</label>
<input v-model.trim="form.password" type="password" autocomplete="new-password" /> <input v-model.trim="form.password" type="password" autocomplete="new-password" />
</div> </div>
<div class="row" style="justify-content: flex-end"> <div class="row" style="justify-content: flex-end">
<button class="primary" type="button" :disabled="busy" @click="submit">注册</button> <button class="primary" type="button" :disabled="busy" @click="submit">注册</button>
</div> </div>
</div> </div>
</div> </div>
<div class="card"> <div class="card">
<p class="title">提示</p> <p class="title">提示</p>
<p class="muted">注册成功后会跳回「账号」页进行登录。</p> <p class="muted">注册成功后会跳回「账号」页进行登录。</p>
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>

View File

@@ -1,168 +1,168 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, nextTick, reactive, ref } from 'vue' import { computed, nextTick, reactive, ref } from 'vue'
import { useRouter } from 'vue-router' import { useRouter } from 'vue-router'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import UserAvatar from '../components/UserAvatar.vue' import UserAvatar from '../components/UserAvatar.vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as accountApi from '../api/account' import * as accountApi from '../api/account'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const router = useRouter() const router = useRouter()
const auth = useAuthStore() const auth = useAuthStore()
const toast = useToastStore() const toast = useToastStore()
const busy = ref(false) const busy = ref(false)
const me = computed(() => ({ const me = computed(() => ({
id: auth.claims?.account_id ?? 0, id: auth.claims?.account_id ?? 0,
username: auth.claims?.username ?? '', username: auth.claims?.username ?? '',
})) }))
const rename = reactive({ const rename = reactive({
open: false, open: false,
newUsername: '', newUsername: '',
}) })
async function openRename() { async function openRename() {
if (!auth.isLoggedIn) return if (!auth.isLoggedIn) return
rename.open = true rename.open = true
rename.newUsername = me.value.username rename.newUsername = me.value.username
await nextTick() await nextTick()
} }
async function submitRename() { async function submitRename() {
if (!auth.isLoggedIn) return if (!auth.isLoggedIn) return
if (busy.value) return if (busy.value) return
const newUsername = rename.newUsername.trim() const newUsername = rename.newUsername.trim()
if (!newUsername) { if (!newUsername) {
toast.error('请输入新用户名') toast.error('请输入新用户名')
return return
} }
busy.value = true busy.value = true
try { try {
const res = await accountApi.rename(newUsername) const res = await accountApi.rename(newUsername)
auth.setToken(res.token) auth.setToken(res.token)
rename.open = false rename.open = false
toast.success('改名成功(已刷新 token)') toast.success('改名成功(已刷新 token)')
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(msg) toast.error(msg)
} finally { } finally {
busy.value = false busy.value = false
} }
} }
async function goLogin() { async function goLogin() {
await router.push('/account') await router.push('/account')
} }
async function goChangePassword() { async function goChangePassword() {
await router.push('/account/change-password') await router.push('/account/change-password')
} }
async function onLogout() { async function onLogout() {
if (!auth.isLoggedIn) return if (!auth.isLoggedIn) return
if (busy.value) return if (busy.value) return
if (!window.confirm('确认退出登录?')) return if (!window.confirm('确认退出登录?')) return
busy.value = true busy.value = true
try { try {
await accountApi.logout() await accountApi.logout()
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(`登出失败:${msg}`) toast.error(`登出失败:${msg}`)
} finally { } finally {
auth.clearTokens() auth.clearTokens()
rename.open = false rename.open = false
toast.info('已退出登录') toast.info('已退出登录')
busy.value = false busy.value = false
await router.push('/') await router.push('/')
} }
} }
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div v-if="!auth.isLoggedIn" class="grid two"> <div v-if="!auth.isLoggedIn" class="grid two">
<div class="card"> <div class="card">
<p class="title">设置</p> <p class="title">设置</p>
<p class="subtle">需要先登录后才能进行改名/退出等操作。</p> <p class="subtle">需要先登录后才能进行改名/退出等操作。</p>
<div class="row" style="margin-top: 12px; justify-content: flex-end"> <div class="row" style="margin-top: 12px; justify-content: flex-end">
<button class="primary" type="button" @click="goLogin">去登录</button> <button class="primary" type="button" @click="goLogin">去登录</button>
</div> </div>
</div> </div>
<div class="card"> <div class="card">
<p class="title">提示</p> <p class="title">提示</p>
<p class="muted">登录入口在「账号」页。</p> <p class="muted">登录入口在「账号」页。</p>
</div> </div>
</div> </div>
<div v-else class="grid two"> <div v-else class="grid two">
<div class="card"> <div class="card">
<div class="row" style="justify-content: space-between; align-items: flex-start"> <div class="row" style="justify-content: space-between; align-items: flex-start">
<div class="row" style="gap: 12px; align-items: center"> <div class="row" style="gap: 12px; align-items: center">
<UserAvatar :username="me.username" :id="me.id" :size="56" /> <UserAvatar :username="me.username" :id="me.id" :size="56" />
<div> <div>
<div class="title" style="margin: 0">@{{ me.username }}</div> <div class="title" style="margin: 0">@{{ me.username }}</div>
<div class="subtle mono">#{{ me.id }}</div> <div class="subtle mono">#{{ me.id }}</div>
</div> </div>
</div> </div>
</div> </div>
<div class="card" style="margin-top: 14px"> <div class="card" style="margin-top: 14px">
<div class="row" style="justify-content: space-between; align-items: center"> <div class="row" style="justify-content: space-between; align-items: center">
<p class="title" style="margin: 0">账号设置</p> <p class="title" style="margin: 0">账号设置</p>
<button class="ghost" type="button" :disabled="busy" @click="openRename">改名</button> <button class="ghost" type="button" :disabled="busy" @click="openRename">改名</button>
</div> </div>
<div v-if="rename.open" class="grid" style="margin-top: 12px"> <div v-if="rename.open" class="grid" style="margin-top: 12px">
<div> <div>
<label>new_username</label> <label>new_username</label>
<input v-model.trim="rename.newUsername" @keydown.enter="submitRename" /> <input v-model.trim="rename.newUsername" @keydown.enter="submitRename" />
</div> </div>
<div class="row" style="justify-content: flex-end"> <div class="row" style="justify-content: flex-end">
<button type="button" :disabled="busy" @click="rename.open = false">取消</button> <button type="button" :disabled="busy" @click="rename.open = false">取消</button>
<button class="primary" type="button" :disabled="busy" @click="submitRename">提交</button> <button class="primary" type="button" :disabled="busy" @click="submitRename">提交</button>
</div> </div>
</div> </div>
</div> </div>
<div class="card" style="margin-top: 14px"> <div class="card" style="margin-top: 14px">
<p class="title">账号安全</p> <p class="title">账号安全</p>
<div class="row"> <div class="row">
<button class="ghost" type="button" :disabled="busy" @click="goChangePassword">修改密码</button> <button class="ghost" type="button" :disabled="busy" @click="goChangePassword">修改密码</button>
<button class="danger" type="button" :disabled="busy" @click="onLogout">退出登录</button> <button class="danger" type="button" :disabled="busy" @click="onLogout">退出登录</button>
</div> </div>
</div> </div>
</div> </div>
<div class="card"> <div class="card">
<p class="title">说明</p> <p class="title">说明</p>
<div class="grid" style="margin-top: 10px"> <div class="grid" style="margin-top: 10px">
<div class="pill ok">改名后会返回新 token,旧 token 立即失效</div> <div class="pill ok">改名后会返回新 token,旧 token 立即失效</div>
<div class="pill ok">退出登录会清空本地 token</div> <div class="pill ok">退出登录会清空本地 token</div>
<div class="pill">修改密码无需登录,但成功后会让旧 token 失效</div> <div class="pill">修改密码无需登录,但成功后会让旧 token 失效</div>
</div> </div>
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>
<style scoped> <style scoped>
.ghost { .ghost {
border: 1px solid rgba(255, 255, 255, 0.14); border: 1px solid rgba(255, 255, 255, 0.14);
background: rgba(0, 0, 0, 0.18); background: rgba(0, 0, 0, 0.18);
color: rgba(255, 255, 255, 0.86); color: rgba(255, 255, 255, 0.86);
border-radius: 12px; border-radius: 12px;
padding: 10px 12px; padding: 10px 12px;
cursor: pointer; cursor: pointer;
} }
.ghost:hover { .ghost:hover {
background: rgba(255, 255, 255, 0.1); background: rgba(255, 255, 255, 0.1);
} }
</style> </style>

View File

@@ -1,107 +1,107 @@
<script setup lang="ts"> <script setup lang="ts">
import { computed, onMounted, reactive, watch } from 'vue' import { computed, onMounted, reactive, watch } from 'vue'
import { useRoute, useRouter } from 'vue-router' import { useRoute, useRouter } from 'vue-router'
import AppShell from '../components/AppShell.vue' import AppShell from '../components/AppShell.vue'
import UserAvatar from '../components/UserAvatar.vue' import UserAvatar from '../components/UserAvatar.vue'
import { ApiError } from '../api/client' import { ApiError } from '../api/client'
import * as accountApi from '../api/account' import * as accountApi from '../api/account'
import * as socialApi from '../api/social' import * as socialApi from '../api/social'
import type { Account, Video } from '../api/types' import type { Account, Video } from '../api/types'
import * as videoApi from '../api/video' import * as videoApi from '../api/video'
import { useAuthStore } from '../stores/auth' import { useAuthStore } from '../stores/auth'
import { useSocialStore } from '../stores/social' import { useSocialStore } from '../stores/social'
import { useToastStore } from '../stores/toast' import { useToastStore } from '../stores/toast'
const route = useRoute() const route = useRoute()
const router = useRouter() const router = useRouter()
const auth = useAuthStore() const auth = useAuthStore()
const social = useSocialStore() const social = useSocialStore()
const toast = useToastStore() const toast = useToastStore()
const userId = computed(() => Number(route.params.id)) const userId = computed(() => Number(route.params.id))
const myId = computed(() => auth.claims?.account_id ?? 0) const myId = computed(() => auth.claims?.account_id ?? 0)
const isMe = computed(() => myId.value > 0 && myId.value === userId.value) const isMe = computed(() => myId.value > 0 && myId.value === userId.value)
const state = reactive({ const state = reactive({
loading: false, loading: false,
error: '', error: '',
user: null as Account | null, user: null as Account | null,
videos: [] as Video[], videos: [] as Video[],
followers: [] as Account[], followers: [] as Account[],
vloggers: [] as Account[], vloggers: [] as Account[],
socialLoading: false, socialLoading: false,
socialError: '', socialError: '',
}) })
const isFollowing = computed(() => (auth.isLoggedIn ? social.isFollowing(userId.value) : false)) const isFollowing = computed(() => (auth.isLoggedIn ? social.isFollowing(userId.value) : false))
async function loadProfile() { async function loadProfile() {
if (!Number.isFinite(userId.value) || userId.value <= 0) { if (!Number.isFinite(userId.value) || userId.value <= 0) {
state.error = '无效的用户 id' state.error = '无效的用户 id'
return return
} }
state.loading = true state.loading = true
state.error = '' state.error = ''
try { try {
const [u, vids] = await Promise.all([accountApi.findById(userId.value), videoApi.listByAuthorId(userId.value)]) const [u, vids] = await Promise.all([accountApi.findById(userId.value), videoApi.listByAuthorId(userId.value)])
state.user = u state.user = u
state.videos = vids state.videos = vids
} catch (e) { } catch (e) {
state.error = e instanceof ApiError ? e.message : String(e) state.error = e instanceof ApiError ? e.message : String(e)
state.user = null state.user = null
state.videos = [] state.videos = []
} finally { } finally {
state.loading = false state.loading = false
} }
await loadSocialCounts() await loadSocialCounts()
} }
async function loadSocialCounts() { async function loadSocialCounts() {
state.socialError = '' state.socialError = ''
state.followers = [] state.followers = []
state.vloggers = [] state.vloggers = []
if (!auth.isLoggedIn) return if (!auth.isLoggedIn) return
if (!Number.isFinite(userId.value) || userId.value <= 0) return if (!Number.isFinite(userId.value) || userId.value <= 0) return
state.socialLoading = true state.socialLoading = true
try { try {
const [followersRes, vloggersRes] = await Promise.all([ const [followersRes, vloggersRes] = await Promise.all([
socialApi.getAllFollowers(userId.value), socialApi.getAllFollowers(userId.value),
socialApi.getAllVloggers(userId.value), socialApi.getAllVloggers(userId.value),
]) ])
state.followers = followersRes.followers state.followers = followersRes.followers
state.vloggers = vloggersRes.vloggers state.vloggers = vloggersRes.vloggers
} catch (e) { } catch (e) {
state.socialError = e instanceof ApiError ? e.message : String(e) state.socialError = e instanceof ApiError ? e.message : String(e)
} finally { } finally {
state.socialLoading = false state.socialLoading = false
} }
} }
async function toggleFollow() { async function toggleFollow() {
if (isMe.value) return if (isMe.value) return
if (!auth.isLoggedIn) { if (!auth.isLoggedIn) {
toast.error('请先登录') toast.error('请先登录')
await router.push('/account') await router.push('/account')
return return
} }
try { try {
if (isFollowing.value) { if (isFollowing.value) {
await social.unfollow(userId.value) await social.unfollow(userId.value)
toast.info('已取关') toast.info('已取关')
} else { } else {
await social.follow(userId.value) await social.follow(userId.value)
toast.success('已关注') toast.success('已关注')
} }
await loadSocialCounts() await loadSocialCounts()
} catch (e) { } catch (e) {
const msg = e instanceof ApiError ? e.message : String(e) const msg = e instanceof ApiError ? e.message : String(e)
toast.error(msg) toast.error(msg)
} }
} }
@@ -114,69 +114,69 @@ async function goMessage() {
} }
await router.push(`/messages/${userId.value}`) await router.push(`/messages/${userId.value}`)
} }
type ListTab = 'followers' | 'following' type ListTab = 'followers' | 'following'
const drawer = reactive({ const drawer = reactive({
open: false, open: false,
tab: 'followers' as ListTab, tab: 'followers' as ListTab,
}) })
function openFollowers() { function openFollowers() {
drawer.tab = 'followers' drawer.tab = 'followers'
drawer.open = true drawer.open = true
} }
function openFollowing() { function openFollowing() {
drawer.tab = 'following' drawer.tab = 'following'
drawer.open = true drawer.open = true
} }
function closeDrawer() { function closeDrawer() {
drawer.open = false drawer.open = false
} }
const listTitle = computed(() => (drawer.tab === 'followers' ? '粉丝' : '关注')) const listTitle = computed(() => (drawer.tab === 'followers' ? '粉丝' : '关注'))
const listItems = computed(() => (drawer.tab === 'followers' ? state.followers : state.vloggers)) const listItems = computed(() => (drawer.tab === 'followers' ? state.followers : state.vloggers))
async function goUser(id: number) { async function goUser(id: number) {
drawer.open = false drawer.open = false
await router.push(`/u/${id}`) await router.push(`/u/${id}`)
} }
async function goVideo(videoId: number) { async function goVideo(videoId: number) {
await router.push(`/video/${videoId}`) await router.push(`/video/${videoId}`)
} }
watch( watch(
() => route.params.id, () => route.params.id,
async () => { async () => {
drawer.open = false drawer.open = false
await loadProfile() await loadProfile()
}, },
) )
watch( watch(
() => auth.isLoggedIn, () => auth.isLoggedIn,
async () => { async () => {
await loadSocialCounts() await loadSocialCounts()
}, },
) )
onMounted(loadProfile) onMounted(loadProfile)
</script> </script>
<template> <template>
<AppShell> <AppShell>
<div class="card"> <div class="card">
<div class="row" style="justify-content: space-between; align-items: flex-start"> <div class="row" style="justify-content: space-between; align-items: flex-start">
<div class="row" style="gap: 12px; align-items: center"> <div class="row" style="gap: 12px; align-items: center">
<UserAvatar :username="state.user?.username ?? 'User'" :id="state.user?.id ?? userId" :size="64" /> <UserAvatar :username="state.user?.username ?? 'User'" :id="state.user?.id ?? userId" :size="64" />
<div> <div>
<div class="title" style="margin: 0">@{{ state.user?.username ?? '-' }}</div> <div class="title" style="margin: 0">@{{ state.user?.username ?? '-' }}</div>
<div class="subtle mono">#{{ state.user?.id ?? userId }}</div> <div class="subtle mono">#{{ state.user?.id ?? userId }}</div>
</div> </div>
</div> </div>
<div class="row"> <div class="row">
<button v-if="isMe" class="ghost" type="button" @click="router.push('/account')">我的账号</button> <button v-if="isMe" class="ghost" type="button" @click="router.push('/account')">我的账号</button>
<template v-else> <template v-else>
@@ -187,72 +187,72 @@ onMounted(loadProfile)
</template> </template>
</div> </div>
</div> </div>
<div v-if="state.loading" class="hint" style="margin-top: 12px">加载中…</div> <div v-if="state.loading" class="hint" style="margin-top: 12px">加载中…</div>
<div v-else-if="state.error" class="hint bad" style="margin-top: 12px">{{ state.error }}</div> <div v-else-if="state.error" class="hint bad" style="margin-top: 12px">{{ state.error }}</div>
<div v-else class="row" style="margin-top: 14px"> <div v-else class="row" style="margin-top: 14px">
<button class="metric" type="button" :disabled="!auth.isLoggedIn || state.socialLoading" @click="openFollowers"> <button class="metric" type="button" :disabled="!auth.isLoggedIn || state.socialLoading" @click="openFollowers">
<div class="metric-num">{{ auth.isLoggedIn ? (state.socialLoading ? '…' : state.followers.length) : '—' }}</div> <div class="metric-num">{{ auth.isLoggedIn ? (state.socialLoading ? '…' : state.followers.length) : '—' }}</div>
<div class="metric-label">粉丝</div> <div class="metric-label">粉丝</div>
</button> </button>
<button class="metric" type="button" :disabled="!auth.isLoggedIn || state.socialLoading" @click="openFollowing"> <button class="metric" type="button" :disabled="!auth.isLoggedIn || state.socialLoading" @click="openFollowing">
<div class="metric-num">{{ auth.isLoggedIn ? (state.socialLoading ? '…' : state.vloggers.length) : '—' }}</div> <div class="metric-num">{{ auth.isLoggedIn ? (state.socialLoading ? '…' : state.vloggers.length) : '—' }}</div>
<div class="metric-label">关注</div> <div class="metric-label">关注</div>
</button> </button>
<div class="metric static"> <div class="metric static">
<div class="metric-num">{{ state.videos.length }}</div> <div class="metric-num">{{ state.videos.length }}</div>
<div class="metric-label">作品</div> <div class="metric-label">作品</div>
</div> </div>
<div v-if="!auth.isLoggedIn" class="subtle" style="margin-left: 8px">登录后可查看粉丝/关注列表</div> <div v-if="!auth.isLoggedIn" class="subtle" style="margin-left: 8px">登录后可查看粉丝/关注列表</div>
<div v-else-if="state.socialError" class="subtle" style="margin-left: 8px">社交信息加载失败:{{ state.socialError }}</div> <div v-else-if="state.socialError" class="subtle" style="margin-left: 8px">社交信息加载失败:{{ state.socialError }}</div>
</div> </div>
</div> </div>
<div class="card" style="margin-top: 14px"> <div class="card" style="margin-top: 14px">
<div class="row" style="justify-content: space-between"> <div class="row" style="justify-content: space-between">
<p class="title" style="margin: 0">作品</p> <p class="title" style="margin: 0">作品</p>
<div class="subtle">点击封面进入播放页</div> <div class="subtle">点击封面进入播放页</div>
</div> </div>
<div v-if="state.videos.length === 0" class="hint" style="margin-top: 12px">暂无作品</div> <div v-if="state.videos.length === 0" class="hint" style="margin-top: 12px">暂无作品</div>
<div v-else class="video-grid" style="margin-top: 12px"> <div v-else class="video-grid" style="margin-top: 12px">
<button v-for="v in state.videos" :key="v.id" class="video-card" type="button" @click="goVideo(v.id)"> <button v-for="v in state.videos" :key="v.id" class="video-card" type="button" @click="goVideo(v.id)">
<img class="video-cover" :src="v.cover_url" :alt="v.title" loading="lazy" /> <img class="video-cover" :src="v.cover_url" :alt="v.title" loading="lazy" />
<div class="video-meta"> <div class="video-meta">
<div class="video-title">{{ v.title }}</div> <div class="video-title">{{ v.title }}</div>
<div class="video-sub subtle">❤️ {{ v.likes_count }} · {{ new Date(v.create_time).toLocaleDateString() }}</div> <div class="video-sub subtle">❤️ {{ v.likes_count }} · {{ new Date(v.create_time).toLocaleDateString() }}</div>
</div> </div>
</button> </button>
</div> </div>
</div> </div>
<div v-if="drawer.open" class="drawer-backdrop" @click.self="closeDrawer"> <div v-if="drawer.open" class="drawer-backdrop" @click.self="closeDrawer">
<div class="drawer"> <div class="drawer">
<div class="drawer-head"> <div class="drawer-head">
<div class="drawer-title">{{ listTitle }}</div> <div class="drawer-title">{{ listTitle }}</div>
<button class="drawer-x" type="button" @click="closeDrawer">×</button> <button class="drawer-x" type="button" @click="closeDrawer">×</button>
</div> </div>
<div class="drawer-body"> <div class="drawer-body">
<div v-if="state.socialLoading" class="drawer-hint">加载中…</div> <div v-if="state.socialLoading" class="drawer-hint">加载中…</div>
<div v-else-if="state.socialError" class="drawer-hint bad">{{ state.socialError }}</div> <div v-else-if="state.socialError" class="drawer-hint bad">{{ state.socialError }}</div>
<div v-else-if="listItems.length === 0" class="drawer-hint">暂无</div> <div v-else-if="listItems.length === 0" class="drawer-hint">暂无</div>
<button v-for="u in listItems" :key="u.id" class="user-row" type="button" @click="goUser(u.id)"> <button v-for="u in listItems" :key="u.id" class="user-row" type="button" @click="goUser(u.id)">
<UserAvatar :username="u.username" :id="u.id" :size="40" /> <UserAvatar :username="u.username" :id="u.id" :size="40" />
<div class="user-meta"> <div class="user-meta">
<div class="user-name">@{{ u.username }}</div> <div class="user-name">@{{ u.username }}</div>
<div class="user-id mono">#{{ u.id }}</div> <div class="user-id mono">#{{ u.id }}</div>
</div> </div>
</button> </button>
</div> </div>
</div> </div>
</div> </div>
</AppShell> </AppShell>
</template> </template>
<style scoped> <style scoped>
.ghost { .ghost {
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.055); background: rgba(255, 255, 255, 0.055);
@@ -261,42 +261,42 @@ onMounted(loadProfile)
padding: 10px 12px; padding: 10px 12px;
cursor: pointer; cursor: pointer;
} }
.ghost:hover { .ghost:hover {
background: rgba(255, 255, 255, 0.1); background: rgba(255, 255, 255, 0.1);
} }
.metric { .metric {
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
border-radius: 8px; border-radius: 8px;
padding: 12px 14px; padding: 12px 14px;
min-width: 120px; min-width: 120px;
cursor: pointer; cursor: pointer;
display: grid; display: grid;
gap: 4px; gap: 4px;
text-align: left; text-align: left;
} }
.metric.static { .metric.static {
cursor: default; cursor: default;
} }
.metric:hover { .metric:hover {
background: rgba(255, 255, 255, 0.1); background: rgba(255, 255, 255, 0.1);
} }
.metric:disabled { .metric:disabled {
opacity: 0.55; opacity: 0.55;
cursor: not-allowed; cursor: not-allowed;
} }
.metric-num { .metric-num {
font-size: 18px; font-size: 18px;
font-weight: 900; font-weight: 900;
letter-spacing: 0.2px; letter-spacing: 0.2px;
} }
.metric-label { .metric-label {
font-size: 12px; font-size: 12px;
color: var(--muted); color: var(--muted);
@@ -309,160 +309,160 @@ onMounted(loadProfile)
.hint.bad { .hint.bad {
color: var(--danger); color: var(--danger);
} }
.video-grid { .video-grid {
display: grid; display: grid;
grid-template-columns: repeat(4, minmax(0, 1fr)); grid-template-columns: repeat(4, minmax(0, 1fr));
gap: 12px; gap: 12px;
} }
@media (max-width: 1100px) { @media (max-width: 1100px) {
.video-grid { .video-grid {
grid-template-columns: repeat(3, minmax(0, 1fr)); grid-template-columns: repeat(3, minmax(0, 1fr));
} }
} }
@media (max-width: 800px) { @media (max-width: 800px) {
.video-grid { .video-grid {
grid-template-columns: repeat(2, minmax(0, 1fr)); grid-template-columns: repeat(2, minmax(0, 1fr));
} }
} }
.video-card { .video-card {
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.05); background: rgba(255, 255, 255, 0.05);
border-radius: 8px; border-radius: 8px;
overflow: hidden; overflow: hidden;
cursor: pointer; cursor: pointer;
padding: 0; padding: 0;
text-align: left; text-align: left;
} }
.video-card:hover { .video-card:hover {
background: rgba(255, 255, 255, 0.08); background: rgba(255, 255, 255, 0.08);
} }
.video-cover { .video-cover {
width: 100%; width: 100%;
aspect-ratio: 9/12; aspect-ratio: 9/12;
object-fit: cover; object-fit: cover;
display: block; display: block;
background: rgba(0, 0, 0, 0.35); background: rgba(0, 0, 0, 0.35);
} }
.video-meta { .video-meta {
padding: 10px 10px; padding: 10px 10px;
} }
.video-title { .video-title {
font-weight: 800; font-weight: 800;
font-size: 13px; font-size: 13px;
overflow: hidden; overflow: hidden;
display: -webkit-box; display: -webkit-box;
-webkit-line-clamp: 2; -webkit-line-clamp: 2;
-webkit-box-orient: vertical; -webkit-box-orient: vertical;
} }
.video-sub { .video-sub {
margin-top: 6px; margin-top: 6px;
font-size: 12px; font-size: 12px;
} }
.drawer-backdrop { .drawer-backdrop {
position: fixed; position: fixed;
inset: 0; inset: 0;
background: rgba(0, 0, 0, 0.55); background: rgba(0, 0, 0, 0.55);
backdrop-filter: blur(10px); backdrop-filter: blur(10px);
z-index: 120; z-index: 120;
display: grid; display: grid;
justify-items: center; justify-items: center;
align-items: center; align-items: center;
padding: 16px; padding: 16px;
} }
.drawer { .drawer {
width: min(520px, calc(100vw - 18px)); width: min(520px, calc(100vw - 18px));
max-height: min(78vh, 720px); max-height: min(78vh, 720px);
background: rgba(13, 18, 29, 0.92); background: rgba(13, 18, 29, 0.92);
border: 1px solid var(--border); border: 1px solid var(--border);
border-radius: 8px; border-radius: 8px;
overflow: hidden; overflow: hidden;
display: grid; display: grid;
grid-template-rows: auto 1fr; grid-template-rows: auto 1fr;
} }
.drawer-head { .drawer-head {
display: flex; display: flex;
align-items: center; align-items: center;
justify-content: space-between; justify-content: space-between;
padding: 14px 14px; padding: 14px 14px;
border-bottom: 1px solid var(--border); border-bottom: 1px solid var(--border);
} }
.drawer-title { .drawer-title {
font-weight: 900; font-weight: 900;
} }
.drawer-x { .drawer-x {
width: 34px; width: 34px;
height: 34px; height: 34px;
border-radius: 8px; border-radius: 8px;
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.06); background: rgba(255, 255, 255, 0.06);
color: rgba(255, 255, 255, 0.9); color: rgba(255, 255, 255, 0.9);
cursor: pointer; cursor: pointer;
font-size: 20px; font-size: 20px;
line-height: 1; line-height: 1;
} }
.drawer-body { .drawer-body {
overflow: auto; overflow: auto;
padding: 12px 14px; padding: 12px 14px;
display: grid; display: grid;
gap: 10px; gap: 10px;
} }
.drawer-hint { .drawer-hint {
color: var(--muted); color: var(--muted);
padding: 12px 0; padding: 12px 0;
} }
.drawer-hint.bad { .drawer-hint.bad {
color: var(--danger); color: var(--danger);
} }
.user-row { .user-row {
text-align: left; text-align: left;
display: grid; display: grid;
grid-template-columns: auto 1fr; grid-template-columns: auto 1fr;
gap: 12px; gap: 12px;
align-items: center; align-items: center;
padding: 10px 10px; padding: 10px 10px;
border-radius: 8px; border-radius: 8px;
border: 1px solid var(--border); border: 1px solid var(--border);
background: rgba(255, 255, 255, 0.05); background: rgba(255, 255, 255, 0.05);
cursor: pointer; cursor: pointer;
} }
.user-row:hover { .user-row:hover {
background: rgba(255, 255, 255, 0.08); background: rgba(255, 255, 255, 0.08);
} }
.user-meta { .user-meta {
min-width: 0; min-width: 0;
} }
.user-name { .user-name {
font-weight: 800; font-weight: 800;
} }
.user-id { .user-id {
font-size: 12px; font-size: 12px;
color: var(--muted); color: var(--muted);
} }
.mono { .mono {
font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace;
} }
</style> </style>

File diff suppressed because it is too large Load Diff