mirror of https://github.com/stashapp/stash.git
1002 lines
25 KiB
Go
1002 lines
25 KiB
Go
package models
|
|
|
|
import (
|
|
"database/sql"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/stashapp/stash/pkg/database"
|
|
)
|
|
|
|
type JoinsQueryBuilder struct{}
|
|
|
|
func NewJoinsQueryBuilder() JoinsQueryBuilder {
|
|
return JoinsQueryBuilder{}
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetScenePerformers(sceneID int, tx *sqlx.Tx) ([]PerformersScenes, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from performers_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()
|
|
|
|
performerScenes := make([]PerformersScenes, 0)
|
|
for rows.Next() {
|
|
performerScene := PerformersScenes{}
|
|
if err := rows.StructScan(&performerScene); err != nil {
|
|
return nil, err
|
|
}
|
|
performerScenes = append(performerScenes, performerScene)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return performerScenes, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreatePerformersScenes(newJoins []PerformersScenes, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO performers_scenes (performer_id, scene_id) VALUES (:performer_id, :scene_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddPerformerScene adds a performer to a scene. It does not make any change
|
|
// if the performer already exists on the scene. It returns true if scene
|
|
// performer was added.
|
|
func (qb *JoinsQueryBuilder) AddPerformerScene(sceneID int, performerID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingPerformers, err := qb.GetScenePerformers(sceneID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingPerformers {
|
|
if p.PerformerID == performerID && p.SceneID == sceneID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
performerJoin := PerformersScenes{
|
|
PerformerID: performerID,
|
|
SceneID: sceneID,
|
|
}
|
|
performerJoins := append(existingPerformers, performerJoin)
|
|
|
|
err = qb.UpdatePerformersScenes(sceneID, performerJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdatePerformersScenes(sceneID int, updatedJoins []PerformersScenes, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM performers_scenes WHERE scene_id = ?", sceneID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreatePerformersScenes(updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyPerformersScenes(sceneID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM performers_scenes WHERE scene_id = ?", sceneID)
|
|
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 *int, 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,
|
|
}
|
|
|
|
if sceneIdx != nil {
|
|
movieJoin.SceneIndex = sql.NullInt64{
|
|
Int64: int64(*sceneIdx),
|
|
Valid: true,
|
|
}
|
|
}
|
|
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)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from scenes_tags 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()
|
|
|
|
sceneTags := make([]ScenesTags, 0)
|
|
for rows.Next() {
|
|
sceneTag := ScenesTags{}
|
|
if err := rows.StructScan(&sceneTag); err != nil {
|
|
return nil, err
|
|
}
|
|
sceneTags = append(sceneTags, sceneTag)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return sceneTags, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateScenesTags(newJoins []ScenesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO scenes_tags (scene_id, tag_id) VALUES (:scene_id, :tag_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateScenesTags(sceneID int, updatedJoins []ScenesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM scenes_tags WHERE scene_id = ?", sceneID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateScenesTags(updatedJoins, tx)
|
|
}
|
|
|
|
// AddSceneTag adds a tag to a scene. It does not make any change if the tag
|
|
// already exists on the scene. It returns true if scene tag was added.
|
|
func (qb *JoinsQueryBuilder) AddSceneTag(sceneID int, tagID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingTags, err := qb.GetSceneTags(sceneID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingTags {
|
|
if p.TagID == tagID && p.SceneID == sceneID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
tagJoin := ScenesTags{
|
|
TagID: tagID,
|
|
SceneID: sceneID,
|
|
}
|
|
tagJoins := append(existingTags, tagJoin)
|
|
|
|
err = qb.UpdateScenesTags(sceneID, tagJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyScenesTags(sceneID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM scenes_tags WHERE scene_id = ?", sceneID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateSceneMarkersTags(newJoins []SceneMarkersTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO scene_markers_tags (scene_marker_id, tag_id) VALUES (:scene_marker_id, :tag_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateSceneMarkersTags(sceneMarkerID int, updatedJoins []SceneMarkersTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM scene_markers_tags WHERE scene_marker_id = ?", sceneMarkerID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateSceneMarkersTags(updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroySceneMarkersTags(sceneMarkerID int, updatedJoins []SceneMarkersTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM scene_markers_tags WHERE scene_marker_id = ?", sceneMarkerID)
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyScenesGalleries(sceneID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Unset the existing scene id from galleries
|
|
_, err := tx.Exec("UPDATE galleries SET scene_id = null WHERE scene_id = ?", sceneID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyScenesMarkers(sceneID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the scene marker tags
|
|
_, err := tx.Exec("DELETE t FROM scene_markers_tags t join scene_markers m on t.scene_marker_id = m.id WHERE m.scene_id = ?", sceneID)
|
|
|
|
// Delete the existing joins
|
|
_, err = tx.Exec("DELETE FROM scene_markers WHERE scene_id = ?", sceneID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateStashIDs(entityName string, entityID int, newJoins []StashID, tx *sqlx.Tx) error {
|
|
query := "INSERT INTO " + entityName + "_stash_ids (" + entityName + "_id, endpoint, stash_id) VALUES (?, ?, ?)"
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.Exec(query, entityID, join.Endpoint, join.StashID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetImagePerformers(imageID int, tx *sqlx.Tx) ([]PerformersImages, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from performers_images WHERE image_id = ?`
|
|
|
|
var rows *sqlx.Rows
|
|
var err error
|
|
if tx != nil {
|
|
rows, err = tx.Queryx(query, imageID)
|
|
} else {
|
|
rows, err = database.DB.Queryx(query, imageID)
|
|
}
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
performerImages := make([]PerformersImages, 0)
|
|
for rows.Next() {
|
|
performerImage := PerformersImages{}
|
|
if err := rows.StructScan(&performerImage); err != nil {
|
|
return nil, err
|
|
}
|
|
performerImages = append(performerImages, performerImage)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return performerImages, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreatePerformersImages(newJoins []PerformersImages, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO performers_images (performer_id, image_id) VALUES (:performer_id, :image_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddPerformerImage adds a performer to a image. It does not make any change
|
|
// if the performer already exists on the image. It returns true if image
|
|
// performer was added.
|
|
func (qb *JoinsQueryBuilder) AddPerformerImage(imageID int, performerID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingPerformers, err := qb.GetImagePerformers(imageID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingPerformers {
|
|
if p.PerformerID == performerID && p.ImageID == imageID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
performerJoin := PerformersImages{
|
|
PerformerID: performerID,
|
|
ImageID: imageID,
|
|
}
|
|
performerJoins := append(existingPerformers, performerJoin)
|
|
|
|
err = qb.UpdatePerformersImages(imageID, performerJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdatePerformersImages(imageID int, updatedJoins []PerformersImages, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM performers_images WHERE image_id = ?", imageID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreatePerformersImages(updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyPerformersImages(imageID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM performers_images WHERE image_id = ?", imageID)
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetImageTags(imageID int, tx *sqlx.Tx) ([]ImagesTags, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from images_tags WHERE image_id = ?`
|
|
|
|
var rows *sqlx.Rows
|
|
var err error
|
|
if tx != nil {
|
|
rows, err = tx.Queryx(query, imageID)
|
|
} else {
|
|
rows, err = database.DB.Queryx(query, imageID)
|
|
}
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
imageTags := make([]ImagesTags, 0)
|
|
for rows.Next() {
|
|
imageTag := ImagesTags{}
|
|
if err := rows.StructScan(&imageTag); err != nil {
|
|
return nil, err
|
|
}
|
|
imageTags = append(imageTags, imageTag)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return imageTags, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateImagesTags(newJoins []ImagesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO images_tags (image_id, tag_id) VALUES (:image_id, :tag_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateImagesTags(imageID int, updatedJoins []ImagesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM images_tags WHERE image_id = ?", imageID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateImagesTags(updatedJoins, tx)
|
|
}
|
|
|
|
// AddImageTag adds a tag to a image. It does not make any change if the tag
|
|
// already exists on the image. It returns true if image tag was added.
|
|
func (qb *JoinsQueryBuilder) AddImageTag(imageID int, tagID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingTags, err := qb.GetImageTags(imageID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingTags {
|
|
if p.TagID == tagID && p.ImageID == imageID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
tagJoin := ImagesTags{
|
|
TagID: tagID,
|
|
ImageID: imageID,
|
|
}
|
|
tagJoins := append(existingTags, tagJoin)
|
|
|
|
err = qb.UpdateImagesTags(imageID, tagJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyImagesTags(imageID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM images_tags WHERE image_id = ?", imageID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetImageGalleries(imageID int, tx *sqlx.Tx) ([]GalleriesImages, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from galleries_images WHERE image_id = ?`
|
|
|
|
var rows *sqlx.Rows
|
|
var err error
|
|
if tx != nil {
|
|
rows, err = tx.Queryx(query, imageID)
|
|
} else {
|
|
rows, err = database.DB.Queryx(query, imageID)
|
|
}
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
galleryImages := make([]GalleriesImages, 0)
|
|
for rows.Next() {
|
|
galleriesImages := GalleriesImages{}
|
|
if err := rows.StructScan(&galleriesImages); err != nil {
|
|
return nil, err
|
|
}
|
|
galleryImages = append(galleryImages, galleriesImages)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return galleryImages, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateGalleriesImages(newJoins []GalleriesImages, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO galleries_images (gallery_id, image_id) VALUES (:gallery_id, :image_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateGalleriesImages(imageID int, updatedJoins []GalleriesImages, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM galleries_images WHERE image_id = ?", imageID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateGalleriesImages(updatedJoins, tx)
|
|
}
|
|
|
|
// AddGalleryImage adds a gallery to an image. It does not make any change if the tag
|
|
// already exists on the image. It returns true if image tag was added.
|
|
func (qb *JoinsQueryBuilder) AddImageGallery(imageID int, galleryID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingGalleries, err := qb.GetImageGalleries(imageID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingGalleries {
|
|
if p.GalleryID == galleryID && p.ImageID == imageID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
galleryJoin := GalleriesImages{
|
|
GalleryID: galleryID,
|
|
ImageID: imageID,
|
|
}
|
|
galleryJoins := append(existingGalleries, galleryJoin)
|
|
|
|
err = qb.UpdateGalleriesImages(imageID, galleryJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
// RemoveImageGallery removes a gallery from an image. Returns true if the join
|
|
// was removed.
|
|
func (qb *JoinsQueryBuilder) RemoveImageGallery(imageID int, galleryID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingGalleries, err := qb.GetImageGalleries(imageID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// remove the join
|
|
var updatedJoins []GalleriesImages
|
|
found := false
|
|
for _, p := range existingGalleries {
|
|
if p.GalleryID == galleryID && p.ImageID == imageID {
|
|
found = true
|
|
continue
|
|
}
|
|
|
|
updatedJoins = append(updatedJoins, p)
|
|
}
|
|
|
|
if found {
|
|
err = qb.UpdateGalleriesImages(imageID, updatedJoins, tx)
|
|
}
|
|
|
|
return found && err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyImageGalleries(imageID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM galleries_images WHERE image_id = ?", imageID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetGalleryPerformers(galleryID int, tx *sqlx.Tx) ([]PerformersGalleries, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from performers_galleries WHERE gallery_id = ?`
|
|
|
|
var rows *sqlx.Rows
|
|
var err error
|
|
if tx != nil {
|
|
rows, err = tx.Queryx(query, galleryID)
|
|
} else {
|
|
rows, err = database.DB.Queryx(query, galleryID)
|
|
}
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
performerGalleries := make([]PerformersGalleries, 0)
|
|
for rows.Next() {
|
|
performerGallery := PerformersGalleries{}
|
|
if err := rows.StructScan(&performerGallery); err != nil {
|
|
return nil, err
|
|
}
|
|
performerGalleries = append(performerGalleries, performerGallery)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return performerGalleries, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreatePerformersGalleries(newJoins []PerformersGalleries, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO performers_galleries (performer_id, gallery_id) VALUES (:performer_id, :gallery_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddPerformerGallery adds a performer to a gallery. It does not make any change
|
|
// if the performer already exists on the gallery. It returns true if gallery
|
|
// performer was added.
|
|
func (qb *JoinsQueryBuilder) AddPerformerGallery(galleryID int, performerID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingPerformers, err := qb.GetGalleryPerformers(galleryID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingPerformers {
|
|
if p.PerformerID == performerID && p.GalleryID == galleryID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
performerJoin := PerformersGalleries{
|
|
PerformerID: performerID,
|
|
GalleryID: galleryID,
|
|
}
|
|
performerJoins := append(existingPerformers, performerJoin)
|
|
|
|
err = qb.UpdatePerformersGalleries(galleryID, performerJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdatePerformersGalleries(galleryID int, updatedJoins []PerformersGalleries, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM performers_galleries WHERE gallery_id = ?", galleryID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreatePerformersGalleries(updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyPerformersGalleries(galleryID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM performers_galleries WHERE gallery_id = ?", galleryID)
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetGalleryTags(galleryID int, tx *sqlx.Tx) ([]GalleriesTags, error) {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
query := `SELECT * from galleries_tags WHERE gallery_id = ?`
|
|
|
|
var rows *sqlx.Rows
|
|
var err error
|
|
if tx != nil {
|
|
rows, err = tx.Queryx(query, galleryID)
|
|
} else {
|
|
rows, err = database.DB.Queryx(query, galleryID)
|
|
}
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
galleryTags := make([]GalleriesTags, 0)
|
|
for rows.Next() {
|
|
galleryTag := GalleriesTags{}
|
|
if err := rows.StructScan(&galleryTag); err != nil {
|
|
return nil, err
|
|
}
|
|
galleryTags = append(galleryTags, galleryTag)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return galleryTags, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) CreateGalleriesTags(newJoins []GalleriesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
for _, join := range newJoins {
|
|
_, err := tx.NamedExec(
|
|
`INSERT INTO galleries_tags (gallery_id, tag_id) VALUES (:gallery_id, :tag_id)`,
|
|
join,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateGalleriesTags(galleryID int, updatedJoins []GalleriesTags, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins and then create new ones
|
|
_, err := tx.Exec("DELETE FROM galleries_tags WHERE gallery_id = ?", galleryID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateGalleriesTags(updatedJoins, tx)
|
|
}
|
|
|
|
// AddGalleryTag adds a tag to a gallery. It does not make any change if the tag
|
|
// already exists on the gallery. It returns true if gallery tag was added.
|
|
func (qb *JoinsQueryBuilder) AddGalleryTag(galleryID int, tagID int, tx *sqlx.Tx) (bool, error) {
|
|
ensureTx(tx)
|
|
|
|
existingTags, err := qb.GetGalleryTags(galleryID, tx)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// ensure not already present
|
|
for _, p := range existingTags {
|
|
if p.TagID == tagID && p.GalleryID == galleryID {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
tagJoin := GalleriesTags{
|
|
TagID: tagID,
|
|
GalleryID: galleryID,
|
|
}
|
|
tagJoins := append(existingTags, tagJoin)
|
|
|
|
err = qb.UpdateGalleriesTags(galleryID, tagJoins, tx)
|
|
|
|
return err == nil, err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) DestroyGalleriesTags(galleryID int, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
// Delete the existing joins
|
|
_, err := tx.Exec("DELETE FROM galleries_tags WHERE gallery_id = ?", galleryID)
|
|
|
|
return err
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetSceneStashIDs(sceneID int) ([]*StashID, error) {
|
|
rows, err := database.DB.Queryx(`SELECT stash_id, endpoint from scene_stash_ids WHERE scene_id = ?`, sceneID)
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
stashIDs := []*StashID{}
|
|
for rows.Next() {
|
|
stashID := StashID{}
|
|
if err := rows.StructScan(&stashID); err != nil {
|
|
return nil, err
|
|
}
|
|
stashIDs = append(stashIDs, &stashID)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return stashIDs, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetPerformerStashIDs(performerID int) ([]*StashID, error) {
|
|
rows, err := database.DB.Queryx(`SELECT stash_id, endpoint from performer_stash_ids WHERE performer_id = ?`, performerID)
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
stashIDs := []*StashID{}
|
|
for rows.Next() {
|
|
stashID := StashID{}
|
|
if err := rows.StructScan(&stashID); err != nil {
|
|
return nil, err
|
|
}
|
|
stashIDs = append(stashIDs, &stashID)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return stashIDs, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) GetStudioStashIDs(studioID int) ([]*StashID, error) {
|
|
rows, err := database.DB.Queryx(`SELECT stash_id, endpoint from studio_stash_ids WHERE studio_id = ?`, studioID)
|
|
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
|
|
stashIDs := []*StashID{}
|
|
for rows.Next() {
|
|
stashID := StashID{}
|
|
if err := rows.StructScan(&stashID); err != nil {
|
|
return nil, err
|
|
}
|
|
stashIDs = append(stashIDs, &stashID)
|
|
}
|
|
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return stashIDs, nil
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateSceneStashIDs(sceneID int, updatedJoins []StashID, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
_, err := tx.Exec("DELETE FROM scene_stash_ids WHERE scene_id = ?", sceneID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateStashIDs("scene", sceneID, updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdatePerformerStashIDs(performerID int, updatedJoins []StashID, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
_, err := tx.Exec("DELETE FROM performer_stash_ids WHERE performer_id = ?", performerID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateStashIDs("performer", performerID, updatedJoins, tx)
|
|
}
|
|
|
|
func (qb *JoinsQueryBuilder) UpdateStudioStashIDs(studioID int, updatedJoins []StashID, tx *sqlx.Tx) error {
|
|
ensureTx(tx)
|
|
|
|
_, err := tx.Exec("DELETE FROM studio_stash_ids WHERE studio_id = ?", studioID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return qb.CreateStashIDs("studio", studioID, updatedJoins, tx)
|
|
}
|