2020-02-05 14:51:46 +01:00
|
|
|
package resolvers
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2021-04-26 12:21:15 +02:00
|
|
|
"strings"
|
2020-02-05 14:51:46 +01:00
|
|
|
|
2021-05-06 21:54:31 +02:00
|
|
|
"github.com/photoview/photoview/api/dataloader"
|
2020-12-17 22:51:43 +01:00
|
|
|
api "github.com/photoview/photoview/api/graphql"
|
|
|
|
"github.com/photoview/photoview/api/graphql/auth"
|
|
|
|
"github.com/photoview/photoview/api/graphql/models"
|
2021-09-25 17:11:54 +02:00
|
|
|
"github.com/photoview/photoview/api/graphql/models/actions"
|
2021-08-31 12:05:46 +02:00
|
|
|
"github.com/photoview/photoview/api/scanner/face_detection"
|
2020-07-10 18:52:18 +02:00
|
|
|
"github.com/pkg/errors"
|
2020-02-05 14:51:46 +01:00
|
|
|
)
|
|
|
|
|
2021-02-13 15:08:05 +01:00
|
|
|
func (r *queryResolver) MyMedia(ctx context.Context, order *models.Ordering, paginate *models.Pagination) ([]*models.Media, error) {
|
2020-02-09 14:21:53 +01:00
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return nil, errors.New("unauthorized")
|
|
|
|
}
|
|
|
|
|
2021-09-25 17:11:54 +02:00
|
|
|
return actions.MyMedia(r.Database, user, order, paginate)
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2021-03-03 15:55:55 +01:00
|
|
|
func (r *queryResolver) Media(ctx context.Context, id int, tokenCredentials *models.ShareTokenCredentials) (*models.Media, error) {
|
|
|
|
if tokenCredentials != nil {
|
|
|
|
|
|
|
|
shareToken, err := r.ShareToken(ctx, *tokenCredentials)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if *shareToken.MediaID == id {
|
|
|
|
return shareToken.Media, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-05 14:51:46 +01:00
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return nil, auth.ErrUnauthorized
|
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
var media models.Media
|
2020-12-08 16:24:08 +01:00
|
|
|
|
|
|
|
err := r.Database.
|
|
|
|
Joins("Album").
|
|
|
|
Where("media.id = ?", id).
|
2021-01-31 17:06:25 +01:00
|
|
|
Where("EXISTS (SELECT * FROM user_albums WHERE user_albums.album_id = media.album_id AND user_albums.user_id = ?)", user.ID).
|
2020-12-08 16:24:08 +01:00
|
|
|
Where("media.id IN (?)", r.Database.Model(&models.MediaURL{}).Select("media_id").Where("media_urls.media_id = media.id")).
|
|
|
|
First(&media).Error
|
2020-02-05 14:51:46 +01:00
|
|
|
|
|
|
|
if err != nil {
|
2020-07-10 18:52:18 +02:00
|
|
|
return nil, errors.Wrap(err, "could not get media by media_id and user_id from database")
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
return &media, nil
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2020-09-27 20:52:09 +02:00
|
|
|
func (r *queryResolver) MediaList(ctx context.Context, ids []int) ([]*models.Media, error) {
|
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return nil, auth.ErrUnauthorized
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(ids) == 0 {
|
|
|
|
return nil, errors.New("no ids provided")
|
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
var media []*models.Media
|
2021-01-29 00:23:40 +01:00
|
|
|
err := r.Database.Model(&media).
|
|
|
|
Joins("LEFT JOIN user_albums ON user_albums.album_id = media.album_id").
|
2020-12-08 16:24:08 +01:00
|
|
|
Where("media.id IN ?", ids).
|
2021-01-29 00:23:40 +01:00
|
|
|
Where("user_albums.user_id = ?", user.ID).
|
2021-04-15 16:27:26 +02:00
|
|
|
Find(&media).Error
|
2020-12-08 16:24:08 +01:00
|
|
|
|
2020-09-27 20:52:09 +02:00
|
|
|
if err != nil {
|
2020-11-28 17:31:19 +01:00
|
|
|
return nil, errors.Wrap(err, "could not get media list by media_id and user_id from database")
|
2020-09-27 20:52:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return media, nil
|
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
type mediaResolver struct {
|
2020-02-05 14:51:46 +01:00
|
|
|
*Resolver
|
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
func (r *Resolver) Media() api.MediaResolver {
|
|
|
|
return &mediaResolver{r}
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2021-04-27 20:31:15 +02:00
|
|
|
func (r *mediaResolver) Type(ctx context.Context, media *models.Media) (models.MediaType, error) {
|
2021-04-26 12:21:15 +02:00
|
|
|
formattedType := models.MediaType(strings.Title(string(media.Type)))
|
2021-04-27 20:31:15 +02:00
|
|
|
return formattedType, nil
|
2021-04-26 12:21:15 +02:00
|
|
|
}
|
|
|
|
|
2021-09-18 20:17:24 +02:00
|
|
|
func (r *mediaResolver) Album(ctx context.Context, obj *models.Media) (*models.Album, error) {
|
|
|
|
var album models.Album
|
|
|
|
err := r.Database.Find(&album, obj.AlbumID).Error
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &album, nil
|
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
func (r *mediaResolver) Shares(ctx context.Context, media *models.Media) ([]*models.ShareToken, error) {
|
|
|
|
var shareTokens []*models.ShareToken
|
2020-11-28 21:49:33 +01:00
|
|
|
if err := r.Database.Where("media_id = ?", media.ID).Find(&shareTokens).Error; err != nil {
|
2020-11-28 17:31:19 +01:00
|
|
|
return nil, errors.Wrapf(err, "get shares for media (%s)", media.Path)
|
2020-02-11 15:36:12 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
return shareTokens, nil
|
2020-02-10 12:05:58 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
func (r *mediaResolver) Downloads(ctx context.Context, media *models.Media) ([]*models.MediaDownload, error) {
|
2020-02-21 22:42:39 +01:00
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
var mediaUrls []*models.MediaURL
|
|
|
|
if err := r.Database.Where("media_id = ?", media.ID).Find(&mediaUrls).Error; err != nil {
|
|
|
|
return nil, errors.Wrapf(err, "get downloads for media (%s)", media.Path)
|
2020-02-21 22:42:39 +01:00
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
downloads := make([]*models.MediaDownload, 0)
|
2020-02-21 22:42:39 +01:00
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
for _, url := range mediaUrls {
|
2020-02-21 22:42:39 +01:00
|
|
|
|
|
|
|
var title string
|
|
|
|
switch {
|
2020-07-10 12:58:11 +02:00
|
|
|
case url.Purpose == models.MediaOriginal:
|
2020-02-21 22:42:39 +01:00
|
|
|
title = "Original"
|
|
|
|
case url.Purpose == models.PhotoThumbnail:
|
|
|
|
title = "Small"
|
|
|
|
case url.Purpose == models.PhotoHighRes:
|
|
|
|
title = "Large"
|
2020-07-11 16:42:27 +02:00
|
|
|
case url.Purpose == models.VideoThumbnail:
|
|
|
|
title = "Video thumbnail"
|
|
|
|
case url.Purpose == models.VideoWeb:
|
|
|
|
title = "Web optimized video"
|
2020-02-21 22:42:39 +01:00
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
downloads = append(downloads, &models.MediaDownload{
|
2020-08-11 22:34:42 +02:00
|
|
|
Title: title,
|
|
|
|
MediaURL: url,
|
2020-02-21 22:42:39 +01:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-02-10 12:05:58 +01:00
|
|
|
return downloads, nil
|
2020-02-09 12:53:21 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
func (r *mediaResolver) HighRes(ctx context.Context, media *models.Media) (*models.MediaURL, error) {
|
2021-01-22 09:35:54 +01:00
|
|
|
if media.Type != models.MediaTypePhoto {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
2021-02-07 22:17:33 +01:00
|
|
|
return dataloader.For(ctx).MediaHighres.Load(media.ID)
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
func (r *mediaResolver) Thumbnail(ctx context.Context, media *models.Media) (*models.MediaURL, error) {
|
2021-02-07 22:17:33 +01:00
|
|
|
return dataloader.For(ctx).MediaThumbnail.Load(media.ID)
|
2020-02-05 14:51:46 +01:00
|
|
|
}
|
|
|
|
|
2020-11-28 17:31:19 +01:00
|
|
|
func (r *mediaResolver) VideoWeb(ctx context.Context, media *models.Media) (*models.MediaURL, error) {
|
2021-01-22 09:35:54 +01:00
|
|
|
if media.Type != models.MediaTypeVideo {
|
|
|
|
return nil, nil
|
|
|
|
}
|
2020-11-28 17:31:19 +01:00
|
|
|
|
2021-02-07 22:17:33 +01:00
|
|
|
return dataloader.For(ctx).MediaVideoWeb.Load(media.ID)
|
2020-07-11 15:57:58 +02:00
|
|
|
}
|
|
|
|
|
2021-01-19 16:46:15 +01:00
|
|
|
func (r *mediaResolver) Exif(ctx context.Context, media *models.Media) (*models.MediaEXIF, error) {
|
|
|
|
if media.Exif != nil {
|
|
|
|
return media.Exif, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var exif models.MediaEXIF
|
|
|
|
if err := r.Database.Model(&media).Association("Exif").Find(&exif); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return &exif, nil
|
|
|
|
}
|
|
|
|
|
2020-12-20 17:10:00 +01:00
|
|
|
func (r *mediaResolver) Favorite(ctx context.Context, media *models.Media) (bool, error) {
|
|
|
|
user := auth.UserFromContext(ctx)
|
|
|
|
if user == nil {
|
|
|
|
return false, auth.ErrUnauthorized
|
|
|
|
}
|
|
|
|
|
2021-02-07 22:17:33 +01:00
|
|
|
return dataloader.For(ctx).UserMediaFavorite.Load(&models.UserMediaData{
|
|
|
|
UserID: user.ID,
|
|
|
|
MediaID: media.ID,
|
|
|
|
})
|
2020-12-20 17:10:00 +01:00
|
|
|
}
|
|
|
|
|
2020-07-10 14:26:19 +02:00
|
|
|
func (r *mutationResolver) FavoriteMedia(ctx context.Context, mediaID int, favorite bool) (*models.Media, error) {
|
2020-06-17 18:00:58 +02:00
|
|
|
|
|
|
|
user := auth.UserFromContext(ctx)
|
2020-12-20 17:10:00 +01:00
|
|
|
if user == nil {
|
|
|
|
return nil, auth.ErrUnauthorized
|
|
|
|
}
|
2020-06-17 18:00:58 +02:00
|
|
|
|
2021-09-27 20:23:10 +02:00
|
|
|
return user.FavoriteMedia(r.Database, mediaID, favorite)
|
2020-06-17 18:00:58 +02:00
|
|
|
}
|
2021-02-16 17:13:08 +01:00
|
|
|
|
|
|
|
func (r *mediaResolver) Faces(ctx context.Context, media *models.Media) ([]*models.ImageFace, error) {
|
2021-08-31 12:05:46 +02:00
|
|
|
if face_detection.GlobalFaceDetector == nil {
|
|
|
|
return []*models.ImageFace{}, nil
|
|
|
|
}
|
|
|
|
|
2021-02-16 17:13:08 +01:00
|
|
|
if media.Faces != nil {
|
|
|
|
return media.Faces, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var faces []*models.ImageFace
|
|
|
|
if err := r.Database.Model(&media).Association("Faces").Find(&faces); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return faces, nil
|
|
|
|
}
|