2020-06-19 11:00:50 -04:00
using System ;
2019-01-13 14:24:58 -05:00
using System.Collections.Generic ;
using System.Linq ;
using System.Threading ;
2020-06-08 14:20:33 -04:00
using Jellyfin.Api.Constants ;
2019-01-13 14:24:58 -05:00
using MediaBrowser.Controller.Configuration ;
2014-12-22 01:50:29 -05:00
using MediaBrowser.Controller.Entities ;
2013-06-27 15:06:37 -04:00
using MediaBrowser.Controller.Entities.Audio ;
using MediaBrowser.Controller.Entities.TV ;
using MediaBrowser.Controller.Library ;
2014-12-22 22:58:14 -05:00
using MediaBrowser.Controller.LiveTv ;
2014-12-21 00:57:06 -05:00
using MediaBrowser.Controller.Providers ;
2013-06-27 15:06:37 -04:00
using MediaBrowser.Model.Dto ;
2014-12-21 13:58:17 -05:00
using MediaBrowser.Model.Entities ;
2016-10-23 22:45:23 -04:00
using MediaBrowser.Model.Globalization ;
2018-09-12 13:26:21 -04:00
using MediaBrowser.Model.IO ;
2020-06-08 14:20:33 -04:00
using Microsoft.AspNetCore.Authorization ;
using Microsoft.AspNetCore.Http ;
using Microsoft.AspNetCore.Mvc ;
using Microsoft.AspNetCore.Mvc.ModelBinding ;
2013-06-27 15:06:37 -04:00
2020-06-08 14:20:33 -04:00
namespace Jellyfin.Api.Controllers
2013-06-27 15:06:37 -04:00
{
2020-06-08 14:20:33 -04:00
/// <summary>
/// Item update controller.
/// </summary>
2020-08-04 14:48:53 -04:00
[Route("")]
2020-06-08 14:20:33 -04:00
[Authorize(Policy = Policies.RequiresElevation)]
public class ItemUpdateController : BaseJellyfinApiController
2013-06-27 15:06:37 -04:00
{
private readonly ILibraryManager _libraryManager ;
2014-12-21 00:57:06 -05:00
private readonly IProviderManager _providerManager ;
private readonly ILocalizationManager _localizationManager ;
2018-09-12 13:26:21 -04:00
private readonly IFileSystem _fileSystem ;
2020-06-08 14:20:33 -04:00
private readonly IServerConfigurationManager _serverConfigurationManager ;
/// <summary>
/// Initializes a new instance of the <see cref="ItemUpdateController"/> class.
/// </summary>
/// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
/// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
/// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
/// <param name="localizationManager">Instance of the <see cref="ILocalizationManager"/> interface.</param>
/// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
public ItemUpdateController (
2019-11-17 17:05:39 -05:00
IFileSystem fileSystem ,
ILibraryManager libraryManager ,
IProviderManager providerManager ,
2020-06-08 14:20:33 -04:00
ILocalizationManager localizationManager ,
IServerConfigurationManager serverConfigurationManager )
2013-06-27 15:06:37 -04:00
{
_libraryManager = libraryManager ;
2014-12-21 00:57:06 -05:00
_providerManager = providerManager ;
_localizationManager = localizationManager ;
2018-09-12 13:26:21 -04:00
_fileSystem = fileSystem ;
2020-06-08 14:20:33 -04:00
_serverConfigurationManager = serverConfigurationManager ;
2014-12-21 00:57:06 -05:00
}
2020-06-08 14:20:33 -04:00
/// <summary>
/// Updates an item.
/// </summary>
/// <param name="itemId">The item id.</param>
/// <param name="request">The new item properties.</param>
2020-06-20 17:14:43 -04:00
/// <response code="204">Item updated.</response>
2020-06-08 14:20:33 -04:00
/// <response code="404">Item not found.</response>
2020-06-20 17:14:43 -04:00
/// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
2020-08-04 14:48:53 -04:00
[HttpPost("Items/{itemId}")]
2020-06-20 17:15:59 -04:00
[ProducesResponseType(StatusCodes.Status204NoContent)]
2020-06-08 14:20:33 -04:00
[ProducesResponseType(StatusCodes.Status404NotFound)]
public ActionResult UpdateItem ( [ FromRoute ] Guid itemId , [ FromBody , BindRequired ] BaseItemDto request )
2014-12-21 00:57:06 -05:00
{
2020-06-08 14:20:33 -04:00
var item = _libraryManager . GetItemById ( itemId ) ;
if ( item = = null )
2014-12-21 13:58:17 -05:00
{
2020-06-08 14:20:33 -04:00
return NotFound ( ) ;
2014-12-21 13:58:17 -05:00
}
2014-02-19 00:21:03 -05:00
var newLockData = request . LockData ? ? false ;
2014-04-26 23:42:05 -04:00
var isLockedChanged = item . IsLocked ! = newLockData ;
2013-12-01 01:25:05 -05:00
2018-09-12 13:26:21 -04:00
var series = item as Series ;
2020-06-08 14:20:33 -04:00
var displayOrderChanged = series ! = null & & ! string . Equals (
series . DisplayOrder ? ? string . Empty ,
request . DisplayOrder ? ? string . Empty ,
StringComparison . OrdinalIgnoreCase ) ;
2018-09-12 13:26:21 -04:00
2017-06-06 02:13:49 -04:00
// Do this first so that metadata savers can pull the updates from the database.
2015-06-20 23:35:22 -04:00
if ( request . People ! = null )
{
2020-06-08 14:20:33 -04:00
_libraryManager . UpdatePeople (
item ,
request . People . Select ( x = > new PersonInfo
{
Name = x . Name ,
Role = x . Role ,
Type = x . Type
} ) . ToList ( ) ) ;
2015-06-20 23:35:22 -04:00
}
2017-06-06 02:13:49 -04:00
UpdateItem ( request , item ) ;
2017-09-13 14:41:48 -04:00
item . OnMetadataChanged ( ) ;
2017-10-03 14:39:37 -04:00
item . UpdateToRepository ( ItemUpdateType . MetadataEdit , CancellationToken . None ) ;
2017-06-06 02:13:49 -04:00
2014-04-26 23:42:05 -04:00
if ( isLockedChanged & & item . IsFolder )
2013-12-01 01:25:05 -05:00
{
var folder = ( Folder ) item ;
2015-01-25 01:34:50 -05:00
foreach ( var child in folder . GetRecursiveChildren ( ) )
2013-12-01 01:25:05 -05:00
{
2014-04-26 23:42:05 -04:00
child . IsLocked = newLockData ;
2017-10-03 14:39:37 -04:00
child . UpdateToRepository ( ItemUpdateType . MetadataEdit , CancellationToken . None ) ;
2013-12-01 01:25:05 -05:00
}
}
2018-09-12 13:26:21 -04:00
if ( displayOrderChanged )
{
2019-09-10 16:37:53 -04:00
_providerManager . QueueRefresh (
2020-06-08 14:20:33 -04:00
series ! . Id ,
2019-09-10 16:37:53 -04:00
new MetadataRefreshOptions ( new DirectoryService ( _fileSystem ) )
{
MetadataRefreshMode = MetadataRefreshMode . FullRefresh ,
ImageRefreshMode = MetadataRefreshMode . FullRefresh ,
ReplaceAllMetadata = true
} ,
RefreshPriority . High ) ;
2018-09-12 13:26:21 -04:00
}
2020-06-08 14:20:33 -04:00
2020-06-20 17:14:43 -04:00
return NoContent ( ) ;
2013-06-27 15:06:37 -04:00
}
2020-06-08 14:20:33 -04:00
/// <summary>
/// Gets metadata editor info for an item.
/// </summary>
/// <param name="itemId">The item id.</param>
/// <response code="200">Item metadata editor returned.</response>
/// <response code="404">Item not found.</response>
/// <returns>An <see cref="OkResult"/> on success containing the metadata editor, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
2020-08-04 14:48:53 -04:00
[HttpGet("Items/{itemId}/MetadataEditor")]
2020-06-08 14:20:33 -04:00
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public ActionResult < MetadataEditorInfo > GetMetadataEditorInfo ( [ FromRoute ] Guid itemId )
2014-07-13 00:55:56 -04:00
{
2020-06-08 14:20:33 -04:00
var item = _libraryManager . GetItemById ( itemId ) ;
var info = new MetadataEditorInfo
{
ParentalRatingOptions = _localizationManager . GetParentalRatings ( ) . ToArray ( ) ,
ExternalIdInfos = _providerManager . GetExternalIdInfos ( item ) . ToArray ( ) ,
Countries = _localizationManager . GetCountries ( ) . ToArray ( ) ,
Cultures = _localizationManager . GetCultures ( ) . ToArray ( )
} ;
if ( ! item . IsVirtualItem
& & ! ( item is ICollectionFolder )
& & ! ( item is UserView )
& & ! ( item is AggregateFolder )
& & ! ( item is LiveTvChannel )
& & ! ( item is IItemByName )
& & item . SourceType = = SourceType . Library )
{
var inheritedContentType = _libraryManager . GetInheritedContentType ( item ) ;
var configuredContentType = _libraryManager . GetConfiguredContentType ( item ) ;
if ( string . IsNullOrWhiteSpace ( inheritedContentType ) | |
! string . IsNullOrWhiteSpace ( configuredContentType ) )
{
info . ContentTypeOptions = GetContentTypeOptions ( true ) . ToArray ( ) ;
info . ContentType = configuredContentType ;
if ( string . IsNullOrWhiteSpace ( inheritedContentType )
| | string . Equals ( inheritedContentType , CollectionType . TvShows , StringComparison . OrdinalIgnoreCase ) )
{
info . ContentTypeOptions = info . ContentTypeOptions
. Where ( i = > string . IsNullOrWhiteSpace ( i . Value )
| | string . Equals ( i . Value , CollectionType . TvShows , StringComparison . OrdinalIgnoreCase ) )
. ToArray ( ) ;
}
}
}
return info ;
}
/// <summary>
/// Updates an item's content type.
/// </summary>
/// <param name="itemId">The item id.</param>
/// <param name="contentType">The content type of the item.</param>
2020-06-20 17:14:43 -04:00
/// <response code="204">Item content type updated.</response>
2020-06-08 14:20:33 -04:00
/// <response code="404">Item not found.</response>
2020-06-20 17:14:43 -04:00
/// <returns>An <see cref="NoContentResult"/> on success, or a <see cref="NotFoundResult"/> if the item could not be found.</returns>
2020-08-04 14:48:53 -04:00
[HttpPost("Items/{itemId}/ContentType")]
2020-06-20 17:15:59 -04:00
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
2020-06-27 12:50:44 -04:00
public ActionResult UpdateItemContentType ( [ FromRoute ] Guid itemId , [ FromQuery , BindRequired ] string? contentType )
2020-06-08 14:20:33 -04:00
{
var item = _libraryManager . GetItemById ( itemId ) ;
if ( item = = null )
{
return NotFound ( ) ;
}
var path = item . ContainingFolderPath ;
var types = _serverConfigurationManager . Configuration . ContentTypes
. Where ( i = > ! string . IsNullOrWhiteSpace ( i . Name ) )
. Where ( i = > ! string . Equals ( i . Name , path , StringComparison . OrdinalIgnoreCase ) )
. ToList ( ) ;
if ( ! string . IsNullOrWhiteSpace ( contentType ) )
{
types . Add ( new NameValuePair
{
Name = path ,
Value = contentType
} ) ;
}
_serverConfigurationManager . Configuration . ContentTypes = types . ToArray ( ) ;
_serverConfigurationManager . SaveConfiguration ( ) ;
2020-06-20 17:14:43 -04:00
return NoContent ( ) ;
2014-07-13 00:55:56 -04:00
}
2013-06-27 15:06:37 -04:00
private void UpdateItem ( BaseItemDto request , BaseItem item )
{
item . Name = request . Name ;
2014-03-24 13:54:45 -04:00
item . ForcedSortName = request . ForcedSortName ;
2013-06-27 15:06:37 -04:00
2016-10-01 03:06:00 -04:00
item . OriginalTitle = string . IsNullOrWhiteSpace ( request . OriginalTitle ) ? null : request . OriginalTitle ;
2016-04-20 01:21:40 -04:00
2016-10-17 12:35:29 -04:00
item . CriticRating = request . CriticRating ;
2013-09-16 22:08:18 -04:00
2013-09-11 13:54:59 -04:00
item . CommunityRating = request . CommunityRating ;
2013-06-27 15:06:37 -04:00
item . IndexNumber = request . IndexNumber ;
item . ParentIndexNumber = request . ParentIndexNumber ;
item . Overview = request . Overview ;
item . Genres = request . Genres ;
2013-12-05 11:50:21 -05:00
2020-04-05 12:07:43 -04:00
if ( item is Episode episode )
2013-12-08 15:33:24 -05:00
{
episode . AirsAfterSeasonNumber = request . AirsAfterSeasonNumber ;
episode . AirsBeforeEpisodeNumber = request . AirsBeforeEpisodeNumber ;
episode . AirsBeforeSeasonNumber = request . AirsBeforeSeasonNumber ;
}
2014-04-26 23:42:05 -04:00
2016-06-02 13:43:29 -04:00
item . Tags = request . Tags ;
2013-11-24 18:37:38 -05:00
2016-10-08 01:57:38 -04:00
if ( request . Taglines ! = null )
2014-06-28 22:30:20 -04:00
{
2016-10-08 01:57:38 -04:00
item . Tagline = request . Taglines . FirstOrDefault ( ) ;
2014-06-28 22:30:20 -04:00
}
2013-11-24 18:37:38 -05:00
if ( request . Studios ! = null )
{
2017-08-09 15:56:38 -04:00
item . Studios = request . Studios . Select ( x = > x . Name ) . ToArray ( ) ;
2013-11-24 18:37:38 -05:00
}
2013-09-03 10:26:17 -04:00
if ( request . DateCreated . HasValue )
{
2014-07-13 00:55:56 -04:00
item . DateCreated = NormalizeDateTime ( request . DateCreated . Value ) ;
2013-09-03 10:26:17 -04:00
}
2014-07-13 00:55:56 -04:00
item . EndDate = request . EndDate . HasValue ? NormalizeDateTime ( request . EndDate . Value ) : ( DateTime ? ) null ;
item . PremiereDate = request . PremiereDate . HasValue ? NormalizeDateTime ( request . PremiereDate . Value ) : ( DateTime ? ) null ;
2013-06-27 15:06:37 -04:00
item . ProductionYear = request . ProductionYear ;
2016-08-26 13:24:04 -04:00
item . OfficialRating = string . IsNullOrWhiteSpace ( request . OfficialRating ) ? null : request . OfficialRating ;
2013-06-27 15:06:37 -04:00
item . CustomRating = request . CustomRating ;
2013-09-03 10:26:17 -04:00
2016-10-21 14:41:49 -04:00
if ( request . ProductionLocations ! = null )
{
2017-08-09 15:56:38 -04:00
item . ProductionLocations = request . ProductionLocations ;
2016-10-21 14:41:49 -04:00
}
2015-09-29 13:35:23 -04:00
item . PreferredMetadataCountryCode = request . PreferredMetadataCountryCode ;
item . PreferredMetadataLanguage = request . PreferredMetadataLanguage ;
2014-01-03 15:32:27 -05:00
2020-04-05 12:07:43 -04:00
if ( item is IHasDisplayOrder hasDisplayOrder )
2014-01-03 15:32:27 -05:00
{
hasDisplayOrder . DisplayOrder = request . DisplayOrder ;
}
2014-04-26 23:42:05 -04:00
2020-04-05 12:07:43 -04:00
if ( item is IHasAspectRatio hasAspectRatio )
2013-11-19 22:15:48 -05:00
{
hasAspectRatio . AspectRatio = request . AspectRatio ;
}
2014-02-19 00:21:03 -05:00
2016-03-27 17:11:27 -04:00
item . IsLocked = request . LockData ? ? false ;
2014-02-19 00:21:03 -05:00
if ( request . LockedFields ! = null )
2013-06-27 15:06:37 -04:00
{
item . LockedFields = request . LockedFields ;
}
2013-09-13 14:37:44 -04:00
// Only allow this for series. Runtimes for media comes from ffprobe.
if ( item is Series )
{
item . RunTimeTicks = request . RunTimeTicks ;
}
2013-06-27 15:06:37 -04:00
foreach ( var pair in request . ProviderIds . ToList ( ) )
{
if ( string . IsNullOrEmpty ( pair . Value ) )
{
request . ProviderIds . Remove ( pair . Key ) ;
}
}
item . ProviderIds = request . ProviderIds ;
2020-04-05 12:07:43 -04:00
if ( item is Video video )
2013-07-29 08:34:46 -04:00
{
video . Video3DFormat = request . Video3DFormat ;
}
2013-09-03 10:26:17 -04:00
2015-05-18 18:23:03 -04:00
if ( request . AlbumArtists ! = null )
2013-06-27 15:06:37 -04:00
{
2020-04-05 12:07:43 -04:00
if ( item is IHasAlbumArtist hasAlbumArtists )
2015-05-18 18:23:03 -04:00
{
hasAlbumArtists . AlbumArtists = request
. AlbumArtists
. Select ( i = > i . Name )
2017-08-10 14:01:31 -04:00
. ToArray ( ) ;
2015-05-18 18:23:03 -04:00
}
2013-06-27 15:06:37 -04:00
}
2015-05-18 18:23:03 -04:00
if ( request . ArtistItems ! = null )
2015-03-13 13:25:28 -04:00
{
2020-04-05 12:07:43 -04:00
if ( item is IHasArtist hasArtists )
2015-05-18 18:23:03 -04:00
{
hasArtists . Artists = request
. ArtistItems
. Select ( i = > i . Name )
2017-08-24 15:52:19 -04:00
. ToArray ( ) ;
2015-05-18 18:23:03 -04:00
}
2015-03-13 13:25:28 -04:00
}
2015-03-15 21:48:25 -04:00
2020-06-08 14:20:33 -04:00
switch ( item )
2013-07-10 16:10:55 -04:00
{
2020-06-08 14:20:33 -04:00
case Audio song :
song . Album = request . Album ;
break ;
case MusicVideo musicVideo :
musicVideo . Album = request . Album ;
break ;
case Series series :
{
series . Status = GetSeriesStatus ( request ) ;
2013-07-10 16:10:55 -04:00
2020-06-08 14:20:33 -04:00
if ( request . AirDays ! = null )
{
series . AirDays = request . AirDays ;
series . AirTime = request . AirTime ;
}
2017-08-13 16:15:07 -04:00
2020-06-08 14:20:33 -04:00
break ;
2017-08-13 16:15:07 -04:00
}
2013-06-27 15:06:37 -04:00
}
}
2017-02-18 22:46:09 -05:00
private SeriesStatus ? GetSeriesStatus ( BaseItemDto item )
{
if ( string . IsNullOrEmpty ( item . Status ) )
{
return null ;
}
return ( SeriesStatus ) Enum . Parse ( typeof ( SeriesStatus ) , item . Status , true ) ;
}
2020-06-08 14:20:33 -04:00
private DateTime NormalizeDateTime ( DateTime val )
{
return DateTime . SpecifyKind ( val , DateTimeKind . Utc ) ;
}
private List < NameValuePair > GetContentTypeOptions ( bool isForItem )
{
var list = new List < NameValuePair > ( ) ;
if ( isForItem )
{
list . Add ( new NameValuePair
{
Name = "Inherit" ,
Value = string . Empty
} ) ;
}
list . Add ( new NameValuePair
{
Name = "Movies" ,
Value = "movies"
} ) ;
list . Add ( new NameValuePair
{
Name = "Music" ,
Value = "music"
} ) ;
list . Add ( new NameValuePair
{
Name = "Shows" ,
Value = "tvshows"
} ) ;
if ( ! isForItem )
{
list . Add ( new NameValuePair
{
Name = "Books" ,
Value = "books"
} ) ;
}
list . Add ( new NameValuePair
{
Name = "HomeVideos" ,
Value = "homevideos"
} ) ;
list . Add ( new NameValuePair
{
Name = "MusicVideos" ,
Value = "musicvideos"
} ) ;
list . Add ( new NameValuePair
{
Name = "Photos" ,
Value = "photos"
} ) ;
if ( ! isForItem )
{
list . Add ( new NameValuePair
{
Name = "MixedContent" ,
Value = string . Empty
} ) ;
}
foreach ( var val in list )
{
val . Name = _localizationManager . GetLocalizedString ( val . Name ) ;
}
return list ;
}
2013-06-27 15:06:37 -04:00
}
}