139 lines
4.4 KiB
Go
139 lines
4.4 KiB
Go
package photos
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"shared-album/internal/models"
|
|
)
|
|
|
|
var ErrNotFound = errors.New("photo not found")
|
|
|
|
type Store struct {
|
|
pool *pgxpool.Pool
|
|
}
|
|
|
|
func NewStore(pool *pgxpool.Pool) *Store { return &Store{pool: pool} }
|
|
|
|
const photoColumns = `p.id, p.album_id, p.uploader_id, p.storage_key,
|
|
COALESCE(p.thumb_key, ''), COALESCE(p.preview_key, ''),
|
|
p.original_filename, p.size, p.width, p.height, p.mime_type,
|
|
p.taken_at, p.latitude, p.longitude, COALESCE(p.caption, ''), p.created_at,
|
|
u.id, u.name, COALESCE(u.avatar_url, ''),
|
|
(SELECT count(*) FROM likes l WHERE l.photo_id = p.id),
|
|
(SELECT count(*) FROM comments c WHERE c.photo_id = p.id),
|
|
EXISTS(SELECT 1 FROM likes l WHERE l.photo_id = p.id AND l.user_id = $2)`
|
|
|
|
func scanPhoto(row pgx.Row) (*models.Photo, error) {
|
|
var p models.Photo
|
|
err := row.Scan(&p.ID, &p.AlbumID, &p.UploaderID, &p.StorageKey,
|
|
&p.ThumbKey, &p.PreviewKey,
|
|
&p.OriginalFilename, &p.Size, &p.Width, &p.Height, &p.MimeType,
|
|
&p.TakenAt, &p.Latitude, &p.Longitude, &p.Caption, &p.CreatedAt,
|
|
&p.Uploader.ID, &p.Uploader.Name, &p.Uploader.AvatarURL,
|
|
&p.LikesCount, &p.CommentsCount, &p.LikedByMe)
|
|
if err != nil {
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, ErrNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &p, nil
|
|
}
|
|
|
|
func (s *Store) Create(ctx context.Context, p *models.Photo) error {
|
|
return s.pool.QueryRow(ctx,
|
|
`INSERT INTO photos (id, album_id, uploader_id, storage_key, original_filename,
|
|
size, width, height, mime_type, taken_at, latitude, longitude, caption)
|
|
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
|
|
RETURNING created_at`,
|
|
p.ID, p.AlbumID, p.UploaderID, p.StorageKey, p.OriginalFilename,
|
|
p.Size, p.Width, p.Height, p.MimeType, p.TakenAt, p.Latitude, p.Longitude, p.Caption,
|
|
).Scan(&p.CreatedAt)
|
|
}
|
|
|
|
func (s *Store) SetVariants(ctx context.Context, id, thumbKey, previewKey string) error {
|
|
_, err := s.pool.Exec(ctx,
|
|
`UPDATE photos SET thumb_key = $2, preview_key = $3 WHERE id = $1`, id, thumbKey, previewKey)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) GetByID(ctx context.Context, id, viewerID string) (*models.Photo, error) {
|
|
return scanPhoto(s.pool.QueryRow(ctx,
|
|
`SELECT `+photoColumns+`
|
|
FROM photos p JOIN users u ON u.id = p.uploader_id
|
|
WHERE p.id = $1`, id, viewerID))
|
|
}
|
|
|
|
type ListParams struct {
|
|
AlbumID string
|
|
Viewer string
|
|
Cursor string
|
|
Since *time.Time
|
|
Limit int
|
|
}
|
|
|
|
func (s *Store) List(ctx context.Context, in ListParams) ([]models.Photo, error) {
|
|
if in.Limit <= 0 || in.Limit > 100 {
|
|
in.Limit = 50
|
|
}
|
|
rows, err := s.pool.Query(ctx,
|
|
`SELECT `+photoColumns+`
|
|
FROM photos p JOIN users u ON u.id = p.uploader_id
|
|
WHERE p.album_id = $1
|
|
AND ($3 = '' OR (p.created_at, p.id) < (SELECT created_at, id FROM photos WHERE id = $3))
|
|
AND ($4::timestamptz IS NULL OR p.created_at > $4)
|
|
ORDER BY p.created_at DESC, p.id DESC
|
|
LIMIT $5`,
|
|
in.AlbumID, in.Viewer, in.Cursor, in.Since, in.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
out := []models.Photo{}
|
|
for rows.Next() {
|
|
var p models.Photo
|
|
if err := rows.Scan(&p.ID, &p.AlbumID, &p.UploaderID, &p.StorageKey,
|
|
&p.ThumbKey, &p.PreviewKey,
|
|
&p.OriginalFilename, &p.Size, &p.Width, &p.Height, &p.MimeType,
|
|
&p.TakenAt, &p.Latitude, &p.Longitude, &p.Caption, &p.CreatedAt,
|
|
&p.Uploader.ID, &p.Uploader.Name, &p.Uploader.AvatarURL,
|
|
&p.LikesCount, &p.CommentsCount, &p.LikedByMe); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, p)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) Delete(ctx context.Context, id string) error {
|
|
tag, err := s.pool.Exec(ctx, `DELETE FROM photos WHERE id = $1`, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if tag.RowsAffected() == 0 {
|
|
return ErrNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) SetCover(ctx context.Context, albumID, photoID string) {
|
|
_, _ = s.pool.Exec(ctx, `UPDATE albums SET cover_photo_id = $2 WHERE id = $1 AND cover_photo_id IS NULL`, albumID, photoID)
|
|
}
|
|
|
|
func (s *Store) ClearCover(ctx context.Context, albumID, photoID string) {
|
|
_, _ = s.pool.Exec(ctx, `UPDATE albums SET cover_photo_id = NULL WHERE id = $1 AND cover_photo_id = $2`, albumID, photoID)
|
|
}
|
|
|
|
func (s *Store) PhotoInAlbum(ctx context.Context, photoID, albumID string) (bool, error) {
|
|
var exists bool
|
|
err := s.pool.QueryRow(ctx,
|
|
`SELECT EXISTS(SELECT 1 FROM photos WHERE id = $1 AND album_id = $2)`, photoID, albumID).Scan(&exists)
|
|
return exists, err
|
|
}
|