mirror of https://github.com/stashapp/stash.git
677 lines
17 KiB
Go
677 lines
17 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
|
|
"github.com/stashapp/stash/pkg/database"
|
|
"github.com/stashapp/stash/pkg/manager"
|
|
"github.com/stashapp/stash/pkg/manager/config"
|
|
"github.com/stashapp/stash/pkg/models"
|
|
"github.com/stashapp/stash/pkg/utils"
|
|
)
|
|
|
|
func (r *mutationResolver) SceneUpdate(ctx context.Context, input models.SceneUpdateInput) (*models.Scene, error) {
|
|
// Start the transaction and save the scene
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
|
|
translator := changesetTranslator{
|
|
inputMap: getUpdateInputMap(ctx),
|
|
}
|
|
ret, err := r.sceneUpdate(input, translator, tx)
|
|
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func (r *mutationResolver) ScenesUpdate(ctx context.Context, input []*models.SceneUpdateInput) ([]*models.Scene, error) {
|
|
// Start the transaction and save the scene
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
|
|
var ret []*models.Scene
|
|
|
|
inputMaps := getUpdateInputMaps(ctx)
|
|
|
|
for i, scene := range input {
|
|
translator := changesetTranslator{
|
|
inputMap: inputMaps[i],
|
|
}
|
|
|
|
thisScene, err := r.sceneUpdate(*scene, translator, tx)
|
|
ret = append(ret, thisScene)
|
|
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func (r *mutationResolver) sceneUpdate(input models.SceneUpdateInput, translator changesetTranslator, tx *sqlx.Tx) (*models.Scene, error) {
|
|
// Populate scene from the input
|
|
sceneID, _ := strconv.Atoi(input.ID)
|
|
|
|
var coverImageData []byte
|
|
|
|
updatedTime := time.Now()
|
|
updatedScene := models.ScenePartial{
|
|
ID: sceneID,
|
|
UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
|
|
}
|
|
|
|
updatedScene.Title = translator.nullString(input.Title, "title")
|
|
updatedScene.Details = translator.nullString(input.Details, "details")
|
|
updatedScene.URL = translator.nullString(input.URL, "url")
|
|
updatedScene.Date = translator.sqliteDate(input.Date, "date")
|
|
updatedScene.Rating = translator.nullInt64(input.Rating, "rating")
|
|
updatedScene.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
|
|
updatedScene.Organized = input.Organized
|
|
|
|
if input.CoverImage != nil && *input.CoverImage != "" {
|
|
var err error
|
|
_, coverImageData, err = utils.ProcessBase64Image(*input.CoverImage)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// update the cover after updating the scene
|
|
}
|
|
|
|
qb := models.NewSceneQueryBuilder()
|
|
jqb := models.NewJoinsQueryBuilder()
|
|
scene, err := qb.Update(updatedScene, tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// update cover table
|
|
if len(coverImageData) > 0 {
|
|
if err := qb.UpdateSceneCover(sceneID, coverImageData, tx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Clear the existing gallery value
|
|
if translator.hasField("gallery_id") {
|
|
gqb := models.NewGalleryQueryBuilder()
|
|
err = gqb.ClearGalleryId(sceneID, tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if input.GalleryID != nil {
|
|
// Save the gallery
|
|
galleryID, _ := strconv.Atoi(*input.GalleryID)
|
|
updatedGallery := models.Gallery{
|
|
ID: galleryID,
|
|
SceneID: sql.NullInt64{Int64: int64(sceneID), Valid: true},
|
|
UpdatedAt: models.SQLiteTimestamp{Timestamp: updatedTime},
|
|
}
|
|
gqb := models.NewGalleryQueryBuilder()
|
|
_, err := gqb.Update(updatedGallery, tx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Save the performers
|
|
if translator.hasField("performer_ids") {
|
|
var performerJoins []models.PerformersScenes
|
|
for _, pid := range input.PerformerIds {
|
|
performerID, _ := strconv.Atoi(pid)
|
|
performerJoin := models.PerformersScenes{
|
|
PerformerID: performerID,
|
|
SceneID: sceneID,
|
|
}
|
|
performerJoins = append(performerJoins, performerJoin)
|
|
}
|
|
if err := jqb.UpdatePerformersScenes(sceneID, performerJoins, tx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Save the movies
|
|
if translator.hasField("movies") {
|
|
var movieJoins []models.MoviesScenes
|
|
|
|
for _, movie := range input.Movies {
|
|
|
|
movieID, _ := strconv.Atoi(movie.MovieID)
|
|
|
|
movieJoin := models.MoviesScenes{
|
|
MovieID: movieID,
|
|
SceneID: sceneID,
|
|
}
|
|
|
|
if movie.SceneIndex != nil {
|
|
movieJoin.SceneIndex = sql.NullInt64{
|
|
Int64: int64(*movie.SceneIndex),
|
|
Valid: true,
|
|
}
|
|
}
|
|
|
|
movieJoins = append(movieJoins, movieJoin)
|
|
}
|
|
if err := jqb.UpdateMoviesScenes(sceneID, movieJoins, tx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Save the tags
|
|
if translator.hasField("tag_ids") {
|
|
var tagJoins []models.ScenesTags
|
|
for _, tid := range input.TagIds {
|
|
tagID, _ := strconv.Atoi(tid)
|
|
tagJoin := models.ScenesTags{
|
|
SceneID: sceneID,
|
|
TagID: tagID,
|
|
}
|
|
tagJoins = append(tagJoins, tagJoin)
|
|
}
|
|
if err := jqb.UpdateScenesTags(sceneID, tagJoins, tx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// only update the cover image if provided and everything else was successful
|
|
if coverImageData != nil {
|
|
err = manager.SetSceneScreenshot(scene.GetHash(config.GetVideoFileNamingAlgorithm()), coverImageData)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Save the stash_ids
|
|
if translator.hasField("stash_ids") {
|
|
var stashIDJoins []models.StashID
|
|
for _, stashID := range input.StashIds {
|
|
newJoin := models.StashID{
|
|
StashID: stashID.StashID,
|
|
Endpoint: stashID.Endpoint,
|
|
}
|
|
stashIDJoins = append(stashIDJoins, newJoin)
|
|
}
|
|
if err := jqb.UpdateSceneStashIDs(sceneID, stashIDJoins, tx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return scene, nil
|
|
}
|
|
|
|
func (r *mutationResolver) BulkSceneUpdate(ctx context.Context, input models.BulkSceneUpdateInput) ([]*models.Scene, error) {
|
|
// Populate scene from the input
|
|
updatedTime := time.Now()
|
|
|
|
translator := changesetTranslator{
|
|
inputMap: getUpdateInputMap(ctx),
|
|
}
|
|
|
|
// Start the transaction and save the scene marker
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
qb := models.NewSceneQueryBuilder()
|
|
jqb := models.NewJoinsQueryBuilder()
|
|
|
|
updatedScene := models.ScenePartial{
|
|
UpdatedAt: &models.SQLiteTimestamp{Timestamp: updatedTime},
|
|
}
|
|
|
|
updatedScene.Title = translator.nullString(input.Title, "title")
|
|
updatedScene.Details = translator.nullString(input.Details, "details")
|
|
updatedScene.URL = translator.nullString(input.URL, "url")
|
|
updatedScene.Date = translator.sqliteDate(input.Date, "date")
|
|
updatedScene.Rating = translator.nullInt64(input.Rating, "rating")
|
|
updatedScene.StudioID = translator.nullInt64FromString(input.StudioID, "studio_id")
|
|
updatedScene.Organized = input.Organized
|
|
|
|
ret := []*models.Scene{}
|
|
|
|
for _, sceneIDStr := range input.Ids {
|
|
sceneID, _ := strconv.Atoi(sceneIDStr)
|
|
updatedScene.ID = sceneID
|
|
|
|
scene, err := qb.Update(updatedScene, tx)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
|
|
ret = append(ret, scene)
|
|
|
|
if translator.hasField("gallery_id") {
|
|
// Save the gallery
|
|
var galleryID int
|
|
if input.GalleryID != nil {
|
|
galleryID, _ = strconv.Atoi(*input.GalleryID)
|
|
}
|
|
updatedGallery := models.Gallery{
|
|
ID: galleryID,
|
|
SceneID: sql.NullInt64{Int64: int64(sceneID), Valid: true},
|
|
UpdatedAt: models.SQLiteTimestamp{Timestamp: updatedTime},
|
|
}
|
|
gqb := models.NewGalleryQueryBuilder()
|
|
_, err := gqb.Update(updatedGallery, tx)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Save the performers
|
|
if translator.hasField("performer_ids") {
|
|
performerIDs, err := adjustScenePerformerIDs(tx, sceneID, *input.PerformerIds)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
|
|
var performerJoins []models.PerformersScenes
|
|
for _, performerID := range performerIDs {
|
|
performerJoin := models.PerformersScenes{
|
|
PerformerID: performerID,
|
|
SceneID: sceneID,
|
|
}
|
|
performerJoins = append(performerJoins, performerJoin)
|
|
}
|
|
if err := jqb.UpdatePerformersScenes(sceneID, performerJoins, tx); err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Save the tags
|
|
if translator.hasField("tag_ids") {
|
|
tagIDs, err := adjustSceneTagIDs(tx, sceneID, *input.TagIds)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
|
|
var tagJoins []models.ScenesTags
|
|
for _, tagID := range tagIDs {
|
|
tagJoin := models.ScenesTags{
|
|
SceneID: sceneID,
|
|
TagID: tagID,
|
|
}
|
|
tagJoins = append(tagJoins, tagJoin)
|
|
}
|
|
if err := jqb.UpdateScenesTags(sceneID, tagJoins, tx); err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
func adjustIDs(existingIDs []int, updateIDs models.BulkUpdateIds) []int {
|
|
for _, idStr := range updateIDs.Ids {
|
|
id, _ := strconv.Atoi(idStr)
|
|
|
|
// look for the id in the list
|
|
foundExisting := false
|
|
for idx, existingID := range existingIDs {
|
|
if existingID == id {
|
|
if updateIDs.Mode == models.BulkUpdateIDModeRemove {
|
|
// remove from the list
|
|
existingIDs = append(existingIDs[:idx], existingIDs[idx+1:]...)
|
|
}
|
|
|
|
foundExisting = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !foundExisting && updateIDs.Mode != models.BulkUpdateIDModeRemove {
|
|
existingIDs = append(existingIDs, id)
|
|
}
|
|
}
|
|
|
|
return existingIDs
|
|
}
|
|
|
|
func adjustScenePerformerIDs(tx *sqlx.Tx, sceneID int, ids models.BulkUpdateIds) ([]int, error) {
|
|
var ret []int
|
|
|
|
jqb := models.NewJoinsQueryBuilder()
|
|
if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
|
|
// adding to the joins
|
|
performerJoins, err := jqb.GetScenePerformers(sceneID, tx)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, join := range performerJoins {
|
|
ret = append(ret, join.PerformerID)
|
|
}
|
|
}
|
|
|
|
return adjustIDs(ret, ids), nil
|
|
}
|
|
|
|
func adjustSceneTagIDs(tx *sqlx.Tx, sceneID int, ids models.BulkUpdateIds) ([]int, error) {
|
|
var ret []int
|
|
|
|
jqb := models.NewJoinsQueryBuilder()
|
|
if ids.Mode == models.BulkUpdateIDModeAdd || ids.Mode == models.BulkUpdateIDModeRemove {
|
|
// adding to the joins
|
|
tagJoins, err := jqb.GetSceneTags(sceneID, tx)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, join := range tagJoins {
|
|
ret = append(ret, join.TagID)
|
|
}
|
|
}
|
|
|
|
return adjustIDs(ret, ids), nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneDestroy(ctx context.Context, input models.SceneDestroyInput) (bool, error) {
|
|
qb := models.NewSceneQueryBuilder()
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
|
|
sceneID, _ := strconv.Atoi(input.ID)
|
|
scene, err := qb.Find(sceneID)
|
|
err = manager.DestroyScene(sceneID, tx)
|
|
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// if delete generated is true, then delete the generated files
|
|
// for the scene
|
|
if input.DeleteGenerated != nil && *input.DeleteGenerated {
|
|
manager.DeleteGeneratedSceneFiles(scene, config.GetVideoFileNamingAlgorithm())
|
|
}
|
|
|
|
// if delete file is true, then delete the file as well
|
|
// if it fails, just log a message
|
|
if input.DeleteFile != nil && *input.DeleteFile {
|
|
manager.DeleteSceneFile(scene)
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func (r *mutationResolver) ScenesDestroy(ctx context.Context, input models.ScenesDestroyInput) (bool, error) {
|
|
qb := models.NewSceneQueryBuilder()
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
|
|
var scenes []*models.Scene
|
|
for _, id := range input.Ids {
|
|
sceneID, _ := strconv.Atoi(id)
|
|
|
|
scene, err := qb.Find(sceneID)
|
|
if scene != nil {
|
|
scenes = append(scenes, scene)
|
|
}
|
|
err = manager.DestroyScene(sceneID, tx)
|
|
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, err
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
fileNamingAlgo := config.GetVideoFileNamingAlgorithm()
|
|
for _, scene := range scenes {
|
|
// if delete generated is true, then delete the generated files
|
|
// for the scene
|
|
if input.DeleteGenerated != nil && *input.DeleteGenerated {
|
|
manager.DeleteGeneratedSceneFiles(scene, fileNamingAlgo)
|
|
}
|
|
|
|
// if delete file is true, then delete the file as well
|
|
// if it fails, just log a message
|
|
if input.DeleteFile != nil && *input.DeleteFile {
|
|
manager.DeleteSceneFile(scene)
|
|
}
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneMarkerCreate(ctx context.Context, input models.SceneMarkerCreateInput) (*models.SceneMarker, error) {
|
|
primaryTagID, _ := strconv.Atoi(input.PrimaryTagID)
|
|
sceneID, _ := strconv.Atoi(input.SceneID)
|
|
currentTime := time.Now()
|
|
newSceneMarker := models.SceneMarker{
|
|
Title: input.Title,
|
|
Seconds: input.Seconds,
|
|
PrimaryTagID: primaryTagID,
|
|
SceneID: sql.NullInt64{Int64: int64(sceneID), Valid: sceneID != 0},
|
|
CreatedAt: models.SQLiteTimestamp{Timestamp: currentTime},
|
|
UpdatedAt: models.SQLiteTimestamp{Timestamp: currentTime},
|
|
}
|
|
|
|
return changeMarker(ctx, create, newSceneMarker, input.TagIds)
|
|
}
|
|
|
|
func (r *mutationResolver) SceneMarkerUpdate(ctx context.Context, input models.SceneMarkerUpdateInput) (*models.SceneMarker, error) {
|
|
// Populate scene marker from the input
|
|
sceneMarkerID, _ := strconv.Atoi(input.ID)
|
|
sceneID, _ := strconv.Atoi(input.SceneID)
|
|
primaryTagID, _ := strconv.Atoi(input.PrimaryTagID)
|
|
updatedSceneMarker := models.SceneMarker{
|
|
ID: sceneMarkerID,
|
|
Title: input.Title,
|
|
Seconds: input.Seconds,
|
|
SceneID: sql.NullInt64{Int64: int64(sceneID), Valid: sceneID != 0},
|
|
PrimaryTagID: primaryTagID,
|
|
UpdatedAt: models.SQLiteTimestamp{Timestamp: time.Now()},
|
|
}
|
|
|
|
return changeMarker(ctx, update, updatedSceneMarker, input.TagIds)
|
|
}
|
|
|
|
func (r *mutationResolver) SceneMarkerDestroy(ctx context.Context, id string) (bool, error) {
|
|
qb := models.NewSceneMarkerQueryBuilder()
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
|
|
markerID, _ := strconv.Atoi(id)
|
|
marker, err := qb.Find(markerID)
|
|
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
if err := qb.Destroy(id, tx); err != nil {
|
|
_ = tx.Rollback()
|
|
return false, err
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// delete the preview for the marker
|
|
sqb := models.NewSceneQueryBuilder()
|
|
scene, _ := sqb.Find(int(marker.SceneID.Int64))
|
|
|
|
if scene != nil {
|
|
seconds := int(marker.Seconds)
|
|
manager.DeleteSceneMarkerFiles(scene, seconds, config.GetVideoFileNamingAlgorithm())
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func changeMarker(ctx context.Context, changeType int, changedMarker models.SceneMarker, tagIds []string) (*models.SceneMarker, error) {
|
|
// Start the transaction and save the scene marker
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
qb := models.NewSceneMarkerQueryBuilder()
|
|
jqb := models.NewJoinsQueryBuilder()
|
|
|
|
var existingMarker *models.SceneMarker
|
|
var sceneMarker *models.SceneMarker
|
|
var err error
|
|
switch changeType {
|
|
case create:
|
|
sceneMarker, err = qb.Create(changedMarker, tx)
|
|
case update:
|
|
// check to see if timestamp was changed
|
|
existingMarker, err = qb.Find(changedMarker.ID)
|
|
if err == nil {
|
|
sceneMarker, err = qb.Update(changedMarker, tx)
|
|
}
|
|
}
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
|
|
// Save the marker tags
|
|
var markerTagJoins []models.SceneMarkersTags
|
|
for _, tid := range tagIds {
|
|
tagID, _ := strconv.Atoi(tid)
|
|
if tagID == changedMarker.PrimaryTagID {
|
|
continue // If this tag is the primary tag, then let's not add it.
|
|
}
|
|
markerTag := models.SceneMarkersTags{
|
|
SceneMarkerID: sceneMarker.ID,
|
|
TagID: tagID,
|
|
}
|
|
markerTagJoins = append(markerTagJoins, markerTag)
|
|
}
|
|
switch changeType {
|
|
case create:
|
|
if err := jqb.CreateSceneMarkersTags(markerTagJoins, tx); err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
case update:
|
|
if err := jqb.UpdateSceneMarkersTags(changedMarker.ID, markerTagJoins, tx); err != nil {
|
|
_ = tx.Rollback()
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// remove the marker preview if the timestamp was changed
|
|
if existingMarker != nil && existingMarker.Seconds != changedMarker.Seconds {
|
|
sqb := models.NewSceneQueryBuilder()
|
|
|
|
scene, _ := sqb.Find(int(existingMarker.SceneID.Int64))
|
|
|
|
if scene != nil {
|
|
seconds := int(existingMarker.Seconds)
|
|
manager.DeleteSceneMarkerFiles(scene, seconds, config.GetVideoFileNamingAlgorithm())
|
|
}
|
|
}
|
|
|
|
return sceneMarker, nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneIncrementO(ctx context.Context, id string) (int, error) {
|
|
sceneID, _ := strconv.Atoi(id)
|
|
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
qb := models.NewSceneQueryBuilder()
|
|
|
|
newVal, err := qb.IncrementOCounter(sceneID, tx)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return 0, err
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return newVal, nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneDecrementO(ctx context.Context, id string) (int, error) {
|
|
sceneID, _ := strconv.Atoi(id)
|
|
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
qb := models.NewSceneQueryBuilder()
|
|
|
|
newVal, err := qb.DecrementOCounter(sceneID, tx)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return 0, err
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return newVal, nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneResetO(ctx context.Context, id string) (int, error) {
|
|
sceneID, _ := strconv.Atoi(id)
|
|
|
|
tx := database.DB.MustBeginTx(ctx, nil)
|
|
qb := models.NewSceneQueryBuilder()
|
|
|
|
newVal, err := qb.ResetOCounter(sceneID, tx)
|
|
if err != nil {
|
|
_ = tx.Rollback()
|
|
return 0, err
|
|
}
|
|
|
|
// Commit
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return newVal, nil
|
|
}
|
|
|
|
func (r *mutationResolver) SceneGenerateScreenshot(ctx context.Context, id string, at *float64) (string, error) {
|
|
if at != nil {
|
|
manager.GetInstance().GenerateScreenshot(id, *at)
|
|
} else {
|
|
manager.GetInstance().GenerateDefaultScreenshot(id)
|
|
}
|
|
|
|
return "todo", nil
|
|
}
|