2020-02-05 16:14:21 +01:00
|
|
|
package resolvers
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2020-02-09 16:16:41 +01:00
|
|
|
"database/sql"
|
2020-02-05 16:14:21 +01:00
|
|
|
|
|
|
|
api "github.com/viktorstrate/photoview/api/graphql"
|
|
|
|
"github.com/viktorstrate/photoview/api/graphql/auth"
|
|
|
|
"github.com/viktorstrate/photoview/api/graphql/models"
|
|
|
|
)
|
|
|
|
|
2020-09-07 12:04:14 +02:00
|
|
|
func (r *queryResolver) MyAlbums(ctx context.Context, filter *models.Filter, onlyRoot *bool, showEmpty *bool, onlyWithFavorites *bool) ([]*models.Album, error) {
|
2020-02-09 15:26:59 +01:00
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return nil, auth.ErrUnauthorized
|
|
|
|
}
|
|
|
|
|
|
|
|
filterSQL, err := filter.FormatSQL()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-02-20 17:14:11 +01:00
|
|
|
var rows *sql.Rows
|
|
|
|
|
2020-09-07 12:04:14 +02:00
|
|
|
filterFavorites := " AND favorite = 1"
|
|
|
|
if onlyWithFavorites == nil || *onlyWithFavorites == false {
|
|
|
|
filterFavorites = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
filterEmpty := " AND EXISTS (SELECT * FROM media WHERE album_id = album.album_id" + filterFavorites + ") "
|
|
|
|
if showEmpty != nil && *showEmpty == true && (onlyWithFavorites == nil || *onlyWithFavorites == false) {
|
2020-02-20 17:14:11 +01:00
|
|
|
filterEmpty = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
if onlyRoot == nil || *onlyRoot == false {
|
|
|
|
rows, err = r.Database.Query("SELECT * FROM album WHERE owner_id = ?"+filterEmpty+filterSQL, user.UserID)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
rows, err = r.Database.Query(`
|
|
|
|
SELECT * FROM album WHERE owner_id = ? AND parent_album = (
|
2020-02-22 14:29:41 +01:00
|
|
|
SELECT album_id FROM album WHERE parent_album IS NULL AND owner_id = ?
|
2020-02-20 17:14:11 +01:00
|
|
|
)
|
2020-02-22 14:29:41 +01:00
|
|
|
`+filterEmpty+filterSQL, user.UserID, user.UserID)
|
2020-02-20 17:14:11 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2020-02-09 15:26:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
albums, err := models.NewAlbumsFromRows(rows)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return albums, nil
|
2020-02-05 16:14:21 +01:00
|
|
|
}
|
2020-02-09 15:26:59 +01:00
|
|
|
|
2020-02-09 21:25:33 +01:00
|
|
|
func (r *queryResolver) Album(ctx context.Context, id int) (*models.Album, error) {
|
2020-02-05 16:14:21 +01:00
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return nil, auth.ErrUnauthorized
|
|
|
|
}
|
|
|
|
|
|
|
|
row := r.Database.QueryRow("SELECT * FROM album WHERE album_id = ? AND owner_id = ?", id, user.UserID)
|
|
|
|
album, err := models.NewAlbumFromRow(row)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return album, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Resolver) Album() api.AlbumResolver {
|
|
|
|
return &albumResolver{r}
|
|
|
|
}
|
|
|
|
|
|
|
|
type albumResolver struct{ *Resolver }
|
|
|
|
|
2020-09-07 12:04:14 +02:00
|
|
|
func (r *albumResolver) Media(ctx context.Context, obj *models.Album, filter *models.Filter, onlyFavorites *bool) ([]*models.Media, error) {
|
2020-02-09 15:26:59 +01:00
|
|
|
|
|
|
|
filterSQL, err := filter.FormatSQL()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-09-07 12:04:14 +02:00
|
|
|
filterFavorites := " AND media.favorite = 1 "
|
|
|
|
if onlyFavorites == nil || *onlyFavorites == false {
|
|
|
|
filterFavorites = ""
|
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
mediaRows, err := r.Database.Query(`
|
|
|
|
SELECT media.* FROM album, media
|
|
|
|
WHERE album.album_id = ? AND media.album_id = album.album_id
|
|
|
|
AND media.media_id IN (
|
|
|
|
SELECT media_id FROM media_url WHERE media_url.media_id = media.media_id
|
2020-02-27 16:26:53 +01:00
|
|
|
)
|
2020-09-07 12:04:14 +02:00
|
|
|
`+filterFavorites+filterSQL, obj.AlbumID)
|
2020-02-05 16:14:21 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2020-07-10 14:26:19 +02:00
|
|
|
defer mediaRows.Close()
|
2020-02-05 16:14:21 +01:00
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
media, err := models.NewMediaFromRows(mediaRows)
|
2020-02-05 16:14:21 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
return media, nil
|
2020-02-05 16:14:21 +01:00
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
func (r *albumResolver) Thumbnail(ctx context.Context, obj *models.Album) (*models.Media, error) {
|
2020-02-09 16:16:41 +01:00
|
|
|
|
2020-02-22 14:29:41 +01:00
|
|
|
row := r.Database.QueryRow(`
|
|
|
|
WITH recursive sub_albums AS (
|
|
|
|
SELECT * FROM album AS root WHERE album_id = ?
|
|
|
|
UNION ALL
|
|
|
|
SELECT child.* FROM album AS child JOIN sub_albums ON child.parent_album = sub_albums.album_id
|
|
|
|
)
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
SELECT * FROM media WHERE media.album_id IN (
|
2020-02-22 14:29:41 +01:00
|
|
|
SELECT album_id FROM sub_albums
|
2020-07-10 14:26:19 +02:00
|
|
|
) AND media.media_id IN (
|
|
|
|
SELECT media_id FROM media_url WHERE media_url.media_id = media.media_id
|
2020-02-22 14:29:41 +01:00
|
|
|
) LIMIT 1
|
|
|
|
`, obj.AlbumID)
|
2020-02-09 16:16:41 +01:00
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
media, err := models.NewMediaFromRow(row)
|
2020-02-09 16:16:41 +01:00
|
|
|
if err != nil {
|
|
|
|
if err == sql.ErrNoRows {
|
|
|
|
return nil, nil
|
|
|
|
} else {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
return media, nil
|
2020-02-09 16:16:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r *albumResolver) SubAlbums(ctx context.Context, obj *models.Album, filter *models.Filter) ([]*models.Album, error) {
|
|
|
|
filterSQL, err := filter.FormatSQL()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
rows, err := r.Database.Query("SELECT * FROM album WHERE parent_album = ?"+filterSQL, obj.AlbumID)
|
2020-02-09 15:26:59 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
albums, err := models.NewAlbumsFromRows(rows)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return albums, nil
|
2020-02-05 16:14:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r *albumResolver) ParentAlbum(ctx context.Context, obj *models.Album) (*models.Album, error) {
|
|
|
|
panic("not implemented")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *albumResolver) Owner(ctx context.Context, obj *models.Album) (*models.User, error) {
|
|
|
|
panic("not implemented")
|
|
|
|
}
|
2020-02-11 14:32:35 +01:00
|
|
|
|
|
|
|
func (r *albumResolver) Shares(ctx context.Context, obj *models.Album) ([]*models.ShareToken, error) {
|
|
|
|
rows, err := r.Database.Query("SELECT * FROM share_token WHERE album_id = ?", obj.ID())
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer rows.Close()
|
|
|
|
|
|
|
|
return models.NewShareTokensFromRows(rows)
|
|
|
|
}
|
2020-03-07 16:19:27 +01:00
|
|
|
|
|
|
|
func (r *albumResolver) Path(ctx context.Context, obj *models.Album) ([]*models.Album, error) {
|
2020-03-07 17:07:01 +01:00
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
empty := make([]*models.Album, 0)
|
|
|
|
return empty, nil
|
|
|
|
}
|
|
|
|
|
2020-03-07 16:19:27 +01:00
|
|
|
rows, err := r.Database.Query(`
|
|
|
|
WITH recursive path_albums AS (
|
|
|
|
SELECT * FROM album anchor WHERE anchor.album_id = ?
|
|
|
|
UNION
|
|
|
|
SELECT parent.* FROM path_albums child JOIN album parent ON parent.album_id = child.parent_album
|
|
|
|
)
|
2020-03-07 17:07:01 +01:00
|
|
|
SELECT * FROM path_albums WHERE album_id != ? AND owner_id = ?
|
|
|
|
`, obj.AlbumID, obj.AlbumID, user.UserID)
|
2020-03-07 16:19:27 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return models.NewAlbumsFromRows(rows)
|
|
|
|
}
|