156 lines
3.3 KiB
Go
156 lines
3.3 KiB
Go
package search
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/photoprism/photoprism/pkg/txt"
|
|
|
|
"github.com/jinzhu/gorm"
|
|
"github.com/photoprism/photoprism/internal/entity"
|
|
"github.com/photoprism/photoprism/internal/form"
|
|
)
|
|
|
|
// Subjects searches subjects and returns them.
|
|
func Subjects(f form.SubjectSearch) (results SubjectResults, err error) {
|
|
if err := f.ParseQueryString(); err != nil {
|
|
return results, err
|
|
}
|
|
|
|
subjTable := entity.Subject{}.TableName()
|
|
|
|
// Base query.
|
|
s := UnscopedDb().Table(subjTable).
|
|
Select(fmt.Sprintf("%s.*", subjTable))
|
|
|
|
// Limit result count.
|
|
if f.Count > 0 && f.Count <= MaxResults {
|
|
s = s.Limit(f.Count).Offset(f.Offset)
|
|
} else {
|
|
s = s.Limit(MaxResults).Offset(f.Offset)
|
|
}
|
|
|
|
// Set sort order.
|
|
switch f.Order {
|
|
case "name":
|
|
s = s.Order("subj_name")
|
|
case "count":
|
|
s = s.Order("file_count DESC")
|
|
case "added":
|
|
s = s.Order(fmt.Sprintf("%s.created_at DESC", subjTable))
|
|
case "relevance":
|
|
s = s.Order("subj_favorite DESC, subj_name")
|
|
default:
|
|
s = s.Order("subj_favorite DESC, subj_name")
|
|
}
|
|
|
|
if f.ID != "" {
|
|
s = s.Where(fmt.Sprintf("%s.subj_uid IN (?)", subjTable), strings.Split(f.ID, txt.Or))
|
|
|
|
if result := s.Scan(&results); result.Error != nil {
|
|
return results, result.Error
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
// Clip to reasonable size and normalize operators.
|
|
f.Query = txt.NormalizeQuery(f.Query)
|
|
|
|
if f.Query != "" {
|
|
for _, where := range LikeAllNames(Cols{"subj_name", "subj_alias"}, f.Query) {
|
|
s = s.Where("?", gorm.Expr(where))
|
|
}
|
|
}
|
|
|
|
if f.Files > 0 {
|
|
s = s.Where("file_count >= ?", f.Files)
|
|
}
|
|
|
|
if f.Photos > 0 {
|
|
s = s.Where("photo_count >= ?", f.Photos)
|
|
}
|
|
|
|
if f.Type != "" {
|
|
s = s.Where("subj_type IN (?)", strings.Split(f.Type, txt.Or))
|
|
}
|
|
|
|
if f.Favorite {
|
|
s = s.Where("subj_favorite = 1")
|
|
}
|
|
|
|
if f.Private {
|
|
s = s.Where("subj_private = 1")
|
|
}
|
|
|
|
if f.Excluded {
|
|
s = s.Where("subj_excluded = 1")
|
|
}
|
|
|
|
// Omit deleted rows.
|
|
s = s.Where(fmt.Sprintf("%s.deleted_at IS NULL", subjTable))
|
|
|
|
if result := s.Scan(&results); result.Error != nil {
|
|
return results, result.Error
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
// SubjectUIDs finds subject UIDs matching the search string, and removes names from the remaining query.
|
|
func SubjectUIDs(s string) (result []string, names []string, remaining string) {
|
|
if s == "" {
|
|
return result, names, s
|
|
}
|
|
|
|
type Matches struct {
|
|
SubjUID string
|
|
SubjName string
|
|
SubjAlias string
|
|
}
|
|
|
|
var matches []Matches
|
|
|
|
wheres := LikeAllNames(Cols{"subj_name", "subj_alias"}, s)
|
|
|
|
if len(wheres) == 0 {
|
|
return result, names, s
|
|
}
|
|
|
|
remaining = s
|
|
|
|
for _, where := range wheres {
|
|
var subj []string
|
|
|
|
stmt := Db().Model(entity.Subject{})
|
|
stmt = stmt.Where("?", gorm.Expr(where))
|
|
|
|
if err := stmt.Scan(&matches).Error; err != nil {
|
|
log.Errorf("search: %s while finding subjects", err)
|
|
} else if len(matches) == 0 {
|
|
continue
|
|
}
|
|
|
|
for _, m := range matches {
|
|
subj = append(subj, m.SubjUID)
|
|
names = append(names, m.SubjName)
|
|
|
|
for _, r := range txt.Words(strings.ToLower(m.SubjName)) {
|
|
if len(r) > 1 {
|
|
remaining = strings.ReplaceAll(remaining, r, "")
|
|
}
|
|
}
|
|
|
|
for _, r := range txt.Words(strings.ToLower(m.SubjAlias)) {
|
|
if len(r) > 1 {
|
|
remaining = strings.ReplaceAll(remaining, r, "")
|
|
}
|
|
}
|
|
}
|
|
|
|
result = append(result, strings.Join(subj, txt.Or))
|
|
}
|
|
|
|
return result, names, txt.NormalizeQuery(remaining)
|
|
}
|