Images section (#813)

* Add new configuration options * Refactor scan/clean * Schema changes * Add details to galleries * Remove redundant code * Refine thumbnail generation * Gallery overhaul * Don't allow modifying zip gallery images * Show gallery card overlays * Hide zoom slider when not in grid mode
2025-12-17 12:24:38 +03:00 · 2020-10-13 10:12:46 +11:00
parent df3252e24f
commit aca2c7c5f4
147 changed files with 12483 additions and 946 deletions
--- a/pkg/gallery/import_test.go
+++ b/pkg/gallery/import_test.go
@@ -3,42 +3,414 @@ package gallery
 import (
 	"errors"
 	"testing"
+	"time"

 	"github.com/stashapp/stash/pkg/manager/jsonschema"
 	"github.com/stashapp/stash/pkg/models"
 	"github.com/stashapp/stash/pkg/models/mocks"
+	"github.com/stashapp/stash/pkg/models/modelstest"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )

 const (
-	galleryPath         = "galleryPath"
-	galleryPathErr      = "galleryPathErr"
-	existingGalleryPath = "existingGalleryPath"
+	galleryNameErr      = "galleryNameErr"
+	existingGalleryName = "existingGalleryName"

-	galleryID         = 1
-	idErr             = 2
-	existingGalleryID = 100
+	existingGalleryID   = 100
+	existingStudioID    = 101
+	existingPerformerID = 103
+	existingTagID       = 105
+
+	existingStudioName = "existingStudioName"
+	existingStudioErr  = "existingStudioErr"
+	missingStudioName  = "missingStudioName"
+
+	existingPerformerName = "existingPerformerName"
+	existingPerformerErr  = "existingPerformerErr"
+	missingPerformerName  = "missingPerformerName"
+
+	existingTagName = "existingTagName"
+	existingTagErr  = "existingTagErr"
+	missingTagName  = "missingTagName"
+
+	errPerformersID = 200
+
+	missingChecksum = "missingChecksum"
+	errChecksum     = "errChecksum"
 )

+var createdAt time.Time = time.Date(2001, time.January, 2, 1, 2, 3, 4, time.Local)
+var updatedAt time.Time = time.Date(2002, time.January, 2, 1, 2, 3, 4, time.Local)
+
 func TestImporterName(t *testing.T) {
 	i := Importer{
-		Input: jsonschema.PathMapping{
-			Path: galleryPath,
+		Input: jsonschema.Gallery{
+			Path: path,
 		},
 	}

-	assert.Equal(t, galleryPath, i.Name())
+	assert.Equal(t, path, i.Name())
 }

 func TestImporterPreImport(t *testing.T) {
 	i := Importer{
-		Input: jsonschema.PathMapping{
-			Path: galleryPath,
+		Input: jsonschema.Gallery{
+			Path:     path,
+			Checksum: checksum,
+			Title:    title,
+			Date:     date,
+			Details:  details,
+			Rating:   rating,
+			URL:      url,
+			CreatedAt: models.JSONTime{
+				Time: createdAt,
+			},
+			UpdatedAt: models.JSONTime{
+				Time: updatedAt,
+			},
 		},
 	}

 	err := i.PreImport()
 	assert.Nil(t, err)
+
+	expectedGallery := models.Gallery{
+		Path:     modelstest.NullString(path),
+		Checksum: checksum,
+		Title:    modelstest.NullString(title),
+		Date: models.SQLiteDate{
+			String: date,
+			Valid:  true,
+		},
+		Details: modelstest.NullString(details),
+		Rating:  modelstest.NullInt64(rating),
+		URL:     modelstest.NullString(url),
+		CreatedAt: models.SQLiteTimestamp{
+			Timestamp: createdAt,
+		},
+		UpdatedAt: models.SQLiteTimestamp{
+			Timestamp: updatedAt,
+		},
+	}
+
+	assert.Equal(t, expectedGallery, i.gallery)
+}
+
+func TestImporterPreImportWithStudio(t *testing.T) {
+	studioReaderWriter := &mocks.StudioReaderWriter{}
+
+	i := Importer{
+		StudioWriter: studioReaderWriter,
+		Input: jsonschema.Gallery{
+			Studio: existingStudioName,
+			Path:   path,
+		},
+	}
+
+	studioReaderWriter.On("FindByName", existingStudioName, false).Return(&models.Studio{
+		ID: existingStudioID,
+	}, nil).Once()
+	studioReaderWriter.On("FindByName", existingStudioErr, false).Return(nil, errors.New("FindByName error")).Once()
+
+	err := i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, int64(existingStudioID), i.gallery.StudioID.Int64)
+
+	i.Input.Studio = existingStudioErr
+	err = i.PreImport()
+	assert.NotNil(t, err)
+
+	studioReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingStudio(t *testing.T) {
+	studioReaderWriter := &mocks.StudioReaderWriter{}
+
+	i := Importer{
+		StudioWriter: studioReaderWriter,
+		Input: jsonschema.Gallery{
+			Path:   path,
+			Studio: missingStudioName,
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+	}
+
+	studioReaderWriter.On("FindByName", missingStudioName, false).Return(nil, nil).Times(3)
+	studioReaderWriter.On("Create", mock.AnythingOfType("models.Studio")).Return(&models.Studio{
+		ID: existingStudioID,
+	}, nil)
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumIgnore
+	err = i.PreImport()
+	assert.Nil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumCreate
+	err = i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, int64(existingStudioID), i.gallery.StudioID.Int64)
+
+	studioReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingStudioCreateErr(t *testing.T) {
+	studioReaderWriter := &mocks.StudioReaderWriter{}
+
+	i := Importer{
+		StudioWriter: studioReaderWriter,
+		Input: jsonschema.Gallery{
+			Path:   path,
+			Studio: missingStudioName,
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumCreate,
+	}
+
+	studioReaderWriter.On("FindByName", missingStudioName, false).Return(nil, nil).Once()
+	studioReaderWriter.On("Create", mock.AnythingOfType("models.Studio")).Return(nil, errors.New("Create error"))
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+}
+
+func TestImporterPreImportWithPerformer(t *testing.T) {
+	performerReaderWriter := &mocks.PerformerReaderWriter{}
+
+	i := Importer{
+		PerformerWriter:     performerReaderWriter,
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Performers: []string{
+				existingPerformerName,
+			},
+		},
+	}
+
+	performerReaderWriter.On("FindByNames", []string{existingPerformerName}, false).Return([]*models.Performer{
+		{
+			ID:   existingPerformerID,
+			Name: modelstest.NullString(existingPerformerName),
+		},
+	}, nil).Once()
+	performerReaderWriter.On("FindByNames", []string{existingPerformerErr}, false).Return(nil, errors.New("FindByNames error")).Once()
+
+	err := i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingPerformerID, i.performers[0].ID)
+
+	i.Input.Performers = []string{existingPerformerErr}
+	err = i.PreImport()
+	assert.NotNil(t, err)
+
+	performerReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingPerformer(t *testing.T) {
+	performerReaderWriter := &mocks.PerformerReaderWriter{}
+
+	i := Importer{
+		PerformerWriter: performerReaderWriter,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Performers: []string{
+				missingPerformerName,
+			},
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+	}
+
+	performerReaderWriter.On("FindByNames", []string{missingPerformerName}, false).Return(nil, nil).Times(3)
+	performerReaderWriter.On("Create", mock.AnythingOfType("models.Performer")).Return(&models.Performer{
+		ID: existingPerformerID,
+	}, nil)
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumIgnore
+	err = i.PreImport()
+	assert.Nil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumCreate
+	err = i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingPerformerID, i.performers[0].ID)
+
+	performerReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingPerformerCreateErr(t *testing.T) {
+	performerReaderWriter := &mocks.PerformerReaderWriter{}
+
+	i := Importer{
+		PerformerWriter: performerReaderWriter,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Performers: []string{
+				missingPerformerName,
+			},
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumCreate,
+	}
+
+	performerReaderWriter.On("FindByNames", []string{missingPerformerName}, false).Return(nil, nil).Once()
+	performerReaderWriter.On("Create", mock.AnythingOfType("models.Performer")).Return(nil, errors.New("Create error"))
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+}
+
+func TestImporterPreImportWithTag(t *testing.T) {
+	tagReaderWriter := &mocks.TagReaderWriter{}
+
+	i := Importer{
+		TagWriter:           tagReaderWriter,
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Tags: []string{
+				existingTagName,
+			},
+		},
+	}
+
+	tagReaderWriter.On("FindByNames", []string{existingTagName}, false).Return([]*models.Tag{
+		{
+			ID:   existingTagID,
+			Name: existingTagName,
+		},
+	}, nil).Once()
+	tagReaderWriter.On("FindByNames", []string{existingTagErr}, false).Return(nil, errors.New("FindByNames error")).Once()
+
+	err := i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingTagID, i.tags[0].ID)
+
+	i.Input.Tags = []string{existingTagErr}
+	err = i.PreImport()
+	assert.NotNil(t, err)
+
+	tagReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingTag(t *testing.T) {
+	tagReaderWriter := &mocks.TagReaderWriter{}
+
+	i := Importer{
+		TagWriter: tagReaderWriter,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Tags: []string{
+				missingTagName,
+			},
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumFail,
+	}
+
+	tagReaderWriter.On("FindByNames", []string{missingTagName}, false).Return(nil, nil).Times(3)
+	tagReaderWriter.On("Create", mock.AnythingOfType("models.Tag")).Return(&models.Tag{
+		ID: existingTagID,
+	}, nil)
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumIgnore
+	err = i.PreImport()
+	assert.Nil(t, err)
+
+	i.MissingRefBehaviour = models.ImportMissingRefEnumCreate
+	err = i.PreImport()
+	assert.Nil(t, err)
+	assert.Equal(t, existingTagID, i.tags[0].ID)
+
+	tagReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
+	tagReaderWriter := &mocks.TagReaderWriter{}
+
+	i := Importer{
+		TagWriter: tagReaderWriter,
+		Input: jsonschema.Gallery{
+			Path: path,
+			Tags: []string{
+				missingTagName,
+			},
+		},
+		MissingRefBehaviour: models.ImportMissingRefEnumCreate,
+	}
+
+	tagReaderWriter.On("FindByNames", []string{missingTagName}, false).Return(nil, nil).Once()
+	tagReaderWriter.On("Create", mock.AnythingOfType("models.Tag")).Return(nil, errors.New("Create error"))
+
+	err := i.PreImport()
+	assert.NotNil(t, err)
+}
+
+func TestImporterPostImportUpdatePerformers(t *testing.T) {
+	joinReaderWriter := &mocks.JoinReaderWriter{}
+
+	i := Importer{
+		JoinWriter: joinReaderWriter,
+		performers: []*models.Performer{
+			{
+				ID: existingPerformerID,
+			},
+		},
+	}
+
+	updateErr := errors.New("UpdatePerformersGalleries error")
+
+	joinReaderWriter.On("UpdatePerformersGalleries", galleryID, []models.PerformersGalleries{
+		{
+			PerformerID: existingPerformerID,
+			GalleryID:   galleryID,
+		},
+	}).Return(nil).Once()
+	joinReaderWriter.On("UpdatePerformersGalleries", errPerformersID, mock.AnythingOfType("[]models.PerformersGalleries")).Return(updateErr).Once()
+
+	err := i.PostImport(galleryID)
+	assert.Nil(t, err)
+
+	err = i.PostImport(errPerformersID)
+	assert.NotNil(t, err)
+
+	joinReaderWriter.AssertExpectations(t)
+}
+
+func TestImporterPostImportUpdateTags(t *testing.T) {
+	joinReaderWriter := &mocks.JoinReaderWriter{}
+
+	i := Importer{
+		JoinWriter: joinReaderWriter,
+		tags: []*models.Tag{
+			{
+				ID: existingTagID,
+			},
+		},
+	}
+
+	updateErr := errors.New("UpdateGalleriesTags error")
+
+	joinReaderWriter.On("UpdateGalleriesTags", galleryID, []models.GalleriesTags{
+		{
+			TagID:     existingTagID,
+			GalleryID: galleryID,
+		},
+	}).Return(nil).Once()
+	joinReaderWriter.On("UpdateGalleriesTags", errTagsID, mock.AnythingOfType("[]models.GalleriesTags")).Return(updateErr).Once()
+
+	err := i.PostImport(galleryID)
+	assert.Nil(t, err)
+
+	err = i.PostImport(errTagsID)
+	assert.NotNil(t, err)
+
+	joinReaderWriter.AssertExpectations(t)
 }

 func TestImporterFindExistingID(t *testing.T) {
@@ -46,28 +418,29 @@ func TestImporterFindExistingID(t *testing.T) {

 	i := Importer{
 		ReaderWriter: readerWriter,
-		Input: jsonschema.PathMapping{
-			Path: galleryPath,
+		Input: jsonschema.Gallery{
+			Path:     path,
+			Checksum: missingChecksum,
 		},
 	}

-	errFindByPath := errors.New("FindByPath error")
-	readerWriter.On("FindByPath", galleryPath).Return(nil, nil).Once()
-	readerWriter.On("FindByPath", existingGalleryPath).Return(&models.Gallery{
+	expectedErr := errors.New("FindBy* error")
+	readerWriter.On("FindByChecksum", missingChecksum).Return(nil, nil).Once()
+	readerWriter.On("FindByChecksum", checksum).Return(&models.Gallery{
 		ID: existingGalleryID,
 	}, nil).Once()
-	readerWriter.On("FindByPath", galleryPathErr).Return(nil, errFindByPath).Once()
+	readerWriter.On("FindByChecksum", errChecksum).Return(nil, expectedErr).Once()

 	id, err := i.FindExistingID()
 	assert.Nil(t, id)
 	assert.Nil(t, err)

-	i.Input.Path = existingGalleryPath
+	i.Input.Checksum = checksum
 	id, err = i.FindExistingID()
 	assert.Equal(t, existingGalleryID, *id)
 	assert.Nil(t, err)

-	i.Input.Path = galleryPathErr
+	i.Input.Checksum = errChecksum
 	id, err = i.FindExistingID()
 	assert.Nil(t, id)
 	assert.NotNil(t, err)
@@ -79,11 +452,11 @@ func TestCreate(t *testing.T) {
 	readerWriter := &mocks.GalleryReaderWriter{}

 	gallery := models.Gallery{
-		Path: galleryPath,
+		Title: modelstest.NullString(title),
 	}

 	galleryErr := models.Gallery{
-		Path: galleryPathErr,
+		Title: modelstest.NullString(galleryNameErr),
 	}

 	i := Importer{
@@ -113,11 +486,7 @@ func TestUpdate(t *testing.T) {
 	readerWriter := &mocks.GalleryReaderWriter{}

 	gallery := models.Gallery{
-		Path: galleryPath,
-	}
-
-	galleryErr := models.Gallery{
-		Path: galleryPathErr,
+		Title: modelstest.NullString(title),
 	}

 	i := Importer{
@@ -125,8 +494,6 @@ func TestUpdate(t *testing.T) {
 		gallery:      gallery,
 	}

-	errUpdate := errors.New("Update error")
-
 	// id needs to be set for the mock input
 	gallery.ID = galleryID
 	readerWriter.On("Update", gallery).Return(nil, nil).Once()
@@ -134,14 +501,5 @@ func TestUpdate(t *testing.T) {
 	err := i.Update(galleryID)
 	assert.Nil(t, err)

-	i.gallery = galleryErr
-
-	// need to set id separately
-	galleryErr.ID = idErr
-	readerWriter.On("Update", galleryErr).Return(nil, errUpdate).Once()
-
-	err = i.Update(idErr)
-	assert.NotNil(t, err)
-
 	readerWriter.AssertExpectations(t)
 }