2013-07-05 16:17:32 +00:00
using MediaBrowser.Controller.Configuration ;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.IO ;
using MediaBrowser.Controller.Library ;
using MediaBrowser.Controller.Localization ;
2013-04-13 18:02:30 +00:00
using MediaBrowser.Controller.Persistence ;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Providers ;
2013-03-03 16:53:58 +00:00
using MediaBrowser.Controller.Resolvers ;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities ;
2013-02-22 01:26:35 +00:00
using MediaBrowser.Model.Logging ;
2013-02-21 01:33:05 +00:00
using System ;
using System.Collections.Generic ;
using System.IO ;
using System.Linq ;
using System.Runtime.Serialization ;
using System.Threading ;
using System.Threading.Tasks ;
namespace MediaBrowser.Controller.Entities
{
/// <summary>
/// Class BaseItem
/// </summary>
public abstract class BaseItem : IHasProviderIds
{
2013-04-22 04:38:03 +00:00
protected BaseItem ( )
{
Genres = new List < string > ( ) ;
2013-06-27 16:36:41 +00:00
RemoteTrailers = new List < MediaUrl > ( ) ;
2013-04-22 04:38:03 +00:00
Studios = new List < string > ( ) ;
People = new List < PersonInfo > ( ) ;
2013-04-28 05:44:45 +00:00
Taglines = new List < string > ( ) ;
2013-04-30 14:51:34 +00:00
ScreenshotImagePaths = new List < string > ( ) ;
BackdropImagePaths = new List < string > ( ) ;
ProductionLocations = new List < string > ( ) ;
2013-05-02 22:32:15 +00:00
Images = new Dictionary < ImageType , string > ( ) ;
ProviderIds = new Dictionary < string , string > ( StringComparer . OrdinalIgnoreCase ) ;
2013-05-06 22:52:13 +00:00
Tags = new List < string > ( ) ;
2013-05-08 20:58:52 +00:00
ThemeSongIds = new List < Guid > ( ) ;
ThemeVideoIds = new List < Guid > ( ) ;
LocalTrailerIds = new List < Guid > ( ) ;
2013-06-09 14:16:43 +00:00
LockedFields = new List < MetadataFields > ( ) ;
2013-04-22 04:38:03 +00:00
}
2013-05-30 22:22:15 +00:00
/// <summary>
/// The supported image extensions
/// </summary>
public static readonly string [ ] SupportedImageExtensions = new [ ] { ".png" , ".jpg" , ".jpeg" } ;
2013-06-13 18:17:42 +00:00
2013-03-15 19:13:22 +00:00
/// <summary>
2013-02-21 01:33:05 +00:00
/// The trailer folder name
/// </summary>
public const string TrailerFolderName = "trailers" ;
2013-04-24 16:03:10 +00:00
public const string ThemeSongsFolderName = "theme-music" ;
2013-06-01 22:18:27 +00:00
public const string ThemeSongFilename = "theme" ;
2013-04-28 18:30:58 +00:00
public const string ThemeVideosFolderName = "backdrops" ;
2013-05-20 17:04:39 +00:00
public const string XbmcTrailerFileSuffix = "-trailer" ;
2013-02-21 01:33:05 +00:00
2013-05-06 02:40:12 +00:00
private string _name ;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the name.
/// </summary>
/// <value>The name.</value>
2013-05-06 02:40:12 +00:00
public virtual string Name
{
get
{
return _name ;
}
set
{
_name = value ;
// lazy load this again
_sortName = null ;
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the id.
/// </summary>
/// <value>The id.</value>
2013-06-13 18:17:42 +00:00
public Guid Id { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the path.
/// </summary>
/// <value>The path.</value>
public virtual string Path { get ; set ; }
2013-07-05 14:54:14 +00:00
[IgnoreDataMember]
protected internal bool IsOffline { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the type of the location.
/// </summary>
/// <value>The type of the location.</value>
public virtual LocationType LocationType
{
get
{
2013-07-05 14:54:14 +00:00
if ( IsOffline )
{
return LocationType . Offline ;
}
2013-02-21 01:33:05 +00:00
if ( string . IsNullOrEmpty ( Path ) )
{
return LocationType . Virtual ;
}
return System . IO . Path . IsPathRooted ( Path ) ? LocationType . FileSystem : LocationType . Remote ;
}
}
/// <summary>
/// This is just a helper for convenience
/// </summary>
/// <value>The primary image path.</value>
[IgnoreDataMember]
2013-04-05 04:12:05 +00:00
public string PrimaryImagePath
2013-02-21 01:33:05 +00:00
{
get { return GetImage ( ImageType . Primary ) ; }
set { SetImage ( ImageType . Primary , value ) ; }
}
/// <summary>
/// Gets or sets the images.
/// </summary>
/// <value>The images.</value>
2013-04-25 19:47:38 +00:00
public virtual Dictionary < ImageType , string > Images { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the date created.
/// </summary>
/// <value>The date created.</value>
public DateTime DateCreated { get ; set ; }
/// <summary>
/// Gets or sets the date modified.
/// </summary>
/// <value>The date modified.</value>
public DateTime DateModified { get ; set ; }
2013-02-21 20:26:35 +00:00
/// <summary>
/// The logger
/// </summary>
2013-03-08 05:08:27 +00:00
public static ILogger Logger { get ; set ; }
public static ILibraryManager LibraryManager { get ; set ; }
public static IServerConfigurationManager ConfigurationManager { get ; set ; }
public static IProviderManager ProviderManager { get ; set ; }
2013-06-10 17:46:11 +00:00
public static ILocalizationManager LocalizationManager { get ; set ; }
2013-06-20 16:44:24 +00:00
public static IItemRepository ItemRepository { get ; set ; }
2013-02-21 20:26:35 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <returns>A <see cref="System.String" /> that represents this instance.</returns>
public override string ToString ( )
{
return Name ;
}
/// <summary>
/// Returns true if this item should not attempt to fetch metadata
/// </summary>
/// <value><c>true</c> if [dont fetch meta]; otherwise, <c>false</c>.</value>
2013-06-09 13:31:23 +00:00
public bool DontFetchMeta { get ; set ; }
2013-02-21 01:33:05 +00:00
2013-06-09 14:15:59 +00:00
/// <summary>
/// Gets or sets the locked fields.
/// </summary>
/// <value>The locked fields.</value>
public List < MetadataFields > LockedFields { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Determines whether the item has a saved local image of the specified name (jpg or png).
/// </summary>
/// <param name="name">The name.</param>
/// <returns><c>true</c> if [has local image] [the specified item]; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">name</exception>
public bool HasLocalImage ( string name )
{
if ( string . IsNullOrEmpty ( name ) )
{
throw new ArgumentNullException ( "name" ) ;
}
return ResolveArgs . ContainsMetaFileByName ( name + ".jpg" ) | |
ResolveArgs . ContainsMetaFileByName ( name + ".png" ) ;
}
/// <summary>
/// Should be overridden to return the proper folder where metadata lives
/// </summary>
/// <value>The meta location.</value>
[IgnoreDataMember]
public virtual string MetaLocation
{
get
{
return Path ? ? "" ;
}
}
/// <summary>
/// The _provider data
/// </summary>
private Dictionary < Guid , BaseProviderInfo > _providerData ;
/// <summary>
/// Holds persistent data for providers like last refresh date.
/// Providers can use this to determine if they need to refresh.
/// The BaseProviderInfo class can be extended to hold anything a provider may need.
/// Keyed by a unique provider ID.
/// </summary>
/// <value>The provider data.</value>
public Dictionary < Guid , BaseProviderInfo > ProviderData
{
get
{
return _providerData ? ? ( _providerData = new Dictionary < Guid , BaseProviderInfo > ( ) ) ;
}
set
{
_providerData = value ;
}
}
/// <summary>
/// Gets the type of the media.
/// </summary>
/// <value>The type of the media.</value>
[IgnoreDataMember]
public virtual string MediaType
{
get
{
return null ;
}
}
/// <summary>
/// The _resolve args
/// </summary>
private ItemResolveArgs _resolveArgs ;
/// <summary>
/// The _resolve args initialized
/// </summary>
private bool _resolveArgsInitialized ;
/// <summary>
/// The _resolve args sync lock
/// </summary>
private object _resolveArgsSyncLock = new object ( ) ;
/// <summary>
/// We attach these to the item so that we only ever have to hit the file system once
/// (this includes the children of the containing folder)
/// </summary>
/// <value>The resolve args.</value>
[IgnoreDataMember]
public ItemResolveArgs ResolveArgs
{
get
{
try
{
LazyInitializer . EnsureInitialized ( ref _resolveArgs , ref _resolveArgsInitialized , ref _resolveArgsSyncLock , ( ) = > CreateResolveArgs ( ) ) ;
}
catch ( IOException ex )
{
2013-02-21 20:26:35 +00:00
Logger . ErrorException ( "Error creating resolve args for " , ex , Path ) ;
2013-02-21 01:33:05 +00:00
throw ;
}
return _resolveArgs ;
}
set
{
_resolveArgs = value ;
_resolveArgsInitialized = value ! = null ;
}
}
/// <summary>
/// Resets the resolve args.
/// </summary>
/// <param name="pathInfo">The path info.</param>
2013-04-28 05:29:27 +00:00
public void ResetResolveArgs ( FileSystemInfo pathInfo )
2013-02-21 01:33:05 +00:00
{
ResolveArgs = CreateResolveArgs ( pathInfo ) ;
}
/// <summary>
/// Creates ResolveArgs on demand
/// </summary>
/// <param name="pathInfo">The path info.</param>
/// <returns>ItemResolveArgs.</returns>
/// <exception cref="System.IO.IOException">Unable to retrieve file system info for + path</exception>
2013-04-28 05:29:27 +00:00
protected internal virtual ItemResolveArgs CreateResolveArgs ( FileSystemInfo pathInfo = null )
2013-02-21 01:33:05 +00:00
{
var path = Path ;
// non file-system entries will not have a path
2013-04-10 15:56:36 +00:00
if ( LocationType ! = LocationType . FileSystem | | string . IsNullOrEmpty ( path ) )
2013-02-21 01:33:05 +00:00
{
2013-04-28 05:29:27 +00:00
return new ItemResolveArgs ( ConfigurationManager . ApplicationPaths ) ;
2013-02-21 01:33:05 +00:00
}
2013-06-11 20:35:54 +00:00
var isDirectory = false ;
2013-02-21 01:33:05 +00:00
if ( UseParentPathToCreateResolveArgs )
{
path = System . IO . Path . GetDirectoryName ( path ) ;
2013-06-11 20:35:54 +00:00
isDirectory = true ;
2013-02-21 01:33:05 +00:00
}
2013-07-05 18:23:41 +00:00
try
{
pathInfo = pathInfo ? ? ( isDirectory ? new DirectoryInfo ( path ) : FileSystem . GetFileSystemInfo ( path ) ) ;
}
catch ( IOException )
{
IsOffline = true ;
throw ;
}
2013-02-21 01:33:05 +00:00
2013-04-28 05:29:27 +00:00
if ( pathInfo = = null | | ! pathInfo . Exists )
2013-02-21 01:33:05 +00:00
{
2013-07-05 16:17:32 +00:00
IsOffline = true ;
2013-02-21 01:33:05 +00:00
throw new IOException ( "Unable to retrieve file system info for " + path ) ;
}
2013-06-23 17:48:30 +00:00
2013-07-05 16:17:32 +00:00
IsOffline = false ;
2013-03-04 05:43:06 +00:00
var args = new ItemResolveArgs ( ConfigurationManager . ApplicationPaths )
2013-02-21 01:33:05 +00:00
{
2013-04-28 05:29:27 +00:00
FileInfo = pathInfo ,
2013-02-21 01:33:05 +00:00
Path = path ,
Parent = Parent
} ;
// Gather child folder and files
if ( args . IsDirectory )
{
2013-04-19 18:03:21 +00:00
var isPhysicalRoot = args . IsPhysicalRoot ;
2013-02-21 01:33:05 +00:00
// When resolving the root, we need it's grandchildren (children of user views)
2013-04-19 18:03:21 +00:00
var flattenFolderDepth = isPhysicalRoot ? 2 : 0 ;
2013-02-21 01:33:05 +00:00
2013-04-19 18:03:21 +00:00
args . FileSystemDictionary = FileData . GetFilteredFileSystemEntries ( args . Path , Logger , flattenFolderDepth : flattenFolderDepth , args : args , resolveShortcuts : isPhysicalRoot | | args . IsVf ) ;
2013-05-24 17:48:48 +00:00
// Need to remove subpaths that may have been resolved from shortcuts
// Example: if \\server\movies exists, then strip out \\server\movies\action
if ( isPhysicalRoot )
{
var paths = args . FileSystemDictionary . Keys . ToList ( ) ;
2013-05-27 01:24:07 +00:00
foreach ( var subPath in paths
. Where ( subPath = > ! subPath . EndsWith ( ":\\" , StringComparison . OrdinalIgnoreCase ) & & paths . Any ( i = > subPath . StartsWith ( i . TrimEnd ( System . IO . Path . DirectorySeparatorChar ) + System . IO . Path . DirectorySeparatorChar , StringComparison . OrdinalIgnoreCase ) ) ) )
2013-05-24 17:48:48 +00:00
{
2013-05-27 01:24:07 +00:00
Logger . Info ( "Ignoring duplicate path: {0}" , subPath ) ;
2013-05-24 17:48:48 +00:00
args . FileSystemDictionary . Remove ( subPath ) ;
}
}
2013-02-21 01:33:05 +00:00
}
//update our dates
EntityResolutionHelper . EnsureDates ( this , args ) ;
return args ;
}
/// <summary>
/// Some subclasses will stop resolving at a directory and point their Path to a file within. This will help ensure the on-demand resolve args are identical to the
/// original ones.
/// </summary>
/// <value><c>true</c> if [use parent path to create resolve args]; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
protected virtual bool UseParentPathToCreateResolveArgs
{
get
{
return false ;
}
}
2013-03-12 01:46:46 +00:00
/// <summary>
/// Gets or sets the name of the forced sort.
/// </summary>
/// <value>The name of the forced sort.</value>
public string ForcedSortName { get ; set ; }
private string _sortName ;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the name of the sort.
/// </summary>
/// <value>The name of the sort.</value>
2013-03-12 01:46:46 +00:00
[IgnoreDataMember]
public string SortName
{
get
{
return ForcedSortName ? ? _sortName ? ? ( _sortName = CreateSortName ( ) ) ;
}
}
/// <summary>
/// Creates the name of the sort.
/// </summary>
/// <returns>System.String.</returns>
protected virtual string CreateSortName ( )
{
if ( Name = = null ) return null ; //some items may not have name filled in properly
var sortable = Name . Trim ( ) . ToLower ( ) ;
sortable = ConfigurationManager . Configuration . SortRemoveCharacters . Aggregate ( sortable , ( current , search ) = > current . Replace ( search . ToLower ( ) , string . Empty ) ) ;
sortable = ConfigurationManager . Configuration . SortReplaceCharacters . Aggregate ( sortable , ( current , search ) = > current . Replace ( search . ToLower ( ) , " " ) ) ;
foreach ( var search in ConfigurationManager . Configuration . SortRemoveWords )
{
var searchLower = search . ToLower ( ) ;
// Remove from beginning if a space follows
if ( sortable . StartsWith ( searchLower + " " ) )
{
sortable = sortable . Remove ( 0 , searchLower . Length + 1 ) ;
}
// Remove from middle if surrounded by spaces
sortable = sortable . Replace ( " " + searchLower + " " , " " ) ;
// Remove from end if followed by a space
if ( sortable . EndsWith ( " " + searchLower ) )
{
sortable = sortable . Remove ( sortable . Length - ( searchLower . Length + 1 ) ) ;
}
}
return sortable ;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the parent.
/// </summary>
/// <value>The parent.</value>
[IgnoreDataMember]
public Folder Parent { get ; set ; }
/// <summary>
/// When the item first debuted. For movies this could be premiere date, episodes would be first aired
/// </summary>
/// <value>The premiere date.</value>
public DateTime ? PremiereDate { get ; set ; }
2013-04-12 14:13:47 +00:00
/// <summary>
/// Gets or sets the end date.
/// </summary>
/// <value>The end date.</value>
public DateTime ? EndDate { get ; set ; }
2013-04-13 23:43:41 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the display type of the media.
/// </summary>
/// <value>The display type of the media.</value>
2013-06-14 12:18:40 +00:00
public string DisplayMediaType { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the backdrop image paths.
/// </summary>
/// <value>The backdrop image paths.</value>
public List < string > BackdropImagePaths { get ; set ; }
/// <summary>
/// Gets or sets the screenshot image paths.
/// </summary>
/// <value>The screenshot image paths.</value>
public List < string > ScreenshotImagePaths { get ; set ; }
/// <summary>
/// Gets or sets the official rating.
/// </summary>
/// <value>The official rating.</value>
2013-03-27 00:28:07 +00:00
public virtual string OfficialRating { get ; set ; }
2013-02-21 01:33:05 +00:00
2013-06-23 17:48:30 +00:00
/// <summary>
/// Gets or sets the official rating description.
/// </summary>
/// <value>The official rating description.</value>
public string OfficialRatingDescription { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the custom rating.
/// </summary>
/// <value>The custom rating.</value>
2013-03-27 00:28:07 +00:00
public virtual string CustomRating { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the language.
/// </summary>
/// <value>The language.</value>
public string Language { get ; set ; }
/// <summary>
/// Gets or sets the overview.
/// </summary>
/// <value>The overview.</value>
public string Overview { get ; set ; }
/// <summary>
/// Gets or sets the taglines.
/// </summary>
/// <value>The taglines.</value>
public List < string > Taglines { get ; set ; }
/// <summary>
/// Gets or sets the people.
/// </summary>
/// <value>The people.</value>
public List < PersonInfo > People { get ; set ; }
2013-05-06 22:52:13 +00:00
/// <summary>
/// Gets or sets the tags.
/// </summary>
/// <value>The tags.</value>
public List < string > Tags { get ; set ; }
2013-05-08 20:58:52 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Override this if you need to combine/collapse person information
/// </summary>
/// <value>All people.</value>
[IgnoreDataMember]
public virtual IEnumerable < PersonInfo > AllPeople
{
get { return People ; }
}
/// <summary>
/// Gets or sets the studios.
/// </summary>
/// <value>The studios.</value>
public virtual List < string > Studios { get ; set ; }
/// <summary>
/// Gets or sets the genres.
/// </summary>
/// <value>The genres.</value>
public virtual List < string > Genres { get ; set ; }
2013-04-12 14:13:47 +00:00
/// <summary>
/// Gets or sets the home page URL.
/// </summary>
/// <value>The home page URL.</value>
public string HomePageUrl { get ; set ; }
/// <summary>
/// Gets or sets the budget.
/// </summary>
/// <value>The budget.</value>
2013-04-12 14:32:04 +00:00
public double? Budget { get ; set ; }
2013-04-12 14:13:47 +00:00
2013-04-18 13:54:38 +00:00
/// <summary>
/// Gets or sets the revenue.
/// </summary>
/// <value>The revenue.</value>
public double? Revenue { get ; set ; }
2013-05-08 20:58:52 +00:00
2013-04-12 14:13:47 +00:00
/// <summary>
/// Gets or sets the production locations.
/// </summary>
/// <value>The production locations.</value>
public List < string > ProductionLocations { get ; set ; }
2013-04-13 23:43:41 +00:00
2013-04-25 00:58:56 +00:00
/// <summary>
/// Gets or sets the critic rating.
/// </summary>
/// <value>The critic rating.</value>
public float? CriticRating { get ; set ; }
/// <summary>
/// Gets or sets the critic rating summary.
/// </summary>
/// <value>The critic rating summary.</value>
public string CriticRatingSummary { get ; set ; }
2013-05-08 20:58:52 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the community rating.
/// </summary>
/// <value>The community rating.</value>
public float? CommunityRating { get ; set ; }
2013-07-05 17:40:51 +00:00
/// <summary>
/// Gets or sets the community rating vote count.
/// </summary>
/// <value>The community rating vote count.</value>
2013-07-06 00:19:44 +00:00
public int? VoteCount { get ; set ; }
2013-07-05 17:40:51 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the run time ticks.
/// </summary>
/// <value>The run time ticks.</value>
public long? RunTimeTicks { get ; set ; }
2013-05-17 19:18:54 +00:00
/// <summary>
/// Gets or sets the original run time ticks.
/// </summary>
/// <value>The original run time ticks.</value>
public long? OriginalRunTimeTicks { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the aspect ratio.
/// </summary>
/// <value>The aspect ratio.</value>
public string AspectRatio { get ; set ; }
/// <summary>
/// Gets or sets the production year.
/// </summary>
/// <value>The production year.</value>
public virtual int? ProductionYear { get ; set ; }
/// <summary>
/// If the item is part of a series, this is it's number in the series.
/// This could be episode number, album track number, etc.
/// </summary>
/// <value>The index number.</value>
public int? IndexNumber { get ; set ; }
/// <summary>
/// For an episode this could be the season number, or for a song this could be the disc number.
/// </summary>
/// <value>The parent index number.</value>
public int? ParentIndexNumber { get ; set ; }
2013-05-08 20:58:52 +00:00
public List < Guid > ThemeSongIds { get ; set ; }
public List < Guid > ThemeVideoIds { get ; set ; }
public List < Guid > LocalTrailerIds { get ; set ; }
2013-04-28 16:25:14 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Loads local trailers from the file system
/// </summary>
/// <returns>List{Video}.</returns>
2013-05-09 17:38:02 +00:00
private IEnumerable < Trailer > LoadLocalTrailers ( )
2013-02-21 01:33:05 +00:00
{
ItemResolveArgs resolveArgs ;
try
{
resolveArgs = ResolveArgs ;
2013-07-05 13:47:10 +00:00
if ( ! resolveArgs . IsDirectory )
{
return new List < Trailer > ( ) ;
}
2013-02-21 01:33:05 +00:00
}
catch ( IOException ex )
{
2013-02-21 20:26:35 +00:00
Logger . ErrorException ( "Error getting ResolveArgs for {0}" , ex , Path ) ;
2013-04-25 19:47:38 +00:00
return new List < Trailer > ( ) ;
2013-02-21 01:33:05 +00:00
}
2013-05-20 17:04:39 +00:00
var files = new List < FileSystemInfo > ( ) ;
2013-02-21 01:33:05 +00:00
var folder = resolveArgs . GetFileSystemEntryByName ( TrailerFolderName ) ;
// Path doesn't exist. No biggie
2013-05-20 17:04:39 +00:00
if ( folder ! = null )
2013-02-21 01:33:05 +00:00
{
2013-05-20 17:04:39 +00:00
try
{
files . AddRange ( new DirectoryInfo ( folder . FullName ) . EnumerateFiles ( ) ) ;
}
catch ( IOException ex )
{
Logger . ErrorException ( "Error loading trailers for {0}" , ex , Name ) ;
}
2013-02-21 01:33:05 +00:00
}
2013-05-20 17:04:39 +00:00
// Support xbmc trailers (-trailer suffix on video file names)
files . AddRange ( resolveArgs . FileSystemChildren . Where ( i = >
2013-02-21 01:33:05 +00:00
{
2013-07-05 14:54:14 +00:00
try
2013-05-20 17:04:39 +00:00
{
2013-07-05 14:54:14 +00:00
if ( ( i . Attributes & FileAttributes . Directory ) ! = FileAttributes . Directory )
2013-05-20 17:04:39 +00:00
{
2013-07-05 14:54:14 +00:00
if ( System . IO . Path . GetFileNameWithoutExtension ( i . Name ) . EndsWith ( XbmcTrailerFileSuffix , StringComparison . OrdinalIgnoreCase ) & & ! string . Equals ( Path , i . FullName , StringComparison . OrdinalIgnoreCase ) )
{
return true ;
}
2013-05-20 17:04:39 +00:00
}
}
2013-07-05 14:54:14 +00:00
catch ( IOException ex )
{
Logger . ErrorException ( "Error accessing path {0}" , ex , i . FullName ) ;
}
2013-02-21 01:33:05 +00:00
2013-05-20 17:04:39 +00:00
return false ;
} ) ) ;
2013-06-13 18:45:58 +00:00
return LibraryManager . ResolvePaths < Trailer > ( files , null ) . Select ( video = >
2013-02-21 01:33:05 +00:00
{
// Try to retrieve it from the db. If we don't find it, use the resolved version
2013-06-26 16:08:16 +00:00
var dbItem = LibraryManager . RetrieveItem ( video . Id ) as Trailer ;
2013-02-21 01:33:05 +00:00
if ( dbItem ! = null )
{
dbItem . ResolveArgs = video . ResolveArgs ;
video = dbItem ;
}
return video ;
2013-05-20 17:04:39 +00:00
2013-06-13 18:45:58 +00:00
} ) . ToList ( ) ;
2013-02-21 01:33:05 +00:00
}
2013-04-24 16:03:10 +00:00
/// <summary>
/// Loads the theme songs.
/// </summary>
/// <returns>List{Audio.Audio}.</returns>
2013-05-09 17:38:02 +00:00
private IEnumerable < Audio . Audio > LoadThemeSongs ( )
2013-04-24 16:03:10 +00:00
{
ItemResolveArgs resolveArgs ;
try
{
resolveArgs = ResolveArgs ;
2013-07-05 13:47:10 +00:00
if ( ! resolveArgs . IsDirectory )
{
return new List < Audio . Audio > ( ) ;
}
2013-04-24 16:03:10 +00:00
}
catch ( IOException ex )
{
Logger . ErrorException ( "Error getting ResolveArgs for {0}" , ex , Path ) ;
return new List < Audio . Audio > ( ) ;
}
2013-05-30 18:19:30 +00:00
var files = new List < FileSystemInfo > ( ) ;
2013-04-24 16:03:10 +00:00
var folder = resolveArgs . GetFileSystemEntryByName ( ThemeSongsFolderName ) ;
// Path doesn't exist. No biggie
2013-05-30 18:19:30 +00:00
if ( folder ! = null )
2013-04-24 16:03:10 +00:00
{
2013-05-30 18:19:30 +00:00
try
{
files . AddRange ( new DirectoryInfo ( folder . FullName ) . EnumerateFiles ( ) ) ;
}
catch ( IOException ex )
{
Logger . ErrorException ( "Error loading theme songs for {0}" , ex , Name ) ;
}
2013-04-24 16:03:10 +00:00
}
2013-05-30 18:19:30 +00:00
// Support plex/xbmc convention
files . AddRange ( resolveArgs . FileSystemChildren
2013-06-18 14:47:15 +00:00
. Where ( i = > string . Equals ( System . IO . Path . GetFileNameWithoutExtension ( i . Name ) , ThemeSongFilename , StringComparison . OrdinalIgnoreCase ) & & EntityResolutionHelper . IsAudioFile ( i . Name ) )
2013-05-30 18:19:30 +00:00
) ;
2013-04-24 16:03:10 +00:00
return LibraryManager . ResolvePaths < Audio . Audio > ( files , null ) . Select ( audio = >
{
// Try to retrieve it from the db. If we don't find it, use the resolved version
2013-06-26 16:08:16 +00:00
var dbItem = LibraryManager . RetrieveItem ( audio . Id ) as Audio . Audio ;
2013-04-24 16:03:10 +00:00
if ( dbItem ! = null )
{
dbItem . ResolveArgs = audio . ResolveArgs ;
audio = dbItem ;
}
return audio ;
} ) . ToList ( ) ;
}
2013-04-28 16:25:14 +00:00
/// <summary>
/// Loads the video backdrops.
/// </summary>
/// <returns>List{Video}.</returns>
2013-05-09 17:38:02 +00:00
private IEnumerable < Video > LoadThemeVideos ( )
2013-04-28 16:25:14 +00:00
{
ItemResolveArgs resolveArgs ;
try
{
resolveArgs = ResolveArgs ;
2013-07-05 13:47:10 +00:00
if ( ! resolveArgs . IsDirectory )
{
return new List < Video > ( ) ;
}
2013-04-28 16:25:14 +00:00
}
catch ( IOException ex )
{
Logger . ErrorException ( "Error getting ResolveArgs for {0}" , ex , Path ) ;
return new List < Video > ( ) ;
}
2013-04-28 18:30:58 +00:00
var folder = resolveArgs . GetFileSystemEntryByName ( ThemeVideosFolderName ) ;
2013-04-28 16:25:14 +00:00
// Path doesn't exist. No biggie
if ( folder = = null )
{
return new List < Video > ( ) ;
}
IEnumerable < FileSystemInfo > files ;
try
{
files = new DirectoryInfo ( folder . FullName ) . EnumerateFiles ( ) ;
}
catch ( IOException ex )
{
Logger . ErrorException ( "Error loading video backdrops for {0}" , ex , Name ) ;
return new List < Video > ( ) ;
}
return LibraryManager . ResolvePaths < Video > ( files , null ) . Select ( item = >
{
// Try to retrieve it from the db. If we don't find it, use the resolved version
2013-06-26 16:08:16 +00:00
var dbItem = LibraryManager . RetrieveItem ( item . Id ) as Video ;
2013-04-28 16:25:14 +00:00
if ( dbItem ! = null )
{
dbItem . ResolveArgs = item . ResolveArgs ;
item = dbItem ;
}
return item ;
} ) . ToList ( ) ;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Overrides the base implementation to refresh metadata for local trailers
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="forceSave">if set to <c>true</c> [is new item].</param>
/// <param name="forceRefresh">if set to <c>true</c> [force].</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
2013-06-20 19:07:58 +00:00
/// <param name="resetResolveArgs">if set to <c>true</c> [reset resolve args].</param>
2013-02-21 01:33:05 +00:00
/// <returns>true if a provider reports we changed</returns>
2013-06-20 19:07:58 +00:00
public virtual async Task < bool > RefreshMetadata ( CancellationToken cancellationToken , bool forceSave = false , bool forceRefresh = false , bool allowSlowProviders = true , bool resetResolveArgs = true )
2013-02-21 01:33:05 +00:00
{
2013-06-20 19:07:58 +00:00
if ( resetResolveArgs )
{
// Reload this
ResolveArgs = null ;
}
2013-02-21 01:33:05 +00:00
// Refresh for the item
2013-03-08 05:08:27 +00:00
var itemRefreshTask = ProviderManager . ExecuteMetadataProviders ( this , cancellationToken , forceRefresh , allowSlowProviders ) ;
2013-02-21 01:33:05 +00:00
cancellationToken . ThrowIfCancellationRequested ( ) ;
2013-06-17 20:35:43 +00:00
var themeSongsChanged = false ;
2013-02-21 01:33:05 +00:00
2013-06-17 20:35:43 +00:00
var themeVideosChanged = false ;
2013-04-28 16:25:14 +00:00
2013-06-17 20:35:43 +00:00
var localTrailersChanged = false ;
2013-02-21 01:33:05 +00:00
2013-06-17 20:35:43 +00:00
if ( LocationType = = LocationType . FileSystem & & Parent ! = null )
{
themeSongsChanged = await RefreshThemeSongs ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) . ConfigureAwait ( false ) ;
themeVideosChanged = await RefreshThemeVideos ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) . ConfigureAwait ( false ) ;
localTrailersChanged = await RefreshLocalTrailers ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) . ConfigureAwait ( false ) ;
}
2013-02-21 01:33:05 +00:00
cancellationToken . ThrowIfCancellationRequested ( ) ;
// Get the result from the item task
2013-06-25 01:22:21 +00:00
var updateReason = await itemRefreshTask . ConfigureAwait ( false ) ;
var changed = updateReason . HasValue ;
2013-02-21 01:33:05 +00:00
2013-05-08 20:58:52 +00:00
if ( changed | | forceSave | | themeSongsChanged | | themeVideosChanged | | localTrailersChanged )
2013-02-21 01:33:05 +00:00
{
cancellationToken . ThrowIfCancellationRequested ( ) ;
2013-06-25 01:22:21 +00:00
await LibraryManager . UpdateItem ( this , updateReason ? ? ItemUpdateType . Unspecified , cancellationToken ) . ConfigureAwait ( false ) ;
2013-02-21 01:33:05 +00:00
}
return changed ;
}
2013-05-08 20:58:52 +00:00
private async Task < bool > RefreshLocalTrailers ( CancellationToken cancellationToken , bool forceSave = false , bool forceRefresh = false , bool allowSlowProviders = true )
{
var newItems = LoadLocalTrailers ( ) . ToList ( ) ;
var newItemIds = newItems . Select ( i = > i . Id ) . ToList ( ) ;
var itemsChanged = ! LocalTrailerIds . SequenceEqual ( newItemIds ) ;
var tasks = newItems . Select ( i = > i . RefreshMetadata ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) ) ;
var results = await Task . WhenAll ( tasks ) . ConfigureAwait ( false ) ;
LocalTrailerIds = newItemIds ;
return itemsChanged | | results . Contains ( true ) ;
}
2013-06-13 18:17:42 +00:00
2013-05-08 20:58:52 +00:00
private async Task < bool > RefreshThemeVideos ( CancellationToken cancellationToken , bool forceSave = false , bool forceRefresh = false , bool allowSlowProviders = true )
{
var newThemeVideos = LoadThemeVideos ( ) . ToList ( ) ;
var newThemeVideoIds = newThemeVideos . Select ( i = > i . Id ) . ToList ( ) ;
var themeVideosChanged = ! ThemeVideoIds . SequenceEqual ( newThemeVideoIds ) ;
var tasks = newThemeVideos . Select ( i = > i . RefreshMetadata ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) ) ;
var results = await Task . WhenAll ( tasks ) . ConfigureAwait ( false ) ;
ThemeVideoIds = newThemeVideoIds ;
return themeVideosChanged | | results . Contains ( true ) ;
}
2013-06-13 18:17:42 +00:00
2013-05-08 20:58:52 +00:00
/// <summary>
/// Refreshes the theme songs.
/// </summary>
private async Task < bool > RefreshThemeSongs ( CancellationToken cancellationToken , bool forceSave = false , bool forceRefresh = false , bool allowSlowProviders = true )
{
var newThemeSongs = LoadThemeSongs ( ) . ToList ( ) ;
var newThemeSongIds = newThemeSongs . Select ( i = > i . Id ) . ToList ( ) ;
var themeSongsChanged = ! ThemeSongIds . SequenceEqual ( newThemeSongIds ) ;
var tasks = newThemeSongs . Select ( i = > i . RefreshMetadata ( cancellationToken , forceSave , forceRefresh , allowSlowProviders ) ) ;
var results = await Task . WhenAll ( tasks ) . ConfigureAwait ( false ) ;
ThemeSongIds = newThemeSongIds ;
return themeSongsChanged | | results . Contains ( true ) ;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the trailer URL.
/// </summary>
/// <value>The trailer URL.</value>
2013-06-27 16:36:41 +00:00
public List < MediaUrl > RemoteTrailers { get ; set ; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the provider ids.
/// </summary>
/// <value>The provider ids.</value>
public Dictionary < string , string > ProviderIds { get ; set ; }
/// <summary>
/// Override this to false if class should be ignored for indexing purposes
/// </summary>
/// <value><c>true</c> if [include in index]; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
public virtual bool IncludeInIndex
{
get { return true ; }
}
/// <summary>
/// Override this to true if class should be grouped under a container in indicies
/// The container class should be defined via IndexContainer
/// </summary>
/// <value><c>true</c> if [group in index]; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
public virtual bool GroupInIndex
{
get { return false ; }
}
/// <summary>
/// Override this to return the folder that should be used to construct a container
/// for this item in an index. GroupInIndex should be true as well.
/// </summary>
/// <value>The index container.</value>
[IgnoreDataMember]
public virtual Folder IndexContainer
{
get { return null ; }
}
/// <summary>
2013-04-13 18:02:30 +00:00
/// Gets the user data key.
2013-02-21 01:33:05 +00:00
/// </summary>
2013-04-13 18:02:30 +00:00
/// <returns>System.String.</returns>
public virtual string GetUserDataKey ( )
2013-02-21 01:33:05 +00:00
{
2013-04-13 18:02:30 +00:00
return Id . ToString ( ) ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Determines if a given user has access to this item
/// </summary>
/// <param name="user">The user.</param>
2013-06-10 17:46:11 +00:00
/// <param name="localizationManager">The localization manager.</param>
2013-02-21 01:33:05 +00:00
/// <returns><c>true</c> if [is parental allowed] [the specified user]; otherwise, <c>false</c>.</returns>
2013-06-10 17:46:11 +00:00
/// <exception cref="System.ArgumentNullException">user</exception>
public bool IsParentalAllowed ( User user , ILocalizationManager localizationManager )
2013-02-21 01:33:05 +00:00
{
if ( user = = null )
{
2013-04-22 15:38:38 +00:00
throw new ArgumentNullException ( "user" ) ;
}
2013-04-22 16:04:54 +00:00
if ( user . Configuration . MaxParentalRating = = null )
2013-04-22 15:38:38 +00:00
{
return true ;
2013-02-21 01:33:05 +00:00
}
2013-06-10 17:46:11 +00:00
var rating = CustomRating ? ? OfficialRating ;
2013-06-12 02:59:57 +00:00
if ( string . IsNullOrEmpty ( rating ) )
2013-05-23 15:07:25 +00:00
{
2013-06-12 02:59:57 +00:00
return ! user . Configuration . BlockNotRated ;
2013-05-23 15:07:25 +00:00
}
2013-06-10 17:46:11 +00:00
var value = localizationManager . GetRatingLevel ( rating ) ;
// Could not determine the integer value
if ( ! value . HasValue )
{
return true ;
}
return value . Value < = user . Configuration . MaxParentalRating . Value ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Determines if this folder should be visible to a given user.
/// Default is just parental allowed. Can be overridden for more functionality.
/// </summary>
/// <param name="user">The user.</param>
/// <returns><c>true</c> if the specified user is visible; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">user</exception>
public virtual bool IsVisible ( User user )
{
if ( user = = null )
{
throw new ArgumentNullException ( "user" ) ;
}
2013-06-10 17:46:11 +00:00
return IsParentalAllowed ( user , LocalizationManager ) ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Finds the particular item by searching through our parents and, if not found there, loading from repo
/// </summary>
/// <param name="id">The id.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentException"></exception>
protected BaseItem FindParentItem ( Guid id )
{
if ( id = = Guid . Empty )
{
throw new ArgumentException ( ) ;
}
var parent = Parent ;
while ( parent ! = null & & ! parent . IsRoot )
{
if ( parent . Id = = id ) return parent ;
parent = parent . Parent ;
}
2013-06-17 20:35:43 +00:00
return null ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets a value indicating whether this instance is folder.
/// </summary>
/// <value><c>true</c> if this instance is folder; otherwise, <c>false</c>.</value>
[IgnoreDataMember]
public virtual bool IsFolder
{
get
{
return false ;
}
}
/// <summary>
/// Determine if we have changed vs the passed in copy
/// </summary>
/// <param name="copy">The copy.</param>
/// <returns><c>true</c> if the specified copy has changed; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public virtual bool HasChanged ( BaseItem copy )
{
if ( copy = = null )
{
throw new ArgumentNullException ( ) ;
}
var changed = copy . DateModified ! = DateModified ;
if ( changed )
{
2013-02-21 20:26:35 +00:00
Logger . Debug ( Name + " changed - original creation: " + DateCreated + " new creation: " + copy . DateCreated + " original modified: " + DateModified + " new modified: " + copy . DateModified ) ;
2013-02-21 01:33:05 +00:00
}
return changed ;
}
/// <summary>
/// Determines if the item is considered new based on user settings
/// </summary>
/// <returns><c>true</c> if [is recently added] [the specified user]; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
2013-04-22 04:38:03 +00:00
public bool IsRecentlyAdded ( )
2013-02-21 01:33:05 +00:00
{
2013-03-04 05:43:06 +00:00
return ( DateTime . UtcNow - DateCreated ) . TotalDays < ConfigurationManager . Configuration . RecentItemDays ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Adds a person to the item
/// </summary>
/// <param name="person">The person.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddPerson ( PersonInfo person )
{
if ( person = = null )
{
2013-04-14 15:03:12 +00:00
throw new ArgumentNullException ( "person" ) ;
2013-02-21 01:33:05 +00:00
}
if ( string . IsNullOrWhiteSpace ( person . Name ) )
{
throw new ArgumentNullException ( ) ;
}
2013-04-14 15:03:12 +00:00
// If the type is GuestStar and there's already an Actor entry, then update it to avoid dupes
if ( string . Equals ( person . Type , PersonType . GuestStar , StringComparison . OrdinalIgnoreCase ) )
{
var existing = People . FirstOrDefault ( p = > p . Name . Equals ( person . Name , StringComparison . OrdinalIgnoreCase ) & & p . Type . Equals ( PersonType . Actor , StringComparison . OrdinalIgnoreCase ) ) ;
if ( existing ! = null )
{
existing . Type = PersonType . GuestStar ;
return ;
}
}
2013-02-21 01:33:05 +00:00
2013-04-14 15:03:12 +00:00
if ( string . Equals ( person . Type , PersonType . Actor , StringComparison . OrdinalIgnoreCase ) )
2013-02-21 01:33:05 +00:00
{
2013-04-30 15:25:30 +00:00
// If the actor already exists without a role and we have one, fill it in
var existing = People . FirstOrDefault ( p = > p . Name . Equals ( person . Name , StringComparison . OrdinalIgnoreCase ) & & ( p . Type . Equals ( PersonType . Actor , StringComparison . OrdinalIgnoreCase ) | | p . Type . Equals ( PersonType . GuestStar , StringComparison . OrdinalIgnoreCase ) ) ) ;
if ( existing = = null )
2013-04-14 15:03:12 +00:00
{
2013-04-30 15:25:30 +00:00
// Wasn't there - add it
2013-04-14 15:03:12 +00:00
People . Add ( person ) ;
}
2013-04-30 15:25:30 +00:00
else
{
// Was there, if no role and we have one - fill it in
if ( string . IsNullOrWhiteSpace ( existing . Role ) & & ! string . IsNullOrWhiteSpace ( person . Role ) ) existing . Role = person . Role ;
}
2013-04-14 15:03:12 +00:00
}
else
{
// Check for dupes based on the combination of Name and Type
if ( ! People . Any ( p = > p . Name . Equals ( person . Name , StringComparison . OrdinalIgnoreCase ) & & p . Type . Equals ( person . Type , StringComparison . OrdinalIgnoreCase ) ) )
{
People . Add ( person ) ;
}
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Adds a studio to the item
/// </summary>
/// <param name="name">The name.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddStudio ( string name )
{
if ( string . IsNullOrWhiteSpace ( name ) )
{
2013-04-05 04:12:05 +00:00
throw new ArgumentNullException ( "name" ) ;
2013-02-21 01:33:05 +00:00
}
if ( ! Studios . Contains ( name , StringComparer . OrdinalIgnoreCase ) )
{
Studios . Add ( name ) ;
}
}
2013-06-23 18:55:30 +00:00
public void AddTag ( string name )
{
if ( string . IsNullOrWhiteSpace ( name ) )
{
throw new ArgumentNullException ( "name" ) ;
}
if ( ! Tags . Contains ( name , StringComparer . OrdinalIgnoreCase ) )
{
Tags . Add ( name ) ;
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Adds a tagline to the item
/// </summary>
/// <param name="name">The name.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddTagline ( string name )
{
if ( string . IsNullOrWhiteSpace ( name ) )
{
2013-04-05 04:12:05 +00:00
throw new ArgumentNullException ( "name" ) ;
2013-02-21 01:33:05 +00:00
}
if ( ! Taglines . Contains ( name , StringComparer . OrdinalIgnoreCase ) )
{
Taglines . Add ( name ) ;
}
}
/// <summary>
/// Adds a TrailerUrl to the item
/// </summary>
/// <param name="url">The URL.</param>
2013-06-27 16:36:41 +00:00
/// <param name="isDirectLink">if set to <c>true</c> [is direct link].</param>
/// <exception cref="System.ArgumentNullException">url</exception>
public void AddTrailerUrl ( string url , bool isDirectLink )
2013-02-21 01:33:05 +00:00
{
if ( string . IsNullOrWhiteSpace ( url ) )
{
2013-04-05 04:12:05 +00:00
throw new ArgumentNullException ( "url" ) ;
2013-02-21 01:33:05 +00:00
}
2013-06-27 16:36:41 +00:00
var current = RemoteTrailers . FirstOrDefault ( i = > string . Equals ( i . Url , url , StringComparison . OrdinalIgnoreCase ) ) ;
if ( current ! = null )
2013-02-21 01:33:05 +00:00
{
2013-06-27 16:36:41 +00:00
current . IsDirectLink = isDirectLink ;
2013-02-21 01:33:05 +00:00
}
2013-06-27 16:36:41 +00:00
else
2013-02-21 01:33:05 +00:00
{
2013-06-27 16:36:41 +00:00
RemoteTrailers . Add ( new MediaUrl
{
Url = url ,
IsDirectLink = isDirectLink
} ) ;
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Adds a genre to the item
/// </summary>
/// <param name="name">The name.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddGenre ( string name )
{
if ( string . IsNullOrWhiteSpace ( name ) )
{
2013-04-12 14:13:47 +00:00
throw new ArgumentNullException ( "name" ) ;
2013-02-21 01:33:05 +00:00
}
if ( ! Genres . Contains ( name , StringComparer . OrdinalIgnoreCase ) )
{
Genres . Add ( name ) ;
}
}
2013-04-12 14:13:47 +00:00
/// <summary>
/// Adds the production location.
/// </summary>
/// <param name="location">The location.</param>
/// <exception cref="System.ArgumentNullException">location</exception>
public void AddProductionLocation ( string location )
{
if ( string . IsNullOrWhiteSpace ( location ) )
{
throw new ArgumentNullException ( "location" ) ;
}
if ( ProductionLocations = = null )
{
ProductionLocations = new List < string > ( ) ;
}
if ( ! ProductionLocations . Contains ( location , StringComparer . OrdinalIgnoreCase ) )
{
ProductionLocations . Add ( location ) ;
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Marks the item as either played or unplayed
/// </summary>
/// <param name="user">The user.</param>
/// <param name="wasPlayed">if set to <c>true</c> [was played].</param>
2013-04-02 19:25:16 +00:00
/// <param name="userManager">The user manager.</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
2013-04-13 18:02:30 +00:00
public virtual async Task SetPlayedStatus ( User user , bool wasPlayed , IUserDataRepository userManager )
2013-02-21 01:33:05 +00:00
{
if ( user = = null )
{
throw new ArgumentNullException ( ) ;
}
2013-04-13 18:02:30 +00:00
var key = GetUserDataKey ( ) ;
2013-06-17 20:35:43 +00:00
var data = userManager . GetUserData ( user . Id , key ) ;
2013-02-21 01:33:05 +00:00
if ( wasPlayed )
{
data . PlayCount = Math . Max ( data . PlayCount , 1 ) ;
if ( ! data . LastPlayedDate . HasValue )
{
data . LastPlayedDate = DateTime . UtcNow ;
}
}
else
{
//I think it is okay to do this here.
// if this is only called when a user is manually forcing something to un-played
// then it probably is what we want to do...
data . PlayCount = 0 ;
data . PlaybackPositionTicks = 0 ;
data . LastPlayedDate = null ;
}
data . Played = wasPlayed ;
2013-04-13 18:02:30 +00:00
await userManager . SaveUserData ( user . Id , key , data , CancellationToken . None ) . ConfigureAwait ( false ) ;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Do whatever refreshing is necessary when the filesystem pertaining to this item has changed.
/// </summary>
/// <returns>Task.</returns>
public virtual Task ChangedExternally ( )
{
return RefreshMetadata ( CancellationToken . None ) ;
}
/// <summary>
/// Finds a parent of a given type
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>``0.</returns>
public T FindParent < T > ( )
where T : Folder
{
var parent = Parent ;
while ( parent ! = null )
{
var result = parent as T ;
if ( result ! = null )
{
return result ;
}
parent = parent . Parent ;
}
return null ;
}
/// <summary>
/// Gets an image
/// </summary>
/// <param name="type">The type.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.ArgumentException">Backdrops should be accessed using Item.Backdrops</exception>
public string GetImage ( ImageType type )
{
if ( type = = ImageType . Backdrop )
{
throw new ArgumentException ( "Backdrops should be accessed using Item.Backdrops" ) ;
}
if ( type = = ImageType . Screenshot )
{
throw new ArgumentException ( "Screenshots should be accessed using Item.Screenshots" ) ;
}
string val ;
2013-04-25 19:47:38 +00:00
Images . TryGetValue ( type , out val ) ;
2013-02-21 01:33:05 +00:00
return val ;
}
/// <summary>
/// Gets an image
/// </summary>
/// <param name="type">The type.</param>
/// <returns><c>true</c> if the specified type has image; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentException">Backdrops should be accessed using Item.Backdrops</exception>
public bool HasImage ( ImageType type )
{
if ( type = = ImageType . Backdrop )
{
throw new ArgumentException ( "Backdrops should be accessed using Item.Backdrops" ) ;
}
if ( type = = ImageType . Screenshot )
{
throw new ArgumentException ( "Screenshots should be accessed using Item.Screenshots" ) ;
}
return ! string . IsNullOrEmpty ( GetImage ( type ) ) ;
}
/// <summary>
/// Sets an image
/// </summary>
/// <param name="type">The type.</param>
/// <param name="path">The path.</param>
/// <exception cref="System.ArgumentException">Backdrops should be accessed using Item.Backdrops</exception>
public void SetImage ( ImageType type , string path )
{
if ( type = = ImageType . Backdrop )
{
throw new ArgumentException ( "Backdrops should be accessed using Item.Backdrops" ) ;
}
if ( type = = ImageType . Screenshot )
{
throw new ArgumentException ( "Screenshots should be accessed using Item.Screenshots" ) ;
}
2013-04-25 19:47:38 +00:00
var typeKey = type ;
2013-02-21 01:33:05 +00:00
// If it's null remove the key from the dictionary
if ( string . IsNullOrEmpty ( path ) )
{
2013-06-12 02:59:57 +00:00
if ( Images . ContainsKey ( typeKey ) )
2013-02-21 01:33:05 +00:00
{
2013-06-12 02:59:57 +00:00
Images . Remove ( typeKey ) ;
2013-02-21 01:33:05 +00:00
}
}
else
{
Images [ typeKey ] = path ;
}
}
/// <summary>
/// Deletes the image.
/// </summary>
/// <param name="type">The type.</param>
2013-05-05 04:49:49 +00:00
/// <param name="index">The index.</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task.</returns>
2013-05-05 04:49:49 +00:00
public Task DeleteImage ( ImageType type , int? index )
2013-02-21 01:33:05 +00:00
{
2013-05-05 04:49:49 +00:00
if ( type = = ImageType . Backdrop )
2013-02-21 01:33:05 +00:00
{
2013-05-05 04:49:49 +00:00
if ( ! index . HasValue )
{
throw new ArgumentException ( "Please specify a backdrop image index to delete." ) ;
}
var file = BackdropImagePaths [ index . Value ] ;
BackdropImagePaths . Remove ( file ) ;
// Delete the source file
File . Delete ( file ) ;
2013-02-21 01:33:05 +00:00
}
2013-05-05 04:49:49 +00:00
else if ( type = = ImageType . Screenshot )
{
if ( ! index . HasValue )
{
throw new ArgumentException ( "Please specify a screenshot image index to delete." ) ;
}
var file = ScreenshotImagePaths [ index . Value ] ;
2013-02-21 01:33:05 +00:00
2013-05-05 04:49:49 +00:00
ScreenshotImagePaths . Remove ( file ) ;
// Delete the source file
File . Delete ( file ) ;
}
else
{
// Delete the source file
File . Delete ( GetImage ( type ) ) ;
2013-02-21 01:33:05 +00:00
2013-05-05 04:49:49 +00:00
// Remove it from the item
SetImage ( type , null ) ;
}
2013-02-21 01:33:05 +00:00
// Refresh metadata
2013-05-18 21:47:00 +00:00
return RefreshMetadata ( CancellationToken . None , forceSave : true ) ;
2013-02-21 01:33:05 +00:00
}
}
}