136 lines
3.5 KiB
Go
136 lines
3.5 KiB
Go
package cache
|
|
|
|
import (
|
|
"backend/internal/domain"
|
|
"backend/pkg/cache"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
type SessionRepository struct {
|
|
redis *cache.Redis
|
|
}
|
|
|
|
func NewSessionRepository(redis *cache.Redis) domain.SessionRepo {
|
|
return &SessionRepository{
|
|
redis: redis,
|
|
}
|
|
}
|
|
|
|
func (r *SessionRepository) Create(ctx context.Context, session *domain.UserSession) error {
|
|
key := r.getSessionKey(session.ID)
|
|
|
|
sessionData, err := json.Marshal(session)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal session: %w", err)
|
|
}
|
|
|
|
ttl := time.Until(session.ExpiresAt)
|
|
if ttl <= 0 {
|
|
return fmt.Errorf("session already expired")
|
|
}
|
|
|
|
if err := r.redis.Client().Set(ctx, key, sessionData, ttl).Err(); err != nil {
|
|
return fmt.Errorf("failed to store session in Redis: %w", err)
|
|
}
|
|
|
|
userSessionsKey := r.getUserSessionsKey(session.UserID)
|
|
if err := r.redis.Client().SAdd(ctx, userSessionsKey, session.ID.String()).Err(); err != nil {
|
|
return fmt.Errorf("failed to add session to user sessions set: %w", err)
|
|
}
|
|
|
|
if err := r.redis.Client().Expire(ctx, userSessionsKey, ttl).Err(); err != nil {
|
|
return fmt.Errorf("failed to set TTL for user sessions set: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *SessionRepository) GetByID(ctx context.Context, id uuid.UUID) (*domain.UserSession, error) {
|
|
key := r.getSessionKey(id)
|
|
|
|
result, err := r.redis.Client().Get(ctx, key).Result()
|
|
if err != nil {
|
|
if err == redis.Nil {
|
|
return nil, fmt.Errorf("session not found")
|
|
}
|
|
return nil, fmt.Errorf("failed to get session from Redis: %w", err)
|
|
}
|
|
|
|
var session domain.UserSession
|
|
if err := json.Unmarshal([]byte(result), &session); err != nil {
|
|
return nil, fmt.Errorf("failed to unmarshal session: %w", err)
|
|
}
|
|
|
|
if time.Now().After(session.ExpiresAt) {
|
|
r.Delete(ctx, id)
|
|
return nil, fmt.Errorf("session expired")
|
|
}
|
|
|
|
return &session, nil
|
|
}
|
|
|
|
func (r *SessionRepository) Delete(ctx context.Context, id uuid.UUID) error {
|
|
key := r.getSessionKey(id)
|
|
|
|
session, err := r.GetByID(ctx, id)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
if err := r.redis.Client().Del(ctx, key).Err(); err != nil {
|
|
return fmt.Errorf("failed to delete session from Redis: %w", err)
|
|
}
|
|
|
|
userSessionsKey := r.getUserSessionsKey(session.UserID)
|
|
if err := r.redis.Client().SRem(ctx, userSessionsKey, id.String()).Err(); err != nil {
|
|
return fmt.Errorf("failed to remove session from user sessions set: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (r *SessionRepository) GetUserSessions(ctx context.Context, userID uuid.UUID) ([]domain.UserSession, error) {
|
|
userSessionsKey := r.getUserSessionsKey(userID)
|
|
|
|
sessionIDs, err := r.redis.Client().SMembers(ctx, userSessionsKey).Result()
|
|
if err != nil {
|
|
if err == redis.Nil {
|
|
return []domain.UserSession{}, nil
|
|
}
|
|
return nil, fmt.Errorf("failed to get user sessions from Redis: %w", err)
|
|
}
|
|
|
|
var sessions []domain.UserSession
|
|
for _, sessionIDStr := range sessionIDs {
|
|
sessionID, err := uuid.Parse(sessionIDStr)
|
|
if err != nil {
|
|
r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
|
|
continue
|
|
}
|
|
|
|
session, err := r.GetByID(ctx, sessionID)
|
|
if err != nil {
|
|
r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
|
|
continue
|
|
}
|
|
|
|
sessions = append(sessions, *session)
|
|
}
|
|
|
|
return sessions, nil
|
|
}
|
|
|
|
func (r *SessionRepository) getSessionKey(sessionID uuid.UUID) string {
|
|
return fmt.Sprintf("session:%s", sessionID.String())
|
|
}
|
|
|
|
func (r *SessionRepository) getUserSessionsKey(userID uuid.UUID) string {
|
|
return fmt.Sprintf("user_sessions:%s", userID.String())
|
|
}
|