photoprism/internal/query/albums.go

163 lines
4.9 KiB
Go
Raw Normal View History

package query
import (
"fmt"
"strings"
"time"
"github.com/photoprism/photoprism/internal/entity"
"github.com/photoprism/photoprism/internal/form"
"github.com/photoprism/photoprism/pkg/capture"
)
// AlbumResult contains found albums
type AlbumResult struct {
ID uint `json:"-"`
AlbumUID string `json:"UID"`
CoverUID string `json:"CoverUID"`
FolderUID string `json:"FolderUID"`
AlbumSlug string `json:"Slug"`
AlbumType string `json:"Type"`
AlbumTitle string `json:"Title"`
AlbumCategory string `json:"Category"`
AlbumCaption string `json:"Caption"`
AlbumDescription string `json:"Description"`
AlbumNotes string `json:"Notes"`
AlbumFilter string `json:"Filter"`
AlbumOrder string `json:"Order"`
AlbumTemplate string `json:"Template"`
AlbumCountry string `json:"Country"`
AlbumYear int `json:"Year"`
AlbumMonth int `json:"Month"`
AlbumFavorite bool `json:"Favorite"`
AlbumPrivate bool `json:"Private"`
PhotoCount int `json:"PhotoCount"`
LinkCount int `json:"LinkCount"`
CreatedAt time.Time `json:"CreatedAt"`
UpdatedAt time.Time `json:"UpdatedAt"`
DeletedAt time.Time `json:"DeletedAt,omitempty"`
}
// AlbumByUID returns a Album based on the UID.
func AlbumByUID(albumUID string) (album entity.Album, err error) {
if err := Db().Where("album_uid = ?", albumUID).Preload("Links").First(&album).Error; err != nil {
return album, err
}
return album, nil
}
// AlbumCoverByUID returns a album preview file based on the uid.
func AlbumCoverByUID(albumUID string) (file entity.File, err error) {
a := entity.Album{}
if err := Db().Where("album_uid = ?", albumUID).First(&a).Error; err != nil {
return file, err
} else if a.AlbumType != entity.TypeAlbum { // TODO: Optimize
f := form.PhotoSearch{Album: a.AlbumUID, Filter: a.AlbumFilter, Order: entity.SortOrderRelevance, Count: 1, Offset: 0, Merged: false}
if photos, _, err := PhotoSearch(f); err != nil {
return file, err
} else if len(photos) > 0 {
for _, photo := range photos {
if err := Db().Where("photo_uid = ? AND file_primary = 1", photo.PhotoUID).First(&file).Error; err != nil {
return file, err
} else {
return file, nil
}
}
}
return file, fmt.Errorf("found no cover for moment")
}
if err := Db().Where("files.file_primary = 1 AND files.file_missing = 0 AND files.file_type = 'jpg' AND files.deleted_at IS NULL").
Joins("JOIN albums ON albums.album_uid = ?", albumUID).
Joins("JOIN photos_albums pa ON pa.album_uid = albums.album_uid AND pa.photo_uid = files.photo_uid").
Joins("JOIN photos ON photos.id = files.photo_id AND photos.photo_private = 0 AND photos.deleted_at IS NULL").
Order("photos.photo_quality DESC, photos.taken_at DESC").
First(&file).Error; err != nil {
return file, err
}
return file, nil
}
// AlbumPhotos returns up to count photos from an album.
func AlbumPhotos(a entity.Album, count int) (results PhotoResults, err error) {
results, _, err = PhotoSearch(form.PhotoSearch{
Album: a.AlbumUID,
Filter: a.AlbumFilter,
Count: count,
Offset: 0,
})
return results, err
}
// AlbumSearch searches albums based on their name.
func AlbumSearch(f form.AlbumSearch) (results []AlbumResult, err error) {
if err := f.ParseQueryString(); err != nil {
return results, err
}
defer log.Debug(capture.Time(time.Now(), fmt.Sprintf("albums: search %s", form.Serialize(f, true))))
s := Db().NewScope(nil).DB()
s = s.Table("albums").
Select(`albums.*,
COUNT(photos_albums.album_uid) AS photo_count,
COUNT(links.link_token) AS link_count`).
Joins("LEFT JOIN photos_albums ON photos_albums.album_uid = albums.album_uid").
Joins("LEFT JOIN links ON links.share_uid = albums.album_uid").
Where("albums.deleted_at IS NULL").
Group("albums.id")
if f.ID != "" {
s = s.Where("albums.album_uid IN (?)", strings.Split(f.ID, ","))
if result := s.Scan(&results); result.Error != nil {
return results, result.Error
}
return results, nil
}
if f.Query != "" {
likeString := "%" + strings.ToLower(f.Query) + "%"
s = s.Where("LOWER(albums.album_title) LIKE ?", likeString)
}
if f.Type != "" {
s = s.Where("albums.album_type IN (?)", strings.Split(f.Type, ","))
}
if f.Category != "" {
s = s.Where("albums.album_category IN (?)", strings.Split(f.Category, ","))
}
if f.Favorite {
s = s.Where("albums.album_favorite = 1")
}
switch f.Order {
case "slug":
s = s.Order("albums.album_favorite DESC, album_slug ASC")
default:
s = s.Order("albums.album_favorite DESC, albums.album_year DESC, albums.album_month DESC, albums.album_title, albums.created_at DESC")
}
if f.Count > 0 && f.Count <= 1000 {
s = s.Limit(f.Count).Offset(f.Offset)
} else {
s = s.Limit(100).Offset(0)
}
if result := s.Scan(&results); result.Error != nil {
return results, result.Error
}
return results, nil
}