2020-02-05 16:14:21 +01:00
|
|
|
package resolvers
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2020-11-28 21:29:31 +01:00
|
|
|
"fmt"
|
|
|
|
"log"
|
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
|
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
query := r.Database.Where("owner_id = ?", user.ID)
|
2020-02-09 15:26:59 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
if onlyRoot != nil && *onlyRoot == true {
|
|
|
|
query = query.Where("parent_album = ()", query.Model(&models.Album{})).Select("id").Where("parent_album IS NULL AND owner_id = ?", user.ID)
|
2020-09-07 12:04:14 +02:00
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
if showEmpty == nil || *showEmpty == false {
|
|
|
|
subQuery := r.Database.Model(&models.Media{}).Where("album_id = album.album_id")
|
2020-02-20 17:14:11 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
if onlyWithFavorites != nil && *onlyWithFavorites == true {
|
|
|
|
subQuery = subQuery.Where("favorite = 1")
|
2020-02-20 17:14:11 +01:00
|
|
|
}
|
2020-11-28 21:29:31 +01:00
|
|
|
|
|
|
|
query = query.Where("EXISTS (?)", subQuery)
|
2020-02-09 15:26:59 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
// TODO: Incorporate models.FormatSQL
|
|
|
|
|
|
|
|
var albums []*models.Album
|
|
|
|
if err := query.Find(albums).Error; err != nil {
|
2020-02-09 15:26:59 +01:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
var album models.Album
|
|
|
|
if err := r.Database.Where("owner_id = ?", user.ID).First(&album, id).Error; err != nil {
|
2020-02-05 16:14:21 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
return &album, nil
|
2020-02-05 16:14:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (r *Resolver) Album() api.AlbumResolver {
|
|
|
|
return &albumResolver{r}
|
|
|
|
}
|
|
|
|
|
|
|
|
type albumResolver struct{ *Resolver }
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
func (r *albumResolver) Media(ctx context.Context, album *models.Album, filter *models.Filter, onlyFavorites *bool) ([]*models.Media, error) {
|
2020-02-09 15:26:59 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
query := r.Database.
|
|
|
|
Joins("Album").
|
|
|
|
Where("Album.id = ?", album.ID).
|
|
|
|
Where("media.id IN (?)", r.Database.Model(&models.MediaURL{})).Select("media_id").Where("media_url.media_id = media.id")
|
2020-02-09 15:26:59 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
if onlyFavorites != nil && *onlyFavorites == true {
|
|
|
|
query = query.Where("media.favorite = 1")
|
2020-09-07 12:04:14 +02:00
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
// TODO: Incorporate filter.FormatSQL
|
2020-02-05 16:14:21 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
var media []*models.Media
|
|
|
|
if err := query.Find(&media).Error; err != nil {
|
2020-02-05 16:14:21 +01:00
|
|
|
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-11-28 21:29:31 +01:00
|
|
|
log.Println("TODO: Album thumbnail migrated yet")
|
|
|
|
|
|
|
|
return nil, nil
|
|
|
|
|
|
|
|
// 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
|
|
|
|
// )
|
|
|
|
|
|
|
|
// SELECT * FROM media WHERE media.album_id IN (
|
|
|
|
// SELECT album_id FROM sub_albums
|
|
|
|
// ) AND media.media_id IN (
|
|
|
|
// SELECT media_id FROM media_url WHERE media_url.media_id = media.media_id
|
|
|
|
// ) LIMIT 1
|
|
|
|
// `, obj.AlbumID)
|
|
|
|
|
|
|
|
// media, err := models.NewMediaFromRow(row)
|
|
|
|
// if err != nil {
|
|
|
|
// if err == sql.ErrNoRows {
|
|
|
|
// return nil, nil
|
|
|
|
// } else {
|
|
|
|
// return nil, err
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
|
|
|
|
// return media, nil
|
2020-02-09 16:16:41 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
func (r *albumResolver) SubAlbums(ctx context.Context, parent *models.Album, filter *models.Filter) ([]*models.Album, error) {
|
2020-02-09 16:16:41 +01:00
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
var albums []*models.Album
|
|
|
|
if err := r.Database.Where("parent_album = ?", parent.ID).Find(albums).Error; err != nil {
|
2020-02-09 15:26:59 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
// TODO: Incorporate filter.FormatSQL
|
2020-02-09 15:26:59 +01:00
|
|
|
|
|
|
|
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
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
func (r *albumResolver) Shares(ctx context.Context, album *models.Album) ([]*models.ShareToken, error) {
|
|
|
|
|
|
|
|
var shareTokens []*models.ShareToken
|
|
|
|
if err := r.Database.Where("album_id = ?", album.ID).Find(shareTokens).Error; err != nil {
|
2020-02-11 14:32:35 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
return shareTokens, nil
|
2020-02-11 14:32:35 +01:00
|
|
|
}
|
2020-03-07 16:19:27 +01:00
|
|
|
|
|
|
|
func (r *albumResolver) Path(ctx context.Context, obj *models.Album) ([]*models.Album, error) {
|
|
|
|
|
2020-11-28 21:29:31 +01:00
|
|
|
fmt.Println("TODO: Album path not migrated yet")
|
|
|
|
|
|
|
|
return make([]*models.Album, 0), nil
|
|
|
|
// user := auth.UserFromContext(ctx)
|
|
|
|
// if user == nil {
|
|
|
|
// empty := make([]*models.Album, 0)
|
|
|
|
// return empty, nil
|
|
|
|
// }
|
|
|
|
|
|
|
|
// 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
|
|
|
|
// )
|
|
|
|
// SELECT * FROM path_albums WHERE album_id != ? AND owner_id = ?
|
|
|
|
// `, obj.AlbumID, obj.AlbumID, user.UserID)
|
|
|
|
// if err != nil {
|
|
|
|
// return nil, err
|
|
|
|
// }
|
|
|
|
|
|
|
|
// return models.NewAlbumsFromRows(rows)
|
2020-03-07 16:19:27 +01:00
|
|
|
}
|