Movies Section (#338)

Co-authored-by: WithoutPants <53250216+WithoutPants@users.noreply.github.com>

pkg/api/context_keys.go

@@ -9,4 +9,5 @@ const (
 	performerKey key = 1
 	sceneKey     key = 2
 	studioKey    key = 3
+	movieKey     key = 4
 )

pkg/api/resolver.go

@@ -33,6 +33,9 @@ func (r *Resolver) SceneMarker() models.SceneMarkerResolver {
 func (r *Resolver) Studio() models.StudioResolver {
 	return &studioResolver{r}
 }
+func (r *Resolver) Movie() models.MovieResolver {
+	return &movieResolver{r}
+}
 func (r *Resolver) Subscription() models.SubscriptionResolver {
 	return &subscriptionResolver{r}
 }
@@ -49,6 +52,7 @@ type performerResolver struct{ *Resolver }
 type sceneResolver struct{ *Resolver }
 type sceneMarkerResolver struct{ *Resolver }
 type studioResolver struct{ *Resolver }
+type movieResolver struct{ *Resolver }
 type tagResolver struct{ *Resolver }
 
 func (r *queryResolver) MarkerWall(ctx context.Context, q *string) ([]*models.SceneMarker, error) {
@@ -95,6 +99,8 @@ func (r *queryResolver) Stats(ctx context.Context) (*models.StatsResultType, err
 	performersCount, _ := performersQB.Count()
 	studiosQB := models.NewStudioQueryBuilder()
 	studiosCount, _ := studiosQB.Count()
+	moviesQB := models.NewMovieQueryBuilder()
+	moviesCount, _ := moviesQB.Count()
 	tagsQB := models.NewTagQueryBuilder()
 	tagsCount, _ := tagsQB.Count()
 	return &models.StatsResultType{
@@ -102,6 +108,7 @@ func (r *queryResolver) Stats(ctx context.Context) (*models.StatsResultType, err
 		GalleryCount:   galleryCount,
 		PerformerCount: performersCount,
 		StudioCount:    studiosCount,
+		MovieCount:     moviesCount,
 		TagCount:       tagsCount,
 	}, nil
 }

pkg/api/resolver_model_movie.go

@@ -0,0 +1,84 @@
+package api
+
+import (
+	"context"
+
+	"github.com/stashapp/stash/pkg/api/urlbuilders"
+	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/utils"
+)
+
+func (r *movieResolver) Name(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Name.Valid {
+		return &obj.Name.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) URL(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.URL.Valid {
+		return &obj.URL.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Aliases(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Aliases.Valid {
+		return &obj.Aliases.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Duration(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Duration.Valid {
+		return &obj.Duration.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Date(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Date.Valid {
+		result := utils.GetYMDFromDatabaseDate(obj.Date.String)
+		return &result, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Rating(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Rating.Valid {
+		return &obj.Rating.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Director(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Director.Valid {
+		return &obj.Director.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) Synopsis(ctx context.Context, obj *models.Movie) (*string, error) {
+	if obj.Synopsis.Valid {
+		return &obj.Synopsis.String, nil
+	}
+	return nil, nil
+}
+
+func (r *movieResolver) FrontImagePath(ctx context.Context, obj *models.Movie) (*string, error) {
+	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
+	frontimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj.ID).GetMovieFrontImageURL()
+	return &frontimagePath, nil
+}
+
+func (r *movieResolver) BackImagePath(ctx context.Context, obj *models.Movie) (*string, error) {
+	baseURL, _ := ctx.Value(BaseURLCtxKey).(string)
+	backimagePath := urlbuilders.NewMovieURLBuilder(baseURL, obj.ID).GetMovieBackImageURL()
+	return &backimagePath, nil
+}
+
+func (r *movieResolver) SceneCount(ctx context.Context, obj *models.Movie) (*int, error) {
+	qb := models.NewSceneQueryBuilder()
+	res, err := qb.CountByMovieID(obj.ID)
+	return &res, err
+}

pkg/api/resolver_model_scene.go

@@ -100,6 +100,31 @@ func (r *sceneResolver) Studio(ctx context.Context, obj *models.Scene) (*models.
 	return qb.FindBySceneID(obj.ID)
 }
 
+func (r *sceneResolver) Movies(ctx context.Context, obj *models.Scene) ([]*models.SceneMovie, error) {
+	joinQB := models.NewJoinsQueryBuilder()
+	qb := models.NewMovieQueryBuilder()
+
+	sceneMovies, err := joinQB.GetSceneMovies(obj.ID, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var ret []*models.SceneMovie
+	for _, sm := range sceneMovies {
+		movie, err := qb.Find(sm.MovieID, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		sceneIdx := sm.SceneIndex
+		ret = append(ret, &models.SceneMovie{
+			Movie:      movie,
+			SceneIndex: &sceneIdx,
+		})
+	}
+	return ret, nil
+}
+
 func (r *sceneResolver) Tags(ctx context.Context, obj *models.Scene) ([]*models.Tag, error) {
 	qb := models.NewTagQueryBuilder()
 	return qb.FindBySceneID(obj.ID, nil)

pkg/api/resolver_mutation_movie.go

@@ -0,0 +1,178 @@
+package api
+
+import (
+	"context"
+	"database/sql"
+	"strconv"
+	"time"
+
+	"github.com/stashapp/stash/pkg/database"
+	"github.com/stashapp/stash/pkg/models"
+	"github.com/stashapp/stash/pkg/utils"
+)
+
+func (r *mutationResolver) MovieCreate(ctx context.Context, input models.MovieCreateInput) (*models.Movie, error) {
+	// generate checksum from movie name rather than image
+	checksum := utils.MD5FromString(input.Name)
+
+	var frontimageData []byte
+	var backimageData []byte
+	var err error
+
+	if input.FrontImage == nil {
+		input.FrontImage = &models.DefaultMovieImage
+	}
+	if input.BackImage == nil {
+		input.BackImage = &models.DefaultMovieImage
+	}
+	// Process the base 64 encoded image string
+	_, frontimageData, err = utils.ProcessBase64Image(*input.FrontImage)
+	if err != nil {
+		return nil, err
+	}
+	// Process the base 64 encoded image string
+	_, backimageData, err = utils.ProcessBase64Image(*input.BackImage)
+	if err != nil {
+		return nil, err
+	}
+
+	// Populate a new movie from the input
+	currentTime := time.Now()
+	newMovie := models.Movie{
+		BackImage:  backimageData,
+		FrontImage: frontimageData,
+		Checksum:   checksum,
+		Name:       sql.NullString{String: input.Name, Valid: true},
+		CreatedAt:  models.SQLiteTimestamp{Timestamp: currentTime},
+		UpdatedAt:  models.SQLiteTimestamp{Timestamp: currentTime},
+	}
+
+	if input.Aliases != nil {
+		newMovie.Aliases = sql.NullString{String: *input.Aliases, Valid: true}
+	}
+	if input.Duration != nil {
+		newMovie.Duration = sql.NullString{String: *input.Duration, Valid: true}
+	}
+
+	if input.Date != nil {
+		newMovie.Date = models.SQLiteDate{String: *input.Date, Valid: true}
+	}
+
+	if input.Rating != nil {
+		newMovie.Rating = sql.NullString{String: *input.Rating, Valid: true}
+	} 
+	
+	if input.Director != nil {
+		newMovie.Director = sql.NullString{String: *input.Director, Valid: true}
+	}
+
+	if input.Synopsis != nil {
+		newMovie.Synopsis = sql.NullString{String: *input.Synopsis, Valid: true}
+	}
+
+	if input.URL != nil {
+		newMovie.URL = sql.NullString{String: *input.URL, Valid: true}
+	}
+
+	// Start the transaction and save the movie
+	tx := database.DB.MustBeginTx(ctx, nil)
+	qb := models.NewMovieQueryBuilder()
+	movie, err := qb.Create(newMovie, tx)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil, err
+	}
+
+	// Commit
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	return movie, nil
+}
+
+func (r *mutationResolver) MovieUpdate(ctx context.Context, input models.MovieUpdateInput) (*models.Movie, error) {
+	// Populate movie from the input
+	movieID, _ := strconv.Atoi(input.ID)
+	updatedMovie := models.Movie{
+		ID:        movieID,
+		UpdatedAt: models.SQLiteTimestamp{Timestamp: time.Now()},
+	}
+	if input.FrontImage != nil {
+		_, frontimageData, err := utils.ProcessBase64Image(*input.FrontImage)
+		if err != nil {
+			return nil, err
+		}
+		updatedMovie.FrontImage = frontimageData
+	}
+	if input.BackImage != nil {
+		_, backimageData, err := utils.ProcessBase64Image(*input.BackImage)
+		if err != nil {
+			return nil, err
+		}
+		updatedMovie.BackImage = backimageData
+	}
+
+	if input.Name != nil {
+		// generate checksum from movie name rather than image
+		checksum := utils.MD5FromString(*input.Name)
+		updatedMovie.Name = sql.NullString{String: *input.Name, Valid: true}
+		updatedMovie.Checksum = checksum
+	}
+
+	if input.Aliases != nil {
+		updatedMovie.Aliases = sql.NullString{String: *input.Aliases, Valid: true}
+	}
+	if input.Duration != nil {
+		updatedMovie.Duration = sql.NullString{String: *input.Duration, Valid: true}
+	}
+
+	if input.Date != nil {
+		updatedMovie.Date = models.SQLiteDate{String: *input.Date, Valid: true}
+	}
+
+	if input.Rating != nil {
+		updatedMovie.Rating = sql.NullString{String: *input.Rating, Valid: true}
+	}
+
+	if input.Director != nil {
+		updatedMovie.Director = sql.NullString{String: *input.Director, Valid: true}
+	}
+
+	if input.Synopsis != nil {
+		updatedMovie.Synopsis = sql.NullString{String: *input.Synopsis, Valid: true}
+	}
+
+	if input.URL != nil {
+		updatedMovie.URL = sql.NullString{String: *input.URL, Valid: true}
+	}
+
+	// Start the transaction and save the movie
+	tx := database.DB.MustBeginTx(ctx, nil)
+	qb := models.NewMovieQueryBuilder()
+	movie, err := qb.Update(updatedMovie, tx)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil, err
+	}
+
+	// Commit
+	if err := tx.Commit(); err != nil {
+		return nil, err
+	}
+
+	return movie, nil
+}
+
+func (r *mutationResolver) MovieDestroy(ctx context.Context, input models.MovieDestroyInput) (bool, error) {
+	qb := models.NewMovieQueryBuilder()
+	tx := database.DB.MustBeginTx(ctx, nil)
+	if err := qb.Destroy(input.ID, tx); err != nil {
+		_ = tx.Rollback()
+		return false, err
+	}
+	if err := tx.Commit(); err != nil {
+		return false, err
+	}
+	return true, nil
+}

pkg/api/resolver_mutation_scene.go

@@ -147,6 +147,28 @@ func (r *mutationResolver) sceneUpdate(input models.SceneUpdateInput, tx *sqlx.T
 		return nil, err
 	}
 
+	// Save the movies
+	var movieJoins []models.MoviesScenes
+
+	for _, movie := range input.Movies {
+
+		movieID, _ := strconv.Atoi(movie.MovieID)
+		sceneIdx := ""
+		if movie.SceneIndex != nil {
+			sceneIdx = *movie.SceneIndex
+		}
+
+		movieJoin := models.MoviesScenes{
+			MovieID:    movieID,
+			SceneID:    sceneID,
+			SceneIndex: sceneIdx,
+		}
+		movieJoins = append(movieJoins, movieJoin)
+	}
+	if err := jqb.UpdateMoviesScenes(sceneID, movieJoins, tx); err != nil {
+		return nil, err
+	}
+
 	// Save the tags
 	var tagJoins []models.ScenesTags
 	for _, tid := range input.TagIds {

pkg/api/resolver_query_find_movie.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/stashapp/stash/pkg/models"
+)
+
+func (r *queryResolver) FindMovie(ctx context.Context, id string) (*models.Movie, error) {
+	qb := models.NewMovieQueryBuilder()
+	idInt, _ := strconv.Atoi(id)
+	return qb.Find(idInt, nil)
+}
+
+func (r *queryResolver) FindMovies(ctx context.Context, filter *models.FindFilterType) (*models.FindMoviesResultType, error) {
+	qb := models.NewMovieQueryBuilder()
+	movies, total := qb.Query(filter)
+	return &models.FindMoviesResultType{
+		Count: total,
+		Movies:  movies,
+	}, nil
+}
+
+func (r *queryResolver) AllMovies(ctx context.Context) ([]*models.Movie, error) {
+	qb := models.NewMovieQueryBuilder()
+	return qb.All()
+}

pkg/api/routes_movie.go

@@ -0,0 +1,54 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"github.com/go-chi/chi"
+	"github.com/stashapp/stash/pkg/models"
+)
+
+type movieRoutes struct{}
+
+func (rs movieRoutes) Routes() chi.Router {
+	r := chi.NewRouter()
+
+	r.Route("/{movieId}", func(r chi.Router) {
+		r.Use(MovieCtx)
+		r.Get("/frontimage", rs.FrontImage)
+		r.Get("/backimage", rs.BackImage)
+	})
+
+	return r
+}
+
+func (rs movieRoutes) FrontImage(w http.ResponseWriter, r *http.Request) {
+	movie := r.Context().Value(movieKey).(*models.Movie)
+	_, _ = w.Write(movie.FrontImage)
+}
+
+func (rs movieRoutes) BackImage(w http.ResponseWriter, r *http.Request) {
+	movie := r.Context().Value(movieKey).(*models.Movie)
+	_, _ = w.Write(movie.BackImage)
+}
+
+func MovieCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		movieID, err := strconv.Atoi(chi.URLParam(r, "movieId"))
+		if err != nil {
+			http.Error(w, http.StatusText(404), 404)
+			return
+		}
+
+		qb := models.NewMovieQueryBuilder()
+		movie, err := qb.Find(movieID, nil)
+		if err != nil {
+			http.Error(w, http.StatusText(404), 404)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), movieKey, movie)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

pkg/api/server.go

@@ -109,6 +109,7 @@ func Start() {
 	r.Mount("/performer", performerRoutes{}.Routes())
 	r.Mount("/scene", sceneRoutes{}.Routes())
 	r.Mount("/studio", studioRoutes{}.Routes())
+	r.Mount("/movie", movieRoutes{}.Routes())
 
 	r.HandleFunc("/css", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/css")

pkg/api/urlbuilders/movie.go

@@ -0,0 +1,24 @@
+package urlbuilders
+
+import "strconv"
+
+type MovieURLBuilder struct {
+	BaseURL  string
+	MovieID string
+}
+
+func NewMovieURLBuilder(baseURL string, movieID int) MovieURLBuilder {
+	return MovieURLBuilder{
+		BaseURL:  baseURL,
+		MovieID: strconv.Itoa(movieID),
+	}
+}
+
+func (b MovieURLBuilder) GetMovieFrontImageURL() string {
+	return b.BaseURL + "/movie/" + b.MovieID + "/frontimage"
+}
+
+func (b MovieURLBuilder) GetMovieBackImageURL() string {
+	return b.BaseURL + "/movie/" + b.MovieID + "/backimage"
+}
+

pkg/database/database.go

@@ -17,7 +17,7 @@ import (
 )
 
 var DB *sqlx.DB
-var appSchemaVersion uint = 3
+var appSchemaVersion uint = 4
 
 const sqlite3Driver = "sqlite3_regexp"
 

pkg/database/migrations/4_movie.up.sql

@@ -0,0 +1,32 @@
+CREATE TABLE `movies` (
+  `id` integer not null primary key autoincrement,
+  `name` varchar(255),
+  `aliases` varchar(255),
+  `duration` varchar(6),
+  `date` date,
+  `rating` varchar(1),
+  `director` varchar(255),
+  `synopsis` text,
+  `front_image` blob not null,
+  `back_image` blob,
+  `checksum` varchar(255) not null,
+  `url` varchar(255),
+  `created_at` datetime not null,
+  `updated_at` datetime not null
+);
+CREATE TABLE `movies_scenes` (
+  `movie_id` integer,
+  `scene_id` integer,
+  `scene_index` varchar(2),
+  foreign key(`movie_id`) references `movies`(`id`),
+  foreign key(`scene_id`) references `scenes`(`id`)
+);
+
+
+ALTER TABLE `scraped_items` ADD COLUMN `movie_id` integer;
+CREATE UNIQUE INDEX `movies_checksum_unique` on `movies` (`checksum`);
+CREATE UNIQUE INDEX `index_movie_id_scene_index_unique` ON `movies_scenes` ( `movie_id`, `scene_index` );
+CREATE INDEX `index_movies_scenes_on_movie_id` on `movies_scenes` (`movie_id`);
+CREATE INDEX `index_movies_scenes_on_scene_id` on `movies_scenes` (`scene_id`);
+
+

pkg/manager/filename_parser.go

@@ -89,6 +89,7 @@ func initParserFields() {
 	ret["d"] = newParserField("d", `(?:\.|-|_)`, false)
 	ret["performer"] = newParserField("performer", ".*", true)
 	ret["studio"] = newParserField("studio", ".*", true)
+	ret["movie"] = newParserField("movie", ".*", true)
 	ret["tag"] = newParserField("tag", ".*", true)
 
 	// date fields
@@ -204,6 +205,7 @@ type sceneHolder struct {
 	mm         string
 	dd         string
 	performers []string
+	movies     []string
 	studio     string
 	tags       []string
 }
@@ -307,6 +309,8 @@ func (h *sceneHolder) setField(field parserField, value interface{}) {
 		h.performers = append(h.performers, value.(string))
 	case "studio":
 		h.studio = value.(string)
+	case "movie":
+		h.movies = append(h.movies, value.(string))
 	case "tag":
 		h.tags = append(h.tags, value.(string))
 	case "yyyy":
@@ -389,6 +393,10 @@ type studioQueryer interface {
 	FindByName(name string, tx *sqlx.Tx) (*models.Studio, error)
 }
 
+type movieQueryer interface {
+	FindByName(name string, tx *sqlx.Tx) (*models.Movie, error)
+}
+
 type SceneFilenameParser struct {
 	Pattern        string
 	ParserInput    models.SceneParserInput
@@ -396,12 +404,14 @@ type SceneFilenameParser struct {
 	whitespaceRE   *regexp.Regexp
 	performerCache map[string]*models.Performer
 	studioCache    map[string]*models.Studio
+	movieCache     map[string]*models.Movie
 	tagCache       map[string]*models.Tag
 
 	performerQuery performerQueryer
 	sceneQuery     sceneQueryer
 	tagQuery       tagQueryer
 	studioQuery    studioQueryer
+	movieQuery     movieQueryer
 }
 
 func NewSceneFilenameParser(filter *models.FindFilterType, config models.SceneParserInput) *SceneFilenameParser {
@@ -413,6 +423,7 @@ func NewSceneFilenameParser(filter *models.FindFilterType, config models.ScenePa
 
 	p.performerCache = make(map[string]*models.Performer)
 	p.studioCache = make(map[string]*models.Studio)
+	p.movieCache = make(map[string]*models.Movie)
 	p.tagCache = make(map[string]*models.Tag)
 
 	p.initWhiteSpaceRegex()
@@ -429,6 +440,9 @@ func NewSceneFilenameParser(filter *models.FindFilterType, config models.ScenePa
 	studioQuery := models.NewStudioQueryBuilder()
 	p.studioQuery = &studioQuery
 
+	movieQuery := models.NewMovieQueryBuilder()
+	p.movieQuery = &movieQuery
+
 	return p
 }
 
@@ -535,6 +549,23 @@ func (p *SceneFilenameParser) queryStudio(studioName string) *models.Studio {
 	return ret
 }
 
+func (p *SceneFilenameParser) queryMovie(movieName string) *models.Movie {
+	// massage the movie name
+	movieName = delimiterRE.ReplaceAllString(movieName, " ")
+
+	// check cache first
+	if ret, found := p.movieCache[movieName]; found {
+		return ret
+	}
+
+	ret, _ := p.movieQuery.FindByName(movieName, nil)
+
+	// add result to cache
+	p.movieCache[movieName] = ret
+
+	return ret
+}
+
 func (p *SceneFilenameParser) queryTag(tagName string) *models.Tag {
 	// massage the performer name
 	tagName = delimiterRE.ReplaceAllString(tagName, " ")
@@ -596,6 +627,24 @@ func (p *SceneFilenameParser) setStudio(h sceneHolder, result *models.SceneParse
 	}
 }
 
+func (p *SceneFilenameParser) setMovies(h sceneHolder, result *models.SceneParserResult) {
+	// query for each movie
+	moviesSet := make(map[int]bool)
+	for _, movieName := range h.movies {
+		if movieName != "" {
+			movie := p.queryMovie(movieName)
+			if movie != nil {
+				if _, found := moviesSet[movie.ID]; !found {
+					result.Movies = append(result.Movies, &models.SceneMovieID{
+						MovieID: strconv.Itoa(movie.ID),
+					})
+					moviesSet[movie.ID] = true
+				}
+			}
+		}
+	}
+}
+
 func (p *SceneFilenameParser) setParserResult(h sceneHolder, result *models.SceneParserResult) {
 	if h.result.Title.Valid {
 		title := h.result.Title.String
@@ -619,4 +668,9 @@ func (p *SceneFilenameParser) setParserResult(h sceneHolder, result *models.Scen
 		p.setTags(h, result)
 	}
 	p.setStudio(h, result)
+
+	if len(h.movies) > 0 {
+		p.setMovies(h, result)
+	}
+
 }

pkg/manager/json_utils.go

@@ -38,6 +38,14 @@ func (jp *jsonUtils) saveStudio(checksum string, studio *jsonschema.Studio) erro
 	return jsonschema.SaveStudioFile(instance.Paths.JSON.StudioJSONPath(checksum), studio)
 }
 
+func (jp *jsonUtils) getMovie(checksum string) (*jsonschema.Movie, error) {
+	return jsonschema.LoadMovieFile(instance.Paths.JSON.MovieJSONPath(checksum))
+}
+
+func (jp *jsonUtils) saveMovie(checksum string, movie *jsonschema.Movie) error {
+	return jsonschema.SaveMovieFile(instance.Paths.JSON.MovieJSONPath(checksum), movie)
+}
+
 func (jp *jsonUtils) getScene(checksum string) (*jsonschema.Scene, error) {
 	return jsonschema.LoadSceneFile(instance.Paths.JSON.SceneJSONPath(checksum))
 }

pkg/manager/jsonschema/mappings.go

@@ -19,6 +19,7 @@ type PathMapping struct {
 type Mappings struct {
 	Performers []NameMapping `json:"performers"`
 	Studios    []NameMapping `json:"studios"`
+	Movies     []NameMapping `json:"movies"`
 	Galleries  []PathMapping `json:"galleries"`
 	Scenes     []PathMapping `json:"scenes"`
 }

pkg/manager/jsonschema/movie.go

@@ -0,0 +1,46 @@
+package jsonschema
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/stashapp/stash/pkg/models"
+)
+
+type Movie struct {
+	Name           string          `json:"name,omitempty"`
+	Aliases        string          `json:"aliases,omitempty"`
+	Duration	   string          `json:"duration,omitempty"`
+	Date    	   string          `json:"date,omitempty"`
+	Rating   	   string          `json:"rating,omitempty"`
+	Director       string          `json:"director,omitempty"`
+	Synopsis       string          `json:"sypnopsis,omitempty"`
+	FrontImage     string          `json:"front_image,omitempty"`
+	BackImage      string          `json:"back_image,omitempty"`
+	URL            string          `json:"url,omitempty"`
+	CreatedAt      models.JSONTime `json:"created_at,omitempty"`
+	UpdatedAt      models.JSONTime `json:"updated_at,omitempty"`
+}
+
+func LoadMovieFile(filePath string) (*Movie, error) {
+	var movie Movie
+	file, err := os.Open(filePath)
+	defer file.Close()
+	if err != nil {
+		return nil, err
+	}
+	jsonParser := json.NewDecoder(file)
+	err = jsonParser.Decode(&movie)
+	if err != nil {
+		return nil, err
+	}
+	return &movie, nil
+}
+
+func SaveMovieFile(filePath string, movie *Movie) error {
+	if movie == nil {
+		return fmt.Errorf("movie must not be nil")
+	}
+	return marshalToFile(filePath, movie)
+}

pkg/manager/jsonschema/scene.go

@@ -3,8 +3,9 @@ package jsonschema
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/stashapp/stash/pkg/models"
 	"os"
+
+	"github.com/stashapp/stash/pkg/models"
 )
 
 type SceneMarker struct {
@@ -27,6 +28,11 @@ type SceneFile struct {
 	Bitrate    int    `json:"bitrate"`
 }
 
+type SceneMovie struct {
+	MovieName  string `json:"movieName,omitempty"`
+	SceneIndex string `json:"scene_index,omitempty"`
+}
+
 type Scene struct {
 	Title      string          `json:"title,omitempty"`
 	Studio     string          `json:"studio,omitempty"`
@@ -36,6 +42,7 @@ type Scene struct {
 	Details    string          `json:"details,omitempty"`
 	Gallery    string          `json:"gallery,omitempty"`
 	Performers []string        `json:"performers,omitempty"`
+	Movies     []SceneMovie    `json:"movies,omitempty"`
 	Tags       []string        `json:"tags,omitempty"`
 	Markers    []SceneMarker   `json:"markers,omitempty"`
 	File       *SceneFile      `json:"file,omitempty"`

pkg/manager/manager.go

@@ -158,5 +158,6 @@ func (s *singleton) RefreshConfig() {
 		_ = utils.EnsureDir(s.Paths.JSON.Scenes)
 		_ = utils.EnsureDir(s.Paths.JSON.Galleries)
 		_ = utils.EnsureDir(s.Paths.JSON.Studios)
+		_ = utils.EnsureDir(s.Paths.JSON.Movies)
 	}
 }

pkg/manager/paths/paths_json.go

@@ -13,6 +13,7 @@ type jsonPaths struct {
 	Scenes     string
 	Galleries  string
 	Studios    string
+	Movies     string
 }
 
 func newJSONPaths() *jsonPaths {
@@ -23,6 +24,7 @@ func newJSONPaths() *jsonPaths {
 	jp.Scenes = filepath.Join(config.GetMetadataPath(), "scenes")
 	jp.Galleries = filepath.Join(config.GetMetadataPath(), "galleries")
 	jp.Studios = filepath.Join(config.GetMetadataPath(), "studios")
+	jp.Movies = filepath.Join(config.GetMetadataPath(), "movies")
 	return &jp
 }
 
@@ -37,3 +39,7 @@ func (jp *jsonPaths) SceneJSONPath(checksum string) string {
 func (jp *jsonPaths) StudioJSONPath(checksum string) string {
 	return filepath.Join(jp.Studios, checksum+".json")
 }
+
+func (jp *jsonPaths) MovieJSONPath(checksum string) string {
+	return filepath.Join(jp.Movies, checksum+".json")
+}

pkg/manager/task_export.go

@@ -3,14 +3,15 @@ package manager
 import (
 	"context"
 	"fmt"
+	"math"
+	"strconv"
+	"sync"
+
 	"github.com/stashapp/stash/pkg/database"
 	"github.com/stashapp/stash/pkg/logger"
 	"github.com/stashapp/stash/pkg/manager/jsonschema"
 	"github.com/stashapp/stash/pkg/models"
 	"github.com/stashapp/stash/pkg/utils"
-	"math"
-	"strconv"
-	"sync"
 )
 
 type ExportTask struct {
@@ -20,7 +21,7 @@ type ExportTask struct {
 
 func (t *ExportTask) Start(wg *sync.WaitGroup) {
 	defer wg.Done()
-	// @manager.total = Scene.count + Gallery.count + Performer.count + Studio.count
+	// @manager.total = Scene.count + Gallery.count + Performer.count + Studio.count + Movie.count
 
 	t.Mappings = &jsonschema.Mappings{}
 	t.Scraped = []jsonschema.ScrapedItem{}
@@ -31,6 +32,7 @@ func (t *ExportTask) Start(wg *sync.WaitGroup) {
 	t.ExportGalleries(ctx)
 	t.ExportPerformers(ctx)
 	t.ExportStudios(ctx)
+	t.ExportMovies(ctx)
 
 	if err := instance.JSON.saveMappings(t.Mappings); err != nil {
 		logger.Errorf("[mappings] failed to save json: %s", err.Error())
@@ -44,10 +46,12 @@ func (t *ExportTask) ExportScenes(ctx context.Context) {
 	defer tx.Commit()
 	qb := models.NewSceneQueryBuilder()
 	studioQB := models.NewStudioQueryBuilder()
+	movieQB := models.NewMovieQueryBuilder()
 	galleryQB := models.NewGalleryQueryBuilder()
 	performerQB := models.NewPerformerQueryBuilder()
 	tagQB := models.NewTagQueryBuilder()
 	sceneMarkerQB := models.NewSceneMarkerQueryBuilder()
+	joinQB := models.NewJoinsQueryBuilder()
 	scenes, err := qb.All()
 	if err != nil {
 		logger.Errorf("[scenes] failed to fetch all scenes: %s", err.Error())
@@ -80,6 +84,7 @@ func (t *ExportTask) ExportScenes(ctx context.Context) {
 		}
 
 		performers, _ := performerQB.FindBySceneID(scene.ID, tx)
+		sceneMovies, _ := joinQB.GetSceneMovies(scene.ID, tx)
 		tags, _ := tagQB.FindBySceneID(scene.ID, tx)
 		sceneMarkers, _ := sceneMarkerQB.FindBySceneID(scene.ID, tx)
 
@@ -135,6 +140,18 @@ func (t *ExportTask) ExportScenes(ctx context.Context) {
 			newSceneJSON.Markers = append(newSceneJSON.Markers, sceneMarkerJSON)
 		}
 
+		for _, sceneMovie := range sceneMovies {
+			movie, _ := movieQB.Find(sceneMovie.MovieID, tx)
+
+			if movie.Name.Valid {
+				sceneMovieJSON := jsonschema.SceneMovie{
+					MovieName:  movie.Name.String,
+					SceneIndex: sceneMovie.SceneIndex,
+				}
+				newSceneJSON.Movies = append(newSceneJSON.Movies, sceneMovieJSON)
+			}
+		}
+
 		newSceneJSON.File = &jsonschema.SceneFile{}
 		if scene.Size.Valid {
 			newSceneJSON.File.Size = scene.Size.String
@@ -328,6 +345,71 @@ func (t *ExportTask) ExportStudios(ctx context.Context) {
 	logger.Infof("[studios] export complete")
 }
 
+func (t *ExportTask) ExportMovies(ctx context.Context) {
+	qb := models.NewMovieQueryBuilder()
+	movies, err := qb.All()
+	if err != nil {
+		logger.Errorf("[movies] failed to fetch all movies: %s", err.Error())
+	}
+
+	logger.Info("[movies] exporting")
+
+	for i, movie := range movies {
+		index := i + 1
+		logger.Progressf("[movies] %d of %d", index, len(movies))
+
+		t.Mappings.Movies = append(t.Mappings.Movies, jsonschema.NameMapping{Name: movie.Name.String, Checksum: movie.Checksum})
+
+		newMovieJSON := jsonschema.Movie{
+			CreatedAt: models.JSONTime{Time: movie.CreatedAt.Timestamp},
+			UpdatedAt: models.JSONTime{Time: movie.UpdatedAt.Timestamp},
+		}
+
+		if movie.Name.Valid {
+			newMovieJSON.Name = movie.Name.String
+		}
+		if movie.Aliases.Valid {
+			newMovieJSON.Aliases = movie.Aliases.String
+		}
+		if movie.Date.Valid {
+			newMovieJSON.Date = utils.GetYMDFromDatabaseDate(movie.Date.String)
+		}
+		if movie.Rating.Valid {
+			newMovieJSON.Rating = movie.Rating.String
+		}
+		if movie.Duration.Valid {
+			newMovieJSON.Duration = movie.Duration.String
+		}
+
+		if movie.Director.Valid {
+			newMovieJSON.Director = movie.Director.String
+		}
+
+		if movie.Synopsis.Valid {
+			newMovieJSON.Synopsis = movie.Synopsis.String
+		}
+
+		if movie.URL.Valid {
+			newMovieJSON.URL = movie.URL.String
+		}
+
+		newMovieJSON.FrontImage = utils.GetBase64StringFromData(movie.FrontImage)
+		newMovieJSON.BackImage = utils.GetBase64StringFromData(movie.BackImage)
+		movieJSON, err := instance.JSON.getMovie(movie.Checksum)
+		if err != nil {
+			logger.Debugf("[movies] error reading movie json: %s", err.Error())
+		} else if jsonschema.CompareJSON(*movieJSON, newMovieJSON) {
+			continue
+		}
+
+		if err := instance.JSON.saveMovie(movie.Checksum, &newMovieJSON); err != nil {
+			logger.Errorf("[movies] <%s> failed to save json: %s", movie.Checksum, err.Error())
+		}
+	}
+
+	logger.Infof("[movies] export complete")
+}
+
 func (t *ExportTask) ExportScrapedItems(ctx context.Context) {
 	tx := database.DB.MustBeginTx(ctx, nil)
 	defer tx.Commit()

pkg/manager/task_import.go

@@ -46,6 +46,7 @@ func (t *ImportTask) Start(wg *sync.WaitGroup) {
 
 	t.ImportPerformers(ctx)
 	t.ImportStudios(ctx)
+	t.ImportMovies(ctx)
 	t.ImportGalleries(ctx)
 	t.ImportTags(ctx)
 
@@ -204,6 +205,72 @@ func (t *ImportTask) ImportStudios(ctx context.Context) {
 	logger.Info("[studios] import complete")
 }
 
+func (t *ImportTask) ImportMovies(ctx context.Context) {
+	tx := database.DB.MustBeginTx(ctx, nil)
+	qb := models.NewMovieQueryBuilder()
+
+	for i, mappingJSON := range t.Mappings.Movies {
+		index := i + 1
+		movieJSON, err := instance.JSON.getMovie(mappingJSON.Checksum)
+		if err != nil {
+			logger.Errorf("[movies] failed to read json: %s", err.Error())
+			continue
+		}
+		if mappingJSON.Checksum == "" || mappingJSON.Name == "" || movieJSON == nil {
+			return
+		}
+
+		logger.Progressf("[movies] %d of %d", index, len(t.Mappings.Movies))
+
+		// generate checksum from movie name rather than image
+		checksum := utils.MD5FromString(movieJSON.Name)
+
+		// Process the base 64 encoded image string
+		_, frontimageData, err := utils.ProcessBase64Image(movieJSON.FrontImage)
+		if err != nil {
+			_ = tx.Rollback()
+			logger.Errorf("[movies] <%s> invalid front_image: %s", mappingJSON.Checksum, err.Error())
+			return
+		}
+		_, backimageData, err := utils.ProcessBase64Image(movieJSON.BackImage)
+		if err != nil {
+			_ = tx.Rollback()
+			logger.Errorf("[movies] <%s> invalid back_image: %s", mappingJSON.Checksum, err.Error())
+			return
+		}
+
+		// Populate a new movie from the input
+		newMovie := models.Movie{
+			FrontImage:  frontimageData,
+			BackImage:   backimageData,
+			Checksum:    checksum,
+			Name:        sql.NullString{String: movieJSON.Name, Valid: true},
+			Aliases:     sql.NullString{String: movieJSON.Aliases, Valid: true},
+			Date:        models.SQLiteDate{String: movieJSON.Date, Valid: true},
+			Duration:    sql.NullString{String: movieJSON.Duration, Valid: true},
+			Rating:      sql.NullString{String: movieJSON.Rating, Valid: true},
+			Director:    sql.NullString{String: movieJSON.Director, Valid: true},
+			Synopsis:    sql.NullString{String: movieJSON.Synopsis, Valid: true},
+			URL:         sql.NullString{String: movieJSON.URL, Valid: true},
+			CreatedAt:   models.SQLiteTimestamp{Timestamp: t.getTimeFromJSONTime(movieJSON.CreatedAt)},
+			UpdatedAt:   models.SQLiteTimestamp{Timestamp: t.getTimeFromJSONTime(movieJSON.UpdatedAt)},
+		}
+
+		_, err = qb.Create(newMovie, tx)
+		if err != nil {
+			_ = tx.Rollback()
+			logger.Errorf("[movies] <%s> failed to create: %s", mappingJSON.Checksum, err.Error())
+			return
+		}
+	}
+
+	logger.Info("[movies] importing")
+	if err := tx.Commit(); err != nil {
+		logger.Errorf("[movies] import failed to commit: %s", err.Error())
+	}
+	logger.Info("[movies] import complete")
+}
+
 func (t *ImportTask) ImportGalleries(ctx context.Context) {
 	tx := database.DB.MustBeginTx(ctx, nil)
 	qb := models.NewGalleryQueryBuilder()
@@ -508,6 +575,18 @@ func (t *ImportTask) ImportScenes(ctx context.Context) {
 			}
 		}
 
+		// Relate the scene to the movies
+		if len(sceneJSON.Movies) > 0 {
+			moviesScenes, err := t.getMoviesScenes(sceneJSON.Movies, scene.ID, tx)
+			if err != nil {
+				logger.Warnf("[scenes] <%s> failed to fetch movies: %s", scene.Checksum, err.Error())
+			} else {
+				if err := jqb.CreateMoviesScenes(moviesScenes, tx); err != nil {
+					logger.Errorf("[scenes] <%s> failed to associate movies: %s", scene.Checksum, err.Error())
+				}
+			}
+		}
+
 		// Relate the scene to the tags
 		if len(sceneJSON.Tags) > 0 {
 			tags, err := t.getTags(scene.Checksum, sceneJSON.Tags, tx)
@@ -614,6 +693,30 @@ func (t *ImportTask) getPerformers(names []string, tx *sqlx.Tx) ([]*models.Perfo
 	return performers, nil
 }
 
+func (t *ImportTask) getMoviesScenes(input []jsonschema.SceneMovie, sceneID int, tx *sqlx.Tx) ([]models.MoviesScenes, error) {
+	mqb := models.NewMovieQueryBuilder()
+
+	var movies []models.MoviesScenes
+	for _, inputMovie := range input {
+		movie, err := mqb.FindByName(inputMovie.MovieName, tx)
+		if err != nil {
+			return nil, err
+		}
+
+		if movie == nil {
+			logger.Warnf("[scenes] movie %s does not exist", inputMovie.MovieName)
+		} else {
+			movies = append(movies, models.MoviesScenes{
+				MovieID:    movie.ID,
+				SceneID:    sceneID,
+				SceneIndex: inputMovie.SceneIndex,
+			})
+		}
+	}
+
+	return movies, nil
+}
+
 func (t *ImportTask) getTags(sceneChecksum string, names []string, tx *sqlx.Tx) ([]*models.Tag, error) {
 	tqb := models.NewTagQueryBuilder()
 	tags, err := tqb.FindByNames(names, tx)

pkg/models/model_joins.go

@@ -5,6 +5,12 @@ type PerformersScenes struct {
 	SceneID     int `db:"scene_id" json:"scene_id"`
 }
 
+type MoviesScenes struct {
+	MovieID    int    `db:"movie_id" json:"movie_id"`
+	SceneID    int    `db:"scene_id" json:"scene_id"`
+	SceneIndex string `db:"scene_index" json:"scene_index"`
+}
+
 type ScenesTags struct {
 	SceneID int `db:"scene_id" json:"scene_id"`
 	TagID   int `db:"tag_id" json:"tag_id"`

pkg/models/model_movie.go

@@ -0,0 +1,24 @@
+package models
+
+import (
+	"database/sql"
+)
+
+type Movie struct {
+	ID          int             `db:"id" json:"id"`
+	FrontImage []byte           `db:"front_image" json:"front_image"`
+	BackImage  []byte           `db:"back_image" json:"back_image"`
+	Checksum    string          `db:"checksum" json:"checksum"`
+	Name        sql.NullString  `db:"name" json:"name"`
+	Aliases     sql.NullString  `db:"aliases" json:"aliases"`
+	Duration    sql.NullString  `db:"duration" json:"duration"`
+	Date        SQLiteDate      `db:"date" json:"date"`
+	Rating      sql.NullString  `db:"rating" json:"rating"`
+	Director    sql.NullString  `db:"director" json:"director"`
+	Synopsis    sql.NullString  `db:"synopsis" json:"synopsis"`
+	URL         sql.NullString  `db:"url" json:"url"`
+	CreatedAt   SQLiteTimestamp `db:"created_at" json:"created_at"`
+	UpdatedAt   SQLiteTimestamp `db:"updated_at" json:"updated_at"`
+}
+
+var DefaultMovieImage string = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAA3XAAAN1wFCKJt4AAAAB3RJTUUH4wgVBQsJl1CMZAAAASJJREFUeNrt3N0JwyAYhlEj3cj9R3Cm5rbkqtAP+qrnGaCYHPwJpLlaa++mmLpbAERAgAgIEAEBIiBABERAgAgIEAEBIiBABERAgAgIEAHZuVflj40x4i94zhk9vqsVvEq6AsQqMP1EjORx20OACAgQRRx7T+zzcFBxcjNDfoB4ntQqTm5Awo7MlqywZxcgYQ+RlqywJ3ozJAQCSBiEJSsQA0gYBpDAgAARECACAkRAgAgIEAERECACAmSjUv6eAOSB8m8YIGGzBUjYbAESBgMkbBkDEjZbgITBAClcxiqQvEoatreYIWEBASIgJ4Gkf11ntXH3nS9uxfGWfJ5J9hAgAgJEQAQEiIAAERAgAgJEQAQEiIAAERAgAgJEQAQEiL7qBuc6RKLHxr0CAAAAAElFTkSuQmCC"

pkg/models/model_scene.go

@@ -48,6 +48,7 @@ type ScenePartial struct {
 	Framerate  *sql.NullFloat64 `db:"framerate" json:"framerate"`
 	Bitrate    *sql.NullInt64   `db:"bitrate" json:"bitrate"`
 	StudioID   *sql.NullInt64   `db:"studio_id,omitempty" json:"studio_id"`
+	MovieID    *sql.NullInt64   `db:"movie_id,omitempty" json:"movie_id"`
 	CreatedAt  *SQLiteTimestamp `db:"created_at" json:"created_at"`
 	UpdatedAt  *SQLiteTimestamp `db:"updated_at" json:"updated_at"`
 }

pkg/models/model_scraped_item.go

@@ -48,6 +48,7 @@ type ScrapedScene struct {
 	Date       *string                  `graphql:"date" json:"date"`
 	File       *SceneFileType           `graphql:"file" json:"file"`
 	Studio     *ScrapedSceneStudio      `graphql:"studio" json:"studio"`
+	Movies     []*ScrapedSceneMovie     `graphql:"movies" json:"movies"`
 	Tags       []*ScrapedSceneTag       `graphql:"tags" json:"tags"`
 	Performers []*ScrapedScenePerformer `graphql:"performers" json:"performers"`
 }
@@ -79,6 +80,19 @@ type ScrapedSceneStudio struct {
 	URL  *string `graphql:"url" json:"url"`
 }
 
+type ScrapedSceneMovie struct {
+	// Set if movie matched
+	ID              *string `graphql:"id" json:"id"`
+	Name            string  `graphql:"name" json:"name"`
+	Aliases         string  `graphql:"aliases" json:"aliases"`
+	Duration	    string  `graphql:"duration" json:"duration"`
+	Date	        string  `graphql:"date" json:"date"`
+	Rating	        string  `graphql:"rating" json:"rating"`
+	Director        string  `graphql:"director" json:"director"`
+	Synopsis        string  `graphql:"synopsis" json:"synopsis"`
+	URL             *string `graphql:"url" json:"url"`
+}
+
 type ScrapedSceneTag struct {
 	// Set if tag matched
 	ID   *string `graphql:"id" json:"id"`

pkg/models/querybuilder_joins.go

@@ -111,6 +111,103 @@ func (qb *JoinsQueryBuilder) DestroyPerformersScenes(sceneID int, tx *sqlx.Tx) e
 	return err
 }
 
+func (qb *JoinsQueryBuilder) GetSceneMovies(sceneID int, tx *sqlx.Tx) ([]MoviesScenes, error) {
+	query := `SELECT * from movies_scenes WHERE scene_id = ?`
+
+	var rows *sqlx.Rows
+	var err error
+	if tx != nil {
+		rows, err = tx.Queryx(query, sceneID)
+	} else {
+		rows, err = database.DB.Queryx(query, sceneID)
+	}
+
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	defer rows.Close()
+
+	movieScenes := make([]MoviesScenes, 0)
+	for rows.Next() {
+		movieScene := MoviesScenes{}
+		if err := rows.StructScan(&movieScene); err != nil {
+			return nil, err
+		}
+		movieScenes = append(movieScenes, movieScene)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return movieScenes, nil
+}
+
+func (qb *JoinsQueryBuilder) CreateMoviesScenes(newJoins []MoviesScenes, tx *sqlx.Tx) error {
+	ensureTx(tx)
+	for _, join := range newJoins {
+		_, err := tx.NamedExec(
+			`INSERT INTO movies_scenes (movie_id, scene_id, scene_index) VALUES (:movie_id, :scene_id, :scene_index)`,
+			join,
+		)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AddMovieScene adds a movie to a scene. It does not make any change
+// if the movie already exists on the scene. It returns true if scene
+// movie was added.
+
+func (qb *JoinsQueryBuilder) AddMoviesScene(sceneID int, movieID int, sceneIdx string, tx *sqlx.Tx) (bool, error) {
+	ensureTx(tx)
+
+	existingMovies, err := qb.GetSceneMovies(sceneID, tx)
+
+	if err != nil {
+		return false, err
+	}
+
+	// ensure not already present
+	for _, p := range existingMovies {
+		if p.MovieID == movieID && p.SceneID == sceneID {
+			return false, nil
+		}
+	}
+
+	movieJoin := MoviesScenes{
+		MovieID:    movieID,
+		SceneID:    sceneID,
+		SceneIndex: sceneIdx,
+	}
+	movieJoins := append(existingMovies, movieJoin)
+
+	err = qb.UpdateMoviesScenes(sceneID, movieJoins, tx)
+
+	return err == nil, err
+}
+
+func (qb *JoinsQueryBuilder) UpdateMoviesScenes(sceneID int, updatedJoins []MoviesScenes, tx *sqlx.Tx) error {
+	ensureTx(tx)
+
+	// Delete the existing joins and then create new ones
+	_, err := tx.Exec("DELETE FROM movies_scenes WHERE scene_id = ?", sceneID)
+	if err != nil {
+		return err
+	}
+	return qb.CreateMoviesScenes(updatedJoins, tx)
+}
+
+func (qb *JoinsQueryBuilder) DestroyMoviesScenes(sceneID int, tx *sqlx.Tx) error {
+	ensureTx(tx)
+
+	// Delete the existing joins
+	_, err := tx.Exec("DELETE FROM movies_scenes WHERE scene_id = ?", sceneID)
+	return err
+}
+
 func (qb *JoinsQueryBuilder) GetSceneTags(sceneID int, tx *sqlx.Tx) ([]ScenesTags, error) {
 	ensureTx(tx)
 

pkg/models/querybuilder_movies.go

@@ -0,0 +1,194 @@
+package models
+
+import (
+	"database/sql"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/stashapp/stash/pkg/database"
+)
+
+type MovieQueryBuilder struct{}
+
+func NewMovieQueryBuilder() MovieQueryBuilder {
+	return MovieQueryBuilder{}
+}
+
+func (qb *MovieQueryBuilder) Create(newMovie Movie, tx *sqlx.Tx) (*Movie, error) {
+	ensureTx(tx)
+	result, err := tx.NamedExec(
+		`INSERT INTO movies (front_image, back_image, checksum, name, aliases, duration, date, rating, director, synopsis, url, created_at, updated_at)
+				VALUES (:front_image, :back_image, :checksum, :name, :aliases, :duration, :date, :rating, :director, :synopsis, :url, :created_at, :updated_at)
+		`,
+		newMovie,
+	)
+	if err != nil {
+		return nil, err
+	}
+	movieID, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Get(&newMovie, `SELECT * FROM movies WHERE id = ? LIMIT 1`, movieID); err != nil {
+		return nil, err
+	}
+	return &newMovie, nil
+}
+
+func (qb *MovieQueryBuilder) Update(updatedMovie Movie, tx *sqlx.Tx) (*Movie, error) {
+	ensureTx(tx)
+	_, err := tx.NamedExec(
+		`UPDATE movies SET `+SQLGenKeys(updatedMovie)+` WHERE movies.id = :id`,
+		updatedMovie,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Get(&updatedMovie, `SELECT * FROM movies WHERE id = ? LIMIT 1`, updatedMovie.ID); err != nil {
+		return nil, err
+	}
+	return &updatedMovie, nil
+}
+
+func (qb *MovieQueryBuilder) Destroy(id string, tx *sqlx.Tx) error {
+	// delete movie from movies_scenes
+
+	_, err := tx.Exec("DELETE FROM movies_scenes WHERE movie_id = ?", id)
+	if err != nil {
+		return err
+	}
+
+	// // remove movie from scraped items
+	// _, err = tx.Exec("UPDATE scraped_items SET movie_id = null WHERE movie_id = ?", id)
+	// if err != nil {
+	// 	return err
+	// }
+
+	return executeDeleteQuery("movies", id, tx)
+}
+
+func (qb *MovieQueryBuilder) Find(id int, tx *sqlx.Tx) (*Movie, error) {
+	query := "SELECT * FROM movies WHERE id = ? LIMIT 1"
+	args := []interface{}{id}
+	return qb.queryMovie(query, args, tx)
+}
+
+func (qb *MovieQueryBuilder) FindBySceneID(sceneID int, tx *sqlx.Tx) ([]*Movie, error) {
+	query := `
+		SELECT movies.* FROM movies
+		LEFT JOIN movies_scenes as scenes_join on scenes_join.movie_id = movies.id
+		LEFT JOIN scenes on scenes_join.scene_id = scenes.id
+		WHERE scenes.id = ?
+		GROUP BY movies.id
+	`
+	args := []interface{}{sceneID}
+	return qb.queryMovies(query, args, tx)
+}
+
+func (qb *MovieQueryBuilder) FindByName(name string, tx *sqlx.Tx) (*Movie, error) {
+	query := "SELECT * FROM movies WHERE name = ? LIMIT 1"
+	args := []interface{}{name}
+	return qb.queryMovie(query, args, tx)
+}
+
+func (qb *MovieQueryBuilder) FindByNames(names []string, tx *sqlx.Tx) ([]*Movie, error) {
+	query := "SELECT * FROM movies WHERE name IN " + getInBinding(len(names))
+	var args []interface{}
+	for _, name := range names {
+		args = append(args, name)
+	}
+	return qb.queryMovies(query, args, tx)
+}
+
+func (qb *MovieQueryBuilder) Count() (int, error) {
+	return runCountQuery(buildCountQuery("SELECT movies.id FROM movies"), nil)
+}
+
+func (qb *MovieQueryBuilder) All() ([]*Movie, error) {
+	return qb.queryMovies(selectAll("movies")+qb.getMovieSort(nil), nil, nil)
+}
+
+func (qb *MovieQueryBuilder) Query(findFilter *FindFilterType) ([]*Movie, int) {
+	if findFilter == nil {
+		findFilter = &FindFilterType{}
+	}
+
+	var whereClauses []string
+	var havingClauses []string
+	var args []interface{}
+	body := selectDistinctIDs("movies")
+	body += `
+	left join movies_scenes as scenes_join on scenes_join.movie_id = movies.id
+	left join scenes on scenes_join.scene_id = scenes.id
+`
+
+	if q := findFilter.Q; q != nil && *q != "" {
+		searchColumns := []string{"movies.name"}
+		clause, thisArgs := getSearchBinding(searchColumns, *q, false)
+		whereClauses = append(whereClauses, clause)
+		args = append(args, thisArgs...)
+	}
+
+	sortAndPagination := qb.getMovieSort(findFilter) + getPagination(findFilter)
+	idsResult, countResult := executeFindQuery("movies", body, args, sortAndPagination, whereClauses, havingClauses)
+
+	var movies []*Movie
+	for _, id := range idsResult {
+		movie, _ := qb.Find(id, nil)
+		movies = append(movies, movie)
+	}
+
+	return movies, countResult
+}
+
+func (qb *MovieQueryBuilder) getMovieSort(findFilter *FindFilterType) string {
+	var sort string
+	var direction string
+	if findFilter == nil {
+		sort = "name"
+		direction = "ASC"
+	} else {
+		sort = findFilter.GetSort("name")
+		direction = findFilter.GetDirection()
+	}
+	return getSort(sort, direction, "movies")
+}
+
+func (qb *MovieQueryBuilder) queryMovie(query string, args []interface{}, tx *sqlx.Tx) (*Movie, error) {
+	results, err := qb.queryMovies(query, args, tx)
+	if err != nil || len(results) < 1 {
+		return nil, err
+	}
+	return results[0], nil
+}
+
+func (qb *MovieQueryBuilder) queryMovies(query string, args []interface{}, tx *sqlx.Tx) ([]*Movie, error) {
+	var rows *sqlx.Rows
+	var err error
+	if tx != nil {
+		rows, err = tx.Queryx(query, args...)
+	} else {
+		rows, err = database.DB.Queryx(query, args...)
+	}
+
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	defer rows.Close()
+
+	movies := make([]*Movie, 0)
+	for rows.Next() {
+		movie := Movie{}
+		if err := rows.StructScan(&movie); err != nil {
+			return nil, err
+		}
+		movies = append(movies, &movie)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return movies, nil
+}

pkg/models/querybuilder_scene.go

@@ -23,6 +23,13 @@ JOIN studios ON studios.id = scenes.studio_id
 WHERE studios.id = ?
 GROUP BY scenes.id
 `
+const scenesForMovieQuery = `
+SELECT scenes.* FROM scenes
+LEFT JOIN movies_scenes as movies_join on movies_join.scene_id = scenes.id
+LEFT JOIN movies on movies_join.movie_id = movies.id
+WHERE movies.id = ?
+GROUP BY scenes.id
+`
 
 const scenesForTagQuery = `
 SELECT scenes.* FROM scenes
@@ -170,6 +177,16 @@ func (qb *SceneQueryBuilder) FindByStudioID(studioID int) ([]*Scene, error) {
 	return qb.queryScenes(scenesForStudioQuery, args, nil)
 }
 
+func (qb *SceneQueryBuilder) FindByMovieID(movieID int) ([]*Scene, error) {
+	args := []interface{}{movieID}
+	return qb.queryScenes(scenesForMovieQuery, args, nil)
+}
+
+func (qb *SceneQueryBuilder) CountByMovieID(movieID int) (int, error) {
+	args := []interface{}{movieID}
+	return runCountQuery(buildCountQuery(scenesForMovieQuery), args)
+}
+
 func (qb *SceneQueryBuilder) Count() (int, error) {
 	return runCountQuery(buildCountQuery("SELECT scenes.id FROM scenes"), nil)
 }
@@ -212,7 +229,9 @@ func (qb *SceneQueryBuilder) Query(sceneFilter *SceneFilterType, findFilter *Fin
 	body = body + `
 		left join scene_markers on scene_markers.scene_id = scenes.id
 		left join performers_scenes as performers_join on performers_join.scene_id = scenes.id
+		left join movies_scenes as movies_join on movies_join.scene_id = scenes.id
 		left join performers on performers_join.performer_id = performers.id
+		left join movies on movies_join.movie_id = movies.id
 		left join studios as studio on studio.id = scenes.studio_id
 		left join galleries as gallery on gallery.scene_id = scenes.id
 		left join scenes_tags as tags_join on tags_join.scene_id = scenes.id
@@ -281,6 +300,8 @@ func (qb *SceneQueryBuilder) Query(sceneFilter *SceneFilterType, findFilter *Fin
 			whereClauses = append(whereClauses, "gallery.scene_id IS NULL")
 		case "studio":
 			whereClauses = append(whereClauses, "scenes.studio_id IS NULL")
+		case "movie":
+			whereClauses = append(whereClauses, "movies_join.scene_id IS NULL")
 		case "performers":
 			whereClauses = append(whereClauses, "performers_join.scene_id IS NULL")
 		case "date":
@@ -320,6 +341,16 @@ func (qb *SceneQueryBuilder) Query(sceneFilter *SceneFilterType, findFilter *Fin
 		havingClauses = appendClause(havingClauses, havingClause)
 	}
 
+	if moviesFilter := sceneFilter.Movies; moviesFilter != nil && len(moviesFilter.Value) > 0 {
+		for _, movieID := range moviesFilter.Value {
+			args = append(args, movieID)
+		}
+
+		whereClause, havingClause := getMultiCriterionClause("movies", "movies_scenes", "movie_id", moviesFilter)
+		whereClauses = appendClause(whereClauses, whereClause)
+		havingClauses = appendClause(havingClauses, havingClause)
+	}
+
 	sortAndPagination := qb.getSceneSort(findFilter) + getPagination(findFilter)
 	idsResult, countResult := executeFindQuery("scenes", body, args, sortAndPagination, whereClauses, havingClauses)
 

pkg/models/querybuilder_sql.go

@@ -118,7 +118,7 @@ func getSort(sort string, direction string, tableName string) string {
 		colName := getColumn(tableName, sort)
 		var additional string
 		if tableName == "scenes" {
-			additional = ", bitrate DESC, framerate DESC, rating DESC, duration DESC"
+			additional = ", bitrate DESC, framerate DESC, scenes.rating DESC, scenes.duration DESC"
 		} else if tableName == "scene_markers" {
 			additional = ", scene_markers.scene_id ASC, scene_markers.seconds ASC"
 		}

pkg/models/querybuilder_tag.go

@@ -33,6 +33,7 @@ func (qb *TagQueryBuilder) Create(newTag Tag, tx *sqlx.Tx) (*Tag, error) {
 	if err := tx.Get(&newTag, `SELECT * FROM tags WHERE id = ? LIMIT 1`, studioID); err != nil {
 		return nil, err
 	}
+	
 	return &newTag, nil
 }
 

pkg/scraper/scrapers.go

@@ -161,6 +161,24 @@ func matchStudio(s *models.ScrapedSceneStudio) error {
 	s.ID = &id
 	return nil
 }
+func matchMovie(m *models.ScrapedSceneMovie) error {
+	qb := models.NewMovieQueryBuilder()
+
+	movies, err := qb.FindByNames([]string{m.Name}, nil)
+
+	if err != nil {
+		return err
+	}
+
+	if len(movies) !=1 {
+		// ignore - cannot match
+		return nil
+	}
+
+	id := strconv.Itoa(movies[0].ID)
+	m.ID = &id
+	return nil
+}
 
 func matchTag(s *models.ScrapedSceneTag) error {
 	qb := models.NewTagQueryBuilder()
@@ -189,6 +207,13 @@ func postScrapeScene(ret *models.ScrapedScene) error {
 		}
 	}
 
+	for _, p := range ret.Movies {
+		err := matchMovie(p)
+		if err != nil {
+			return err
+		}
+	}
+
 	for _, t := range ret.Tags {
 		err := matchTag(t)
 		if err != nil {

pkg/scraper/xpath.go

@@ -265,6 +265,7 @@ const (
 	XPathScraperConfigSceneTags       = "Tags"
 	XPathScraperConfigScenePerformers = "Performers"
 	XPathScraperConfigSceneStudio     = "Studio"
+	XPathScraperConfigSceneMovies     = "Movies"
 )
 
 func (s xpathScraper) GetSceneSimple() xpathScraperConfig {
@@ -274,7 +275,7 @@ func (s xpathScraper) GetSceneSimple() xpathScraperConfig {
 
 	if mapped != nil {
 		for k, v := range mapped {
-			if k != XPathScraperConfigSceneTags && k != XPathScraperConfigScenePerformers && k != XPathScraperConfigSceneStudio {
+			if k != XPathScraperConfigSceneTags && k != XPathScraperConfigScenePerformers && k != XPathScraperConfigSceneStudio && k != XPathScraperConfigSceneMovies {
 				ret[k] = v
 			}
 		}
@@ -313,6 +314,10 @@ func (s xpathScraper) GetSceneStudio() xpathScraperConfig {
 	return s.getSceneSubMap(XPathScraperConfigSceneStudio)
 }
 
+func (s xpathScraper) GetSceneMovies() xpathScraperConfig {
+	return s.getSceneSubMap(XPathScraperConfigSceneMovies)
+}
+
 func (s xpathScraper) scrapePerformer(doc *html.Node) (*models.ScrapedPerformer, error) {
 	var ret models.ScrapedPerformer
 
@@ -358,6 +363,7 @@ func (s xpathScraper) scrapeScene(doc *html.Node) (*models.ScrapedScene, error)
 	scenePerformersMap := s.GetScenePerformers()
 	sceneTagsMap := s.GetSceneTags()
 	sceneStudioMap := s.GetSceneStudio()
+	sceneMoviesMap := s.GetSceneMovies()
 
 	results := sceneMap.process(doc, s.Common)
 	if len(results) > 0 {
@@ -393,6 +399,17 @@ func (s xpathScraper) scrapeScene(doc *html.Node) (*models.ScrapedScene, error)
 				ret.Studio = studio
 			}
 		}
+
+		if sceneMoviesMap != nil {
+			movieResults := sceneMoviesMap.process(doc, s.Common)
+
+			for _, p := range movieResults {
+				movie := &models.ScrapedSceneMovie{}
+				p.apply(movie)
+				ret.Movies = append(ret.Movies, movie)
+			}
+
+		}
 	}
 
 	return &ret, nil