267 lines
8.3 KiB
Go
267 lines
8.3 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
"time"
|
|
|
|
"github.com/TopherMayor/unified-media-manager/internal/db"
|
|
)
|
|
|
|
type Request struct {
|
|
ID int64 `json:"id"`
|
|
MediaID int64 `json:"media_id"`
|
|
MediaType string `json:"media_type"`
|
|
Title string `json:"title"`
|
|
RequestedBy int64 `json:"requested_by"`
|
|
Status string `json:"status"`
|
|
QualityProfileID *int64 `json:"quality_profile_id,omitempty"`
|
|
RootFolderID *int64 `json:"root_folder_id,omitempty"`
|
|
Notes string `json:"notes,omitempty"`
|
|
ReviewedBy *int64 `json:"reviewed_by,omitempty"`
|
|
ReviewedAt *time.Time `json:"reviewed_at,omitempty"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
}
|
|
|
|
type CreateRequest struct {
|
|
MediaID int64 `json:"media_id"`
|
|
MediaType string `json:"media_type"`
|
|
Title string `json:"title"`
|
|
QualityProfileID *int64 `json:"quality_profile_id,omitempty"`
|
|
RootFolderID *int64 `json:"root_folder_id,omitempty"`
|
|
Notes string `json:"notes,omitempty"`
|
|
}
|
|
|
|
type RequestFilters struct {
|
|
Status string `json:"status,omitempty"`
|
|
RequestedBy *int64 `json:"requested_by,omitempty"`
|
|
Page int `json:"page"`
|
|
PageSize int `json:"page_size"`
|
|
}
|
|
|
|
type RequestStats struct {
|
|
Total int `json:"total"`
|
|
Pending int `json:"pending"`
|
|
Approved int `json:"approved"`
|
|
Rejected int `json:"rejected"`
|
|
Fulfilled int `json:"fulfilled"`
|
|
Withdrawn int `json:"withdrawn"`
|
|
}
|
|
|
|
const requestColumns = `id, media_id, media_type, title, requested_by, status, quality_profile_id, root_folder_id, notes, reviewed_by, reviewed_at, created_at, updated_at`
|
|
|
|
type RequestService struct {
|
|
db *db.DB
|
|
searchSvc *SearchService
|
|
}
|
|
|
|
func NewRequestService(database *db.DB, searchSvc *SearchService) *RequestService {
|
|
return &RequestService{db: database, searchSvc: searchSvc}
|
|
}
|
|
|
|
func scanRequest(scanner interface{ Scan(...interface{}) error }) (*Request, error) {
|
|
var r Request
|
|
err := scanner.Scan(&r.ID, &r.MediaID, &r.MediaType, &r.Title, &r.RequestedBy, &r.Status,
|
|
&r.QualityProfileID, &r.RootFolderID, &r.Notes,
|
|
&r.ReviewedBy, &r.ReviewedAt, &r.CreatedAt, &r.UpdatedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &r, nil
|
|
}
|
|
|
|
func (s *RequestService) Create(ctx context.Context, req CreateRequest, userRole string, userID int64) (int64, error) {
|
|
status := "pending"
|
|
if userRole == "admin" || userRole == "power_user" {
|
|
status = "approved"
|
|
}
|
|
|
|
now := time.Now()
|
|
var id int64
|
|
err := s.db.Pool.QueryRow(ctx,
|
|
`INSERT INTO requests (media_id, media_type, title, requested_by, status, quality_profile_id, root_folder_id, notes, created_at, updated_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
RETURNING id`,
|
|
req.MediaID, req.MediaType, req.Title, userID, status,
|
|
req.QualityProfileID, req.RootFolderID, req.Notes, now, now).Scan(&id)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("create request: %w", err)
|
|
}
|
|
|
|
// Auto-approve: trigger search immediately in background
|
|
if status == "approved" && s.searchSvc != nil {
|
|
go func() {
|
|
bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
s.triggerSearch(bgCtx, req)
|
|
}()
|
|
}
|
|
|
|
return id, nil
|
|
}
|
|
|
|
func (s *RequestService) List(ctx context.Context, filters RequestFilters) ([]Request, int, error) {
|
|
qb := NewQueryBuilder(1)
|
|
qb.AddLiteral("1=1")
|
|
|
|
if filters.Status != "" {
|
|
qb.Add("AND status = $%d", filters.Status)
|
|
}
|
|
if filters.RequestedBy != nil {
|
|
qb.Add("AND requested_by = $%d", *filters.RequestedBy)
|
|
}
|
|
|
|
countQuery := fmt.Sprintf("SELECT COUNT(*) FROM requests WHERE %s", qb.conditions[0])
|
|
countArgs := qb.Args()
|
|
if len(qb.conditions) > 1 {
|
|
countQuery = fmt.Sprintf("SELECT COUNT(*) FROM requests %s", qb.Where())
|
|
countArgs = qb.Args()
|
|
}
|
|
|
|
var total int
|
|
if err := s.db.Pool.QueryRow(ctx, countQuery, countArgs...).Scan(&total); err != nil {
|
|
return nil, 0, fmt.Errorf("count requests: %w", err)
|
|
}
|
|
|
|
offset := (filters.Page - 1) * filters.PageSize
|
|
dataQuery := fmt.Sprintf("SELECT %s FROM requests %s ORDER BY created_at DESC LIMIT $%d OFFSET $%d",
|
|
requestColumns, qb.Where(), qb.Idx(), qb.Idx()+1)
|
|
dataArgs := append(qb.Args(), filters.PageSize, offset)
|
|
|
|
rows, err := s.db.Pool.Query(ctx, dataQuery, dataArgs...)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("list requests: %w", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var items []Request
|
|
for rows.Next() {
|
|
r, err := scanRequest(rows)
|
|
if err != nil {
|
|
slog.Error("failed to scan request", "error", err)
|
|
continue
|
|
}
|
|
items = append(items, *r)
|
|
}
|
|
|
|
return items, total, nil
|
|
}
|
|
|
|
func (s *RequestService) GetByID(ctx context.Context, id int64) (*Request, error) {
|
|
row := s.db.Pool.QueryRow(ctx,
|
|
fmt.Sprintf("SELECT %s FROM requests WHERE id = $1", requestColumns), id)
|
|
|
|
r, err := scanRequest(row)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("request not found")
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func (s *RequestService) Approve(ctx context.Context, id int64, reviewerID int64, notes string) error {
|
|
now := time.Now()
|
|
tag, err := s.db.Pool.Exec(ctx,
|
|
`UPDATE requests SET status = 'approved', reviewed_by = $1, reviewed_at = $2, notes = COALESCE(NULLIF($3, ''), notes), updated_at = $4
|
|
WHERE id = $5 AND status = 'pending'`, reviewerID, now, notes, now, id)
|
|
if err != nil {
|
|
return fmt.Errorf("approve request: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("request not found or not pending")
|
|
}
|
|
|
|
// Trigger search in background
|
|
if s.searchSvc != nil {
|
|
req, err := s.GetByID(ctx, id)
|
|
if err == nil {
|
|
go func() {
|
|
bgCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
s.triggerSearch(bgCtx, CreateRequest{
|
|
MediaID: req.MediaID,
|
|
MediaType: req.MediaType,
|
|
Title: req.Title,
|
|
})
|
|
}()
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *RequestService) Reject(ctx context.Context, id int64, reviewerID int64, notes string) error {
|
|
now := time.Now()
|
|
tag, err := s.db.Pool.Exec(ctx,
|
|
`UPDATE requests SET status = 'rejected', reviewed_by = $1, reviewed_at = $2, notes = COALESCE(NULLIF($3, ''), notes), updated_at = $4
|
|
WHERE id = $5 AND status = 'pending'`, reviewerID, now, notes, now, id)
|
|
if err != nil {
|
|
return fmt.Errorf("reject request: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("request not found or not pending")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *RequestService) Withdraw(ctx context.Context, id int64, userID int64) error {
|
|
now := time.Now()
|
|
tag, err := s.db.Pool.Exec(ctx,
|
|
`UPDATE requests SET status = 'withdrawn', updated_at = $1
|
|
WHERE id = $2 AND requested_by = $3 AND status IN ('pending', 'approved')`, now, id, userID)
|
|
if err != nil {
|
|
return fmt.Errorf("withdraw request: %w", err)
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return fmt.Errorf("request not found, not owned by user, or not withdrawable")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *RequestService) MarkFulfilled(ctx context.Context, mediaID int64) error {
|
|
now := time.Now()
|
|
tag, err := s.db.Pool.Exec(ctx,
|
|
`UPDATE requests SET status = 'fulfilled', updated_at = $1
|
|
WHERE media_id = $2 AND status = 'approved'`, now, mediaID)
|
|
if err != nil {
|
|
return fmt.Errorf("mark fulfilled: %w", err)
|
|
}
|
|
if tag.RowsAffected() > 0 {
|
|
slog.Info("request marked fulfilled", "media_id", mediaID)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *RequestService) Stats(ctx context.Context) (*RequestStats, error) {
|
|
var stats RequestStats
|
|
err := s.db.Pool.QueryRow(ctx,
|
|
`SELECT
|
|
COUNT(*) FILTER (WHERE 1=1) AS total,
|
|
COUNT(*) FILTER (WHERE status = 'pending') AS pending,
|
|
COUNT(*) FILTER (WHERE status = 'approved') AS approved,
|
|
COUNT(*) FILTER (WHERE status = 'rejected') AS rejected,
|
|
COUNT(*) FILTER (WHERE status = 'fulfilled') AS fulfilled,
|
|
COUNT(*) FILTER (WHERE status = 'withdrawn') AS withdrawn
|
|
FROM requests`).Scan(&stats.Total, &stats.Pending, &stats.Approved, &stats.Rejected, &stats.Fulfilled, &stats.Withdrawn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("request stats: %w", err)
|
|
}
|
|
return &stats, nil
|
|
}
|
|
|
|
func (s *RequestService) triggerSearch(ctx context.Context, req CreateRequest) {
|
|
if req.Title == "" {
|
|
return
|
|
}
|
|
_, err := s.searchSvc.Search(ctx, SearchRequest{
|
|
Query: req.Title,
|
|
MediaType: req.MediaType,
|
|
})
|
|
if err != nil {
|
|
slog.Error("auto-search for request failed", "title", req.Title, "error", err)
|
|
} else {
|
|
slog.Info("auto-search triggered for request", "title", req.Title)
|
|
}
|
|
}
|