Autotag support for images and galleries

graphql/schema/types/filters.graphql

@@ -164,6 +164,10 @@ input StudioFilterType {
 }
 
 input GalleryFilterType {
+  AND: GalleryFilterType
+  OR: GalleryFilterType
+  NOT: GalleryFilterType
+
   """Filter by path"""
   path: StringCriterionInput
   """Filter to only include galleries missing this property"""
@@ -219,6 +223,10 @@ input TagFilterType {
 }
 
 input ImageFilterType {
+  AND: ImageFilterType
+  OR: ImageFilterType
+  NOT: ImageFilterType
+
   """Filter by path"""
   path: StringCriterionInput
   """Filter by rating"""

pkg/autotag/gallery.go

@@ -0,0 +1,117 @@
+package autotag
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/stashapp/stash/pkg/gallery"
+	"github.com/stashapp/stash/pkg/models"
+)
+
+func galleryPathsFilter(paths []string) *models.GalleryFilterType {
+	if paths == nil {
+		return nil
+	}
+
+	sep := string(filepath.Separator)
+
+	var ret *models.GalleryFilterType
+	var or *models.GalleryFilterType
+	for _, p := range paths {
+		newOr := &models.GalleryFilterType{}
+		if or != nil {
+			or.Or = newOr
+		} else {
+			ret = newOr
+		}
+
+		or = newOr
+
+		if !strings.HasSuffix(p, sep) {
+			p = p + sep
+		}
+
+		or.Path = &models.StringCriterionInput{
+			Modifier: models.CriterionModifierEquals,
+			Value:    p + "%",
+		}
+	}
+
+	return ret
+}
+
+func getMatchingGalleries(name string, paths []string, galleryReader models.GalleryReader) ([]*models.Gallery, error) {
+	regex := getPathQueryRegex(name)
+	organized := false
+	filter := models.GalleryFilterType{
+		Path: &models.StringCriterionInput{
+			Value:    "(?i)" + regex,
+			Modifier: models.CriterionModifierMatchesRegex,
+		},
+		Organized: &organized,
+	}
+
+	filter.And = galleryPathsFilter(paths)
+
+	pp := models.PerPageAll
+	gallerys, _, err := galleryReader.Query(&filter, &models.FindFilterType{
+		PerPage: &pp,
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("error querying gallerys with regex '%s': %s", regex, err.Error())
+	}
+
+	var ret []*models.Gallery
+	for _, p := range gallerys {
+		if nameMatchesPath(name, p.Path.String) {
+			ret = append(ret, p)
+		}
+	}
+
+	return ret, nil
+}
+
+func getGalleryFileTagger(s *models.Gallery) tagger {
+	return tagger{
+		ID:   s.ID,
+		Type: "gallery",
+		Name: s.GetTitle(),
+		Path: s.Path.String,
+	}
+}
+
+// GalleryPerformers tags the provided gallery with performers whose name matches the gallery's path.
+func GalleryPerformers(s *models.Gallery, rw models.GalleryReaderWriter, performerReader models.PerformerReader) error {
+	t := getGalleryFileTagger(s)
+
+	return t.tagPerformers(performerReader, func(subjectID, otherID int) (bool, error) {
+		return gallery.AddPerformer(rw, subjectID, otherID)
+	})
+}
+
+// GalleryStudios tags the provided gallery with the first studio whose name matches the gallery's path.
+//
+// Gallerys will not be tagged if studio is already set.
+func GalleryStudios(s *models.Gallery, rw models.GalleryReaderWriter, studioReader models.StudioReader) error {
+	if s.StudioID.Valid {
+		// don't modify
+		return nil
+	}
+
+	t := getGalleryFileTagger(s)
+
+	return t.tagStudios(studioReader, func(subjectID, otherID int) (bool, error) {
+		return addGalleryStudio(rw, subjectID, otherID)
+	})
+}
+
+// GalleryTags tags the provided gallery with tags whose name matches the gallery's path.
+func GalleryTags(s *models.Gallery, rw models.GalleryReaderWriter, tagReader models.TagReader) error {
+	t := getGalleryFileTagger(s)
+
+	return t.tagTags(tagReader, func(subjectID, otherID int) (bool, error) {
+		return gallery.AddTag(rw, subjectID, otherID)
+	})
+}

pkg/autotag/gallery_test.go

@@ -0,0 +1,145 @@
+package autotag
+
+import (
+	"testing"
+
+	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/models/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+const galleryExt = "zip"
+
+func TestGalleryPerformers(t *testing.T) {
+	const galleryID = 1
+	const performerName = "performer name"
+	const performerID = 2
+	performer := models.Performer{
+		ID:   performerID,
+		Name: models.NullString(performerName),
+	}
+
+	const reversedPerformerName = "name performer"
+	const reversedPerformerID = 3
+	reversedPerformer := models.Performer{
+		ID:   reversedPerformerID,
+		Name: models.NullString(reversedPerformerName),
+	}
+
+	testTables := generateTestTable(performerName, galleryExt)
+
+	assert := assert.New(t)
+
+	for _, test := range testTables {
+		mockPerformerReader := &mocks.PerformerReaderWriter{}
+		mockGalleryReader := &mocks.GalleryReaderWriter{}
+
+		mockPerformerReader.On("QueryForAutoTag", mock.Anything).Return([]*models.Performer{&performer, &reversedPerformer}, nil).Once()
+
+		if test.Matches {
+			mockGalleryReader.On("GetPerformerIDs", galleryID).Return(nil, nil).Once()
+			mockGalleryReader.On("UpdatePerformers", galleryID, []int{performerID}).Return(nil).Once()
+		}
+
+		gallery := models.Gallery{
+			ID:   galleryID,
+			Path: models.NullString(test.Path),
+		}
+		err := GalleryPerformers(&gallery, mockGalleryReader, mockPerformerReader)
+
+		assert.Nil(err)
+		mockPerformerReader.AssertExpectations(t)
+		mockGalleryReader.AssertExpectations(t)
+	}
+}
+
+func TestGalleryStudios(t *testing.T) {
+	const galleryID = 1
+	const studioName = "studio name"
+	const studioID = 2
+	studio := models.Studio{
+		ID:   studioID,
+		Name: models.NullString(studioName),
+	}
+
+	const reversedStudioName = "name studio"
+	const reversedStudioID = 3
+	reversedStudio := models.Studio{
+		ID:   reversedStudioID,
+		Name: models.NullString(reversedStudioName),
+	}
+
+	testTables := generateTestTable(studioName, galleryExt)
+
+	assert := assert.New(t)
+
+	for _, test := range testTables {
+		mockStudioReader := &mocks.StudioReaderWriter{}
+		mockGalleryReader := &mocks.GalleryReaderWriter{}
+
+		mockStudioReader.On("QueryForAutoTag", mock.Anything).Return([]*models.Studio{&studio, &reversedStudio}, nil).Once()
+
+		if test.Matches {
+			mockGalleryReader.On("Find", galleryID).Return(&models.Gallery{}, nil).Once()
+			expectedStudioID := models.NullInt64(studioID)
+			mockGalleryReader.On("UpdatePartial", models.GalleryPartial{
+				ID:       galleryID,
+				StudioID: &expectedStudioID,
+			}).Return(nil, nil).Once()
+		}
+
+		gallery := models.Gallery{
+			ID:   galleryID,
+			Path: models.NullString(test.Path),
+		}
+		err := GalleryStudios(&gallery, mockGalleryReader, mockStudioReader)
+
+		assert.Nil(err)
+		mockStudioReader.AssertExpectations(t)
+		mockGalleryReader.AssertExpectations(t)
+	}
+}
+
+func TestGalleryTags(t *testing.T) {
+	const galleryID = 1
+	const tagName = "tag name"
+	const tagID = 2
+	tag := models.Tag{
+		ID:   tagID,
+		Name: tagName,
+	}
+
+	const reversedTagName = "name tag"
+	const reversedTagID = 3
+	reversedTag := models.Tag{
+		ID:   reversedTagID,
+		Name: reversedTagName,
+	}
+
+	testTables := generateTestTable(tagName, galleryExt)
+
+	assert := assert.New(t)
+
+	for _, test := range testTables {
+		mockTagReader := &mocks.TagReaderWriter{}
+		mockGalleryReader := &mocks.GalleryReaderWriter{}
+
+		mockTagReader.On("QueryForAutoTag", mock.Anything).Return([]*models.Tag{&tag, &reversedTag}, nil).Once()
+
+		if test.Matches {
+			mockGalleryReader.On("GetTagIDs", galleryID).Return(nil, nil).Once()
+			mockGalleryReader.On("UpdateTags", galleryID, []int{tagID}).Return(nil).Once()
+		}
+
+		gallery := models.Gallery{
+			ID:   galleryID,
+			Path: models.NullString(test.Path),
+		}
+		err := GalleryTags(&gallery, mockGalleryReader, mockTagReader)
+
+		assert.Nil(err)
+		mockTagReader.AssertExpectations(t)
+		mockGalleryReader.AssertExpectations(t)
+	}
+}