BaseItem.cs 94 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Globalization;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Text.Json.Serialization;
  8. using System.Threading;
  9. using System.Threading.Tasks;
  10. using MediaBrowser.Common.Extensions;
  11. using MediaBrowser.Controller.Channels;
  12. using MediaBrowser.Controller.Configuration;
  13. using MediaBrowser.Controller.Dto;
  14. using MediaBrowser.Controller.Extensions;
  15. using MediaBrowser.Controller.Library;
  16. using MediaBrowser.Controller.Persistence;
  17. using MediaBrowser.Controller.Providers;
  18. using MediaBrowser.Model.Configuration;
  19. using MediaBrowser.Model.Dto;
  20. using MediaBrowser.Model.Entities;
  21. using MediaBrowser.Model.Globalization;
  22. using MediaBrowser.Model.IO;
  23. using MediaBrowser.Model.Library;
  24. using MediaBrowser.Model.LiveTv;
  25. using MediaBrowser.Model.MediaInfo;
  26. using MediaBrowser.Model.Providers;
  27. using MediaBrowser.Model.Users;
  28. using Microsoft.Extensions.Logging;
  29. namespace MediaBrowser.Controller.Entities
  30. {
  31. /// <summary>
  32. /// Class BaseItem
  33. /// </summary>
  34. public abstract class BaseItem : IHasProviderIds, IHasLookupInfo<ItemLookupInfo>, IEquatable<BaseItem>
  35. {
  36. /// <summary>
  37. /// The supported image extensions
  38. /// </summary>
  39. public static readonly string[] SupportedImageExtensions
  40. = new[] { ".png", ".jpg", ".jpeg", ".tbn", ".gif" };
  41. private static readonly List<string> _supportedExtensions = new List<string>(SupportedImageExtensions)
  42. {
  43. ".nfo",
  44. ".xml",
  45. ".srt",
  46. ".vtt",
  47. ".sub",
  48. ".idx",
  49. ".txt",
  50. ".edl",
  51. ".bif",
  52. ".smi",
  53. ".ttml"
  54. };
  55. protected BaseItem()
  56. {
  57. ThemeSongIds = Array.Empty<Guid>();
  58. ThemeVideoIds = Array.Empty<Guid>();
  59. Tags = Array.Empty<string>();
  60. Genres = Array.Empty<string>();
  61. Studios = Array.Empty<string>();
  62. ProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
  63. LockedFields = Array.Empty<MetadataFields>();
  64. ImageInfos = Array.Empty<ItemImageInfo>();
  65. ProductionLocations = Array.Empty<string>();
  66. RemoteTrailers = Array.Empty<MediaUrl>();
  67. ExtraIds = Array.Empty<Guid>();
  68. }
  69. public static readonly char[] SlugReplaceChars = { '?', '/', '&' };
  70. public static char SlugChar = '-';
  71. /// <summary>
  72. /// The trailer folder name
  73. /// </summary>
  74. public const string TrailerFolderName = "trailers";
  75. public const string ThemeSongsFolderName = "theme-music";
  76. public const string ThemeSongFilename = "theme";
  77. public const string ThemeVideosFolderName = "backdrops";
  78. public const string ExtrasFolderName = "extras";
  79. public const string BehindTheScenesFolderName = "behind the scenes";
  80. public const string DeletedScenesFolderName = "deleted scenes";
  81. public const string InterviewFolderName = "interviews";
  82. public const string SceneFolderName = "scenes";
  83. public const string SampleFolderName = "samples";
  84. public static readonly string[] AllExtrasTypesFolderNames = {
  85. ExtrasFolderName,
  86. BehindTheScenesFolderName,
  87. DeletedScenesFolderName,
  88. InterviewFolderName,
  89. SceneFolderName,
  90. SampleFolderName
  91. };
  92. [JsonIgnore]
  93. public Guid[] ThemeSongIds { get; set; }
  94. [JsonIgnore]
  95. public Guid[] ThemeVideoIds { get; set; }
  96. [JsonIgnore]
  97. public string PreferredMetadataCountryCode { get; set; }
  98. [JsonIgnore]
  99. public string PreferredMetadataLanguage { get; set; }
  100. public long? Size { get; set; }
  101. public string Container { get; set; }
  102. [JsonIgnore]
  103. public string Tagline { get; set; }
  104. [JsonIgnore]
  105. public virtual ItemImageInfo[] ImageInfos { get; set; }
  106. [JsonIgnore]
  107. public bool IsVirtualItem { get; set; }
  108. /// <summary>
  109. /// Gets or sets the album.
  110. /// </summary>
  111. /// <value>The album.</value>
  112. [JsonIgnore]
  113. public string Album { get; set; }
  114. /// <summary>
  115. /// Gets or sets the channel identifier.
  116. /// </summary>
  117. /// <value>The channel identifier.</value>
  118. [JsonIgnore]
  119. public Guid ChannelId { get; set; }
  120. [JsonIgnore]
  121. public virtual bool SupportsAddingToPlaylist => false;
  122. [JsonIgnore]
  123. public virtual bool AlwaysScanInternalMetadataPath => false;
  124. /// <summary>
  125. /// Gets a value indicating whether this instance is in mixed folder.
  126. /// </summary>
  127. /// <value><c>true</c> if this instance is in mixed folder; otherwise, <c>false</c>.</value>
  128. [JsonIgnore]
  129. public bool IsInMixedFolder { get; set; }
  130. [JsonIgnore]
  131. public virtual bool SupportsPlayedStatus => false;
  132. [JsonIgnore]
  133. public virtual bool SupportsPositionTicksResume => false;
  134. [JsonIgnore]
  135. public virtual bool SupportsRemoteImageDownloading => true;
  136. private string _name;
  137. /// <summary>
  138. /// Gets or sets the name.
  139. /// </summary>
  140. /// <value>The name.</value>
  141. [JsonIgnore]
  142. public virtual string Name
  143. {
  144. get => _name;
  145. set
  146. {
  147. _name = value;
  148. // lazy load this again
  149. _sortName = null;
  150. }
  151. }
  152. [JsonIgnore]
  153. public bool IsUnaired => PremiereDate.HasValue && PremiereDate.Value.ToLocalTime().Date >= DateTime.Now.Date;
  154. [JsonIgnore]
  155. public int? TotalBitrate { get; set; }
  156. [JsonIgnore]
  157. public ExtraType? ExtraType { get; set; }
  158. [JsonIgnore]
  159. public bool IsThemeMedia => ExtraType.HasValue && (ExtraType.Value == Model.Entities.ExtraType.ThemeSong || ExtraType.Value == Model.Entities.ExtraType.ThemeVideo);
  160. [JsonIgnore]
  161. public string OriginalTitle { get; set; }
  162. /// <summary>
  163. /// Gets or sets the id.
  164. /// </summary>
  165. /// <value>The id.</value>
  166. [JsonIgnore]
  167. public Guid Id { get; set; }
  168. [JsonIgnore]
  169. public Guid OwnerId { get; set; }
  170. /// <summary>
  171. /// Gets or sets the audio.
  172. /// </summary>
  173. /// <value>The audio.</value>
  174. [JsonIgnore]
  175. public ProgramAudio? Audio { get; set; }
  176. /// <summary>
  177. /// Return the id that should be used to key display prefs for this item.
  178. /// Default is based on the type for everything except actual generic folders.
  179. /// </summary>
  180. /// <value>The display prefs id.</value>
  181. [JsonIgnore]
  182. public virtual Guid DisplayPreferencesId
  183. {
  184. get
  185. {
  186. var thisType = GetType();
  187. return thisType == typeof(Folder) ? Id : thisType.FullName.GetMD5();
  188. }
  189. }
  190. /// <summary>
  191. /// Gets or sets the path.
  192. /// </summary>
  193. /// <value>The path.</value>
  194. [JsonIgnore]
  195. public virtual string Path { get; set; }
  196. [JsonIgnore]
  197. public virtual SourceType SourceType
  198. {
  199. get
  200. {
  201. if (!ChannelId.Equals(Guid.Empty))
  202. {
  203. return SourceType.Channel;
  204. }
  205. return SourceType.Library;
  206. }
  207. }
  208. /// <summary>
  209. /// Returns the folder containing the item.
  210. /// If the item is a folder, it returns the folder itself
  211. /// </summary>
  212. [JsonIgnore]
  213. public virtual string ContainingFolderPath
  214. {
  215. get
  216. {
  217. if (IsFolder)
  218. {
  219. return Path;
  220. }
  221. return System.IO.Path.GetDirectoryName(Path);
  222. }
  223. }
  224. /// <summary>
  225. /// Gets or sets the name of the service.
  226. /// </summary>
  227. /// <value>The name of the service.</value>
  228. [JsonIgnore]
  229. public string ServiceName { get; set; }
  230. /// <summary>
  231. /// If this content came from an external service, the id of the content on that service
  232. /// </summary>
  233. [JsonIgnore]
  234. public string ExternalId { get; set; }
  235. [JsonIgnore]
  236. public string ExternalSeriesId { get; set; }
  237. /// <summary>
  238. /// Gets or sets the etag.
  239. /// </summary>
  240. /// <value>The etag.</value>
  241. [JsonIgnore]
  242. public string ExternalEtag { get; set; }
  243. [JsonIgnore]
  244. public virtual bool IsHidden => false;
  245. public BaseItem GetOwner()
  246. {
  247. var ownerId = OwnerId;
  248. return ownerId.Equals(Guid.Empty) ? null : LibraryManager.GetItemById(ownerId);
  249. }
  250. /// <summary>
  251. /// Gets or sets the type of the location.
  252. /// </summary>
  253. /// <value>The type of the location.</value>
  254. [JsonIgnore]
  255. public virtual LocationType LocationType
  256. {
  257. get
  258. {
  259. //if (IsOffline)
  260. //{
  261. // return LocationType.Offline;
  262. //}
  263. var path = Path;
  264. if (string.IsNullOrEmpty(path))
  265. {
  266. if (SourceType == SourceType.Channel)
  267. {
  268. return LocationType.Remote;
  269. }
  270. return LocationType.Virtual;
  271. }
  272. return FileSystem.IsPathFile(path) ? LocationType.FileSystem : LocationType.Remote;
  273. }
  274. }
  275. [JsonIgnore]
  276. public MediaProtocol? PathProtocol
  277. {
  278. get
  279. {
  280. var path = Path;
  281. if (string.IsNullOrEmpty(path))
  282. {
  283. return null;
  284. }
  285. return MediaSourceManager.GetPathProtocol(path);
  286. }
  287. }
  288. public bool IsPathProtocol(MediaProtocol protocol)
  289. {
  290. var current = PathProtocol;
  291. return current.HasValue && current.Value == protocol;
  292. }
  293. [JsonIgnore]
  294. public bool IsFileProtocol => IsPathProtocol(MediaProtocol.File);
  295. [JsonIgnore]
  296. public bool HasPathProtocol => PathProtocol.HasValue;
  297. [JsonIgnore]
  298. public virtual bool SupportsLocalMetadata
  299. {
  300. get
  301. {
  302. if (SourceType == SourceType.Channel)
  303. {
  304. return false;
  305. }
  306. return IsFileProtocol;
  307. }
  308. }
  309. [JsonIgnore]
  310. public virtual string FileNameWithoutExtension
  311. {
  312. get
  313. {
  314. if (IsFileProtocol)
  315. {
  316. return System.IO.Path.GetFileNameWithoutExtension(Path);
  317. }
  318. return null;
  319. }
  320. }
  321. [JsonIgnore]
  322. public virtual bool EnableAlphaNumericSorting => true;
  323. private List<Tuple<StringBuilder, bool>> GetSortChunks(string s1)
  324. {
  325. var list = new List<Tuple<StringBuilder, bool>>();
  326. int thisMarker = 0;
  327. while (thisMarker < s1.Length)
  328. {
  329. char thisCh = s1[thisMarker];
  330. var thisChunk = new StringBuilder();
  331. bool isNumeric = char.IsDigit(thisCh);
  332. while (thisMarker < s1.Length && char.IsDigit(thisCh) == isNumeric)
  333. {
  334. thisChunk.Append(thisCh);
  335. thisMarker++;
  336. if (thisMarker < s1.Length)
  337. {
  338. thisCh = s1[thisMarker];
  339. }
  340. }
  341. list.Add(new Tuple<StringBuilder, bool>(thisChunk, isNumeric));
  342. }
  343. return list;
  344. }
  345. /// <summary>
  346. /// This is just a helper for convenience
  347. /// </summary>
  348. /// <value>The primary image path.</value>
  349. [JsonIgnore]
  350. public string PrimaryImagePath => this.GetImagePath(ImageType.Primary);
  351. public bool IsMetadataFetcherEnabled(LibraryOptions libraryOptions, string name)
  352. {
  353. if (SourceType == SourceType.Channel)
  354. {
  355. // hack alert
  356. return !EnableMediaSourceDisplay;
  357. }
  358. var typeOptions = libraryOptions.GetTypeOptions(GetType().Name);
  359. if (typeOptions != null)
  360. {
  361. return typeOptions.MetadataFetchers.Contains(name, StringComparer.OrdinalIgnoreCase);
  362. }
  363. if (!libraryOptions.EnableInternetProviders)
  364. {
  365. return false;
  366. }
  367. var itemConfig = ConfigurationManager.Configuration.MetadataOptions.FirstOrDefault(i => string.Equals(i.ItemType, GetType().Name, StringComparison.OrdinalIgnoreCase));
  368. return itemConfig == null || !itemConfig.DisabledMetadataFetchers.Contains(name, StringComparer.OrdinalIgnoreCase);
  369. }
  370. public bool IsImageFetcherEnabled(LibraryOptions libraryOptions, string name)
  371. {
  372. if (this is Channel)
  373. {
  374. // hack alert
  375. return true;
  376. }
  377. if (SourceType == SourceType.Channel)
  378. {
  379. // hack alert
  380. return !EnableMediaSourceDisplay;
  381. }
  382. var typeOptions = libraryOptions.GetTypeOptions(GetType().Name);
  383. if (typeOptions != null)
  384. {
  385. return typeOptions.ImageFetchers.Contains(name, StringComparer.OrdinalIgnoreCase);
  386. }
  387. if (!libraryOptions.EnableInternetProviders)
  388. {
  389. return false;
  390. }
  391. var itemConfig = ConfigurationManager.Configuration.MetadataOptions.FirstOrDefault(i => string.Equals(i.ItemType, GetType().Name, StringComparison.OrdinalIgnoreCase));
  392. return itemConfig == null || !itemConfig.DisabledImageFetchers.Contains(name, StringComparer.OrdinalIgnoreCase);
  393. }
  394. public virtual bool CanDelete()
  395. {
  396. if (SourceType == SourceType.Channel)
  397. {
  398. return ChannelManager.CanDelete(this);
  399. }
  400. return IsFileProtocol;
  401. }
  402. public virtual bool IsAuthorizedToDelete(User user, List<Folder> allCollectionFolders)
  403. {
  404. if (user.Policy.EnableContentDeletion)
  405. {
  406. return true;
  407. }
  408. var allowed = user.Policy.EnableContentDeletionFromFolders;
  409. if (SourceType == SourceType.Channel)
  410. {
  411. return allowed.Contains(ChannelId.ToString(""), StringComparer.OrdinalIgnoreCase);
  412. }
  413. else
  414. {
  415. var collectionFolders = LibraryManager.GetCollectionFolders(this, allCollectionFolders);
  416. foreach (var folder in collectionFolders)
  417. {
  418. if (allowed.Contains(folder.Id.ToString("N", CultureInfo.InvariantCulture), StringComparer.OrdinalIgnoreCase))
  419. {
  420. return true;
  421. }
  422. }
  423. }
  424. return false;
  425. }
  426. public bool CanDelete(User user, List<Folder> allCollectionFolders)
  427. {
  428. return CanDelete() && IsAuthorizedToDelete(user, allCollectionFolders);
  429. }
  430. public bool CanDelete(User user)
  431. {
  432. var allCollectionFolders = LibraryManager.GetUserRootFolder().Children.OfType<Folder>().ToList();
  433. return CanDelete(user, allCollectionFolders);
  434. }
  435. public virtual bool CanDownload()
  436. {
  437. return false;
  438. }
  439. public virtual bool IsAuthorizedToDownload(User user)
  440. {
  441. return user.Policy.EnableContentDownloading;
  442. }
  443. public bool CanDownload(User user)
  444. {
  445. return CanDownload() && IsAuthorizedToDownload(user);
  446. }
  447. /// <summary>
  448. /// Gets or sets the date created.
  449. /// </summary>
  450. /// <value>The date created.</value>
  451. [JsonIgnore]
  452. public DateTime DateCreated { get; set; }
  453. /// <summary>
  454. /// Gets or sets the date modified.
  455. /// </summary>
  456. /// <value>The date modified.</value>
  457. [JsonIgnore]
  458. public DateTime DateModified { get; set; }
  459. public DateTime DateLastSaved { get; set; }
  460. [JsonIgnore]
  461. public DateTime DateLastRefreshed { get; set; }
  462. /// <summary>
  463. /// The logger
  464. /// </summary>
  465. public static ILogger Logger { get; set; }
  466. public static ILibraryManager LibraryManager { get; set; }
  467. public static IServerConfigurationManager ConfigurationManager { get; set; }
  468. public static IProviderManager ProviderManager { get; set; }
  469. public static ILocalizationManager LocalizationManager { get; set; }
  470. public static IItemRepository ItemRepository { get; set; }
  471. public static IFileSystem FileSystem { get; set; }
  472. public static IUserDataManager UserDataManager { get; set; }
  473. public static IChannelManager ChannelManager { get; set; }
  474. public static IMediaSourceManager MediaSourceManager { get; set; }
  475. /// <summary>
  476. /// Returns a <see cref="string" /> that represents this instance.
  477. /// </summary>
  478. /// <returns>A <see cref="string" /> that represents this instance.</returns>
  479. public override string ToString()
  480. {
  481. return Name;
  482. }
  483. [JsonIgnore]
  484. public bool IsLocked { get; set; }
  485. /// <summary>
  486. /// Gets or sets the locked fields.
  487. /// </summary>
  488. /// <value>The locked fields.</value>
  489. [JsonIgnore]
  490. public MetadataFields[] LockedFields { get; set; }
  491. /// <summary>
  492. /// Gets the type of the media.
  493. /// </summary>
  494. /// <value>The type of the media.</value>
  495. [JsonIgnore]
  496. public virtual string MediaType => null;
  497. [JsonIgnore]
  498. public virtual string[] PhysicalLocations
  499. {
  500. get
  501. {
  502. if (!IsFileProtocol)
  503. {
  504. return new string[] { };
  505. }
  506. return new[] { Path };
  507. }
  508. }
  509. private string _forcedSortName;
  510. /// <summary>
  511. /// Gets or sets the name of the forced sort.
  512. /// </summary>
  513. /// <value>The name of the forced sort.</value>
  514. [JsonIgnore]
  515. public string ForcedSortName
  516. {
  517. get => _forcedSortName;
  518. set { _forcedSortName = value; _sortName = null; }
  519. }
  520. private string _sortName;
  521. /// <summary>
  522. /// Gets the name of the sort.
  523. /// </summary>
  524. /// <value>The name of the sort.</value>
  525. [JsonIgnore]
  526. public string SortName
  527. {
  528. get
  529. {
  530. if (_sortName == null)
  531. {
  532. if (!string.IsNullOrEmpty(ForcedSortName))
  533. {
  534. // Need the ToLower because that's what CreateSortName does
  535. _sortName = ModifySortChunks(ForcedSortName).ToLowerInvariant();
  536. }
  537. else
  538. {
  539. _sortName = CreateSortName();
  540. }
  541. }
  542. return _sortName;
  543. }
  544. set => _sortName = value;
  545. }
  546. public string GetInternalMetadataPath()
  547. {
  548. var basePath = ConfigurationManager.ApplicationPaths.InternalMetadataPath;
  549. return GetInternalMetadataPath(basePath);
  550. }
  551. protected virtual string GetInternalMetadataPath(string basePath)
  552. {
  553. if (SourceType == SourceType.Channel)
  554. {
  555. return System.IO.Path.Combine(basePath, "channels", ChannelId.ToString("N", CultureInfo.InvariantCulture), Id.ToString("N", CultureInfo.InvariantCulture));
  556. }
  557. var idString = Id.ToString("N", CultureInfo.InvariantCulture);
  558. basePath = System.IO.Path.Combine(basePath, "library");
  559. return System.IO.Path.Combine(basePath, idString.Substring(0, 2), idString);
  560. }
  561. /// <summary>
  562. /// Creates the name of the sort.
  563. /// </summary>
  564. /// <returns>System.String.</returns>
  565. protected virtual string CreateSortName()
  566. {
  567. if (Name == null) return null; //some items may not have name filled in properly
  568. if (!EnableAlphaNumericSorting)
  569. {
  570. return Name.TrimStart();
  571. }
  572. var sortable = Name.Trim().ToLowerInvariant();
  573. foreach (var removeChar in ConfigurationManager.Configuration.SortRemoveCharacters)
  574. {
  575. sortable = sortable.Replace(removeChar, string.Empty);
  576. }
  577. foreach (var replaceChar in ConfigurationManager.Configuration.SortReplaceCharacters)
  578. {
  579. sortable = sortable.Replace(replaceChar, " ");
  580. }
  581. foreach (var search in ConfigurationManager.Configuration.SortRemoveWords)
  582. {
  583. // Remove from beginning if a space follows
  584. if (sortable.StartsWith(search + " "))
  585. {
  586. sortable = sortable.Remove(0, search.Length + 1);
  587. }
  588. // Remove from middle if surrounded by spaces
  589. sortable = sortable.Replace(" " + search + " ", " ");
  590. // Remove from end if followed by a space
  591. if (sortable.EndsWith(" " + search))
  592. {
  593. sortable = sortable.Remove(sortable.Length - (search.Length + 1));
  594. }
  595. }
  596. return ModifySortChunks(sortable);
  597. }
  598. private string ModifySortChunks(string name)
  599. {
  600. var chunks = GetSortChunks(name);
  601. var builder = new StringBuilder();
  602. foreach (var chunk in chunks)
  603. {
  604. var chunkBuilder = chunk.Item1;
  605. // This chunk is numeric
  606. if (chunk.Item2)
  607. {
  608. while (chunkBuilder.Length < 10)
  609. {
  610. chunkBuilder.Insert(0, '0');
  611. }
  612. }
  613. builder.Append(chunkBuilder);
  614. }
  615. //logger.LogDebug("ModifySortChunks Start: {0} End: {1}", name, builder.ToString());
  616. return builder.ToString().RemoveDiacritics();
  617. }
  618. [JsonIgnore]
  619. public bool EnableMediaSourceDisplay
  620. {
  621. get
  622. {
  623. if (SourceType == SourceType.Channel)
  624. {
  625. return ChannelManager.EnableMediaSourceDisplay(this);
  626. }
  627. return true;
  628. }
  629. }
  630. [JsonIgnore]
  631. public Guid ParentId { get; set; }
  632. /// <summary>
  633. /// Gets or sets the parent.
  634. /// </summary>
  635. /// <value>The parent.</value>
  636. [JsonIgnore]
  637. public Folder Parent
  638. {
  639. get => GetParent() as Folder;
  640. set
  641. {
  642. }
  643. }
  644. public void SetParent(Folder parent)
  645. {
  646. ParentId = parent == null ? Guid.Empty : parent.Id;
  647. }
  648. public BaseItem GetParent()
  649. {
  650. var parentId = ParentId;
  651. if (!parentId.Equals(Guid.Empty))
  652. {
  653. return LibraryManager.GetItemById(parentId);
  654. }
  655. return null;
  656. }
  657. public IEnumerable<BaseItem> GetParents()
  658. {
  659. var parent = GetParent();
  660. while (parent != null)
  661. {
  662. yield return parent;
  663. parent = parent.GetParent();
  664. }
  665. }
  666. /// <summary>
  667. /// Finds a parent of a given type
  668. /// </summary>
  669. /// <typeparam name="T"></typeparam>
  670. /// <returns>``0.</returns>
  671. public T FindParent<T>()
  672. where T : Folder
  673. {
  674. foreach (var parent in GetParents())
  675. {
  676. var item = parent as T;
  677. if (item != null)
  678. {
  679. return item;
  680. }
  681. }
  682. return null;
  683. }
  684. [JsonIgnore]
  685. public virtual Guid DisplayParentId
  686. {
  687. get
  688. {
  689. var parentId = ParentId;
  690. return parentId;
  691. }
  692. }
  693. [JsonIgnore]
  694. public BaseItem DisplayParent
  695. {
  696. get
  697. {
  698. var id = DisplayParentId;
  699. if (id.Equals(Guid.Empty))
  700. {
  701. return null;
  702. }
  703. return LibraryManager.GetItemById(id);
  704. }
  705. }
  706. /// <summary>
  707. /// When the item first debuted. For movies this could be premiere date, episodes would be first aired
  708. /// </summary>
  709. /// <value>The premiere date.</value>
  710. [JsonIgnore]
  711. public DateTime? PremiereDate { get; set; }
  712. /// <summary>
  713. /// Gets or sets the end date.
  714. /// </summary>
  715. /// <value>The end date.</value>
  716. [JsonIgnore]
  717. public DateTime? EndDate { get; set; }
  718. /// <summary>
  719. /// Gets or sets the official rating.
  720. /// </summary>
  721. /// <value>The official rating.</value>
  722. [JsonIgnore]
  723. public string OfficialRating { get; set; }
  724. [JsonIgnore]
  725. public int InheritedParentalRatingValue { get; set; }
  726. /// <summary>
  727. /// Gets or sets the critic rating.
  728. /// </summary>
  729. /// <value>The critic rating.</value>
  730. [JsonIgnore]
  731. public float? CriticRating { get; set; }
  732. /// <summary>
  733. /// Gets or sets the custom rating.
  734. /// </summary>
  735. /// <value>The custom rating.</value>
  736. [JsonIgnore]
  737. public string CustomRating { get; set; }
  738. /// <summary>
  739. /// Gets or sets the overview.
  740. /// </summary>
  741. /// <value>The overview.</value>
  742. [JsonIgnore]
  743. public string Overview { get; set; }
  744. /// <summary>
  745. /// Gets or sets the studios.
  746. /// </summary>
  747. /// <value>The studios.</value>
  748. [JsonIgnore]
  749. public string[] Studios { get; set; }
  750. /// <summary>
  751. /// Gets or sets the genres.
  752. /// </summary>
  753. /// <value>The genres.</value>
  754. [JsonIgnore]
  755. public string[] Genres { get; set; }
  756. /// <summary>
  757. /// Gets or sets the tags.
  758. /// </summary>
  759. /// <value>The tags.</value>
  760. [JsonIgnore]
  761. public string[] Tags { get; set; }
  762. [JsonIgnore]
  763. public string[] ProductionLocations { get; set; }
  764. /// <summary>
  765. /// Gets or sets the home page URL.
  766. /// </summary>
  767. /// <value>The home page URL.</value>
  768. [JsonIgnore]
  769. public string HomePageUrl { get; set; }
  770. /// <summary>
  771. /// Gets or sets the community rating.
  772. /// </summary>
  773. /// <value>The community rating.</value>
  774. [JsonIgnore]
  775. public float? CommunityRating { get; set; }
  776. /// <summary>
  777. /// Gets or sets the run time ticks.
  778. /// </summary>
  779. /// <value>The run time ticks.</value>
  780. [JsonIgnore]
  781. public long? RunTimeTicks { get; set; }
  782. /// <summary>
  783. /// Gets or sets the production year.
  784. /// </summary>
  785. /// <value>The production year.</value>
  786. [JsonIgnore]
  787. public int? ProductionYear { get; set; }
  788. /// <summary>
  789. /// If the item is part of a series, this is it's number in the series.
  790. /// This could be episode number, album track number, etc.
  791. /// </summary>
  792. /// <value>The index number.</value>
  793. [JsonIgnore]
  794. public int? IndexNumber { get; set; }
  795. /// <summary>
  796. /// For an episode this could be the season number, or for a song this could be the disc number.
  797. /// </summary>
  798. /// <value>The parent index number.</value>
  799. [JsonIgnore]
  800. public int? ParentIndexNumber { get; set; }
  801. [JsonIgnore]
  802. public virtual bool HasLocalAlternateVersions => false;
  803. [JsonIgnore]
  804. public string OfficialRatingForComparison
  805. {
  806. get
  807. {
  808. var officialRating = OfficialRating;
  809. if (!string.IsNullOrEmpty(officialRating))
  810. {
  811. return officialRating;
  812. }
  813. var parent = DisplayParent;
  814. if (parent != null)
  815. {
  816. return parent.OfficialRatingForComparison;
  817. }
  818. return null;
  819. }
  820. }
  821. [JsonIgnore]
  822. public string CustomRatingForComparison
  823. {
  824. get
  825. {
  826. var customRating = CustomRating;
  827. if (!string.IsNullOrEmpty(customRating))
  828. {
  829. return customRating;
  830. }
  831. var parent = DisplayParent;
  832. if (parent != null)
  833. {
  834. return parent.CustomRatingForComparison;
  835. }
  836. return null;
  837. }
  838. }
  839. /// <summary>
  840. /// Gets the play access.
  841. /// </summary>
  842. /// <param name="user">The user.</param>
  843. /// <returns>PlayAccess.</returns>
  844. public PlayAccess GetPlayAccess(User user)
  845. {
  846. if (!user.Policy.EnableMediaPlayback)
  847. {
  848. return PlayAccess.None;
  849. }
  850. //if (!user.IsParentalScheduleAllowed())
  851. //{
  852. // return PlayAccess.None;
  853. //}
  854. return PlayAccess.Full;
  855. }
  856. public virtual List<MediaStream> GetMediaStreams()
  857. {
  858. return MediaSourceManager.GetMediaStreams(new MediaStreamQuery
  859. {
  860. ItemId = Id
  861. });
  862. }
  863. protected virtual bool IsActiveRecording()
  864. {
  865. return false;
  866. }
  867. public virtual List<MediaSourceInfo> GetMediaSources(bool enablePathSubstitution)
  868. {
  869. if (SourceType == SourceType.Channel)
  870. {
  871. var sources = ChannelManager.GetStaticMediaSources(this, CancellationToken.None)
  872. .ToList();
  873. if (sources.Count > 0)
  874. {
  875. return sources;
  876. }
  877. }
  878. var list = GetAllItemsForMediaSources();
  879. var result = list.Select(i => GetVersionInfo(enablePathSubstitution, i.Item1, i.Item2)).ToList();
  880. if (IsActiveRecording())
  881. {
  882. foreach (var mediaSource in result)
  883. {
  884. mediaSource.Type = MediaSourceType.Placeholder;
  885. }
  886. }
  887. return result.OrderBy(i =>
  888. {
  889. if (i.VideoType == VideoType.VideoFile)
  890. {
  891. return 0;
  892. }
  893. return 1;
  894. }).ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
  895. .ThenByDescending(i =>
  896. {
  897. var stream = i.VideoStream;
  898. return stream == null || stream.Width == null ? 0 : stream.Width.Value;
  899. })
  900. .ToList();
  901. }
  902. protected virtual List<Tuple<BaseItem, MediaSourceType>> GetAllItemsForMediaSources()
  903. {
  904. return new List<Tuple<BaseItem, MediaSourceType>>();
  905. }
  906. private MediaSourceInfo GetVersionInfo(bool enablePathSubstitution, BaseItem item, MediaSourceType type)
  907. {
  908. if (item == null)
  909. {
  910. throw new ArgumentNullException(nameof(item));
  911. }
  912. var protocol = item.PathProtocol;
  913. var info = new MediaSourceInfo
  914. {
  915. Id = item.Id.ToString("N", CultureInfo.InvariantCulture),
  916. Protocol = protocol ?? MediaProtocol.File,
  917. MediaStreams = MediaSourceManager.GetMediaStreams(item.Id),
  918. MediaAttachments = MediaSourceManager.GetMediaAttachments(item.Id),
  919. Name = GetMediaSourceName(item),
  920. Path = enablePathSubstitution ? GetMappedPath(item, item.Path, protocol) : item.Path,
  921. RunTimeTicks = item.RunTimeTicks,
  922. Container = item.Container,
  923. Size = item.Size,
  924. Type = type
  925. };
  926. if (string.IsNullOrEmpty(info.Path))
  927. {
  928. info.Type = MediaSourceType.Placeholder;
  929. }
  930. if (info.Protocol == MediaProtocol.File)
  931. {
  932. info.ETag = item.DateModified.Ticks.ToString(CultureInfo.InvariantCulture).GetMD5().ToString("N", CultureInfo.InvariantCulture);
  933. }
  934. var video = item as Video;
  935. if (video != null)
  936. {
  937. info.IsoType = video.IsoType;
  938. info.VideoType = video.VideoType;
  939. info.Video3DFormat = video.Video3DFormat;
  940. info.Timestamp = video.Timestamp;
  941. if (video.IsShortcut)
  942. {
  943. info.IsRemote = true;
  944. info.Path = video.ShortcutPath;
  945. info.Protocol = MediaSourceManager.GetPathProtocol(info.Path);
  946. }
  947. if (string.IsNullOrEmpty(info.Container))
  948. {
  949. if (video.VideoType == VideoType.VideoFile || video.VideoType == VideoType.Iso)
  950. {
  951. if (protocol.HasValue && protocol.Value == MediaProtocol.File)
  952. {
  953. info.Container = System.IO.Path.GetExtension(item.Path).TrimStart('.');
  954. }
  955. }
  956. }
  957. }
  958. if (string.IsNullOrEmpty(info.Container))
  959. {
  960. if (protocol.HasValue && protocol.Value == MediaProtocol.File)
  961. {
  962. info.Container = System.IO.Path.GetExtension(item.Path).TrimStart('.');
  963. }
  964. }
  965. if (info.SupportsDirectStream && !string.IsNullOrEmpty(info.Path))
  966. {
  967. info.SupportsDirectStream = MediaSourceManager.SupportsDirectStream(info.Path, info.Protocol);
  968. }
  969. if (video != null && video.VideoType != VideoType.VideoFile)
  970. {
  971. info.SupportsDirectStream = false;
  972. }
  973. info.Bitrate = item.TotalBitrate;
  974. info.InferTotalBitrate();
  975. return info;
  976. }
  977. private string GetMediaSourceName(BaseItem item)
  978. {
  979. var terms = new List<string>();
  980. var path = item.Path;
  981. if (item.IsFileProtocol && !string.IsNullOrEmpty(path))
  982. {
  983. if (HasLocalAlternateVersions)
  984. {
  985. var displayName = System.IO.Path.GetFileNameWithoutExtension(path)
  986. .Replace(System.IO.Path.GetFileName(ContainingFolderPath), string.Empty, StringComparison.OrdinalIgnoreCase)
  987. .TrimStart(new char[] { ' ', '-' });
  988. if (!string.IsNullOrEmpty(displayName))
  989. {
  990. terms.Add(displayName);
  991. }
  992. }
  993. if (terms.Count == 0)
  994. {
  995. var displayName = System.IO.Path.GetFileNameWithoutExtension(path);
  996. terms.Add(displayName);
  997. }
  998. }
  999. if (terms.Count == 0)
  1000. {
  1001. terms.Add(item.Name);
  1002. }
  1003. var video = item as Video;
  1004. if (video != null)
  1005. {
  1006. if (video.Video3DFormat.HasValue)
  1007. {
  1008. terms.Add("3D");
  1009. }
  1010. if (video.VideoType == VideoType.BluRay)
  1011. {
  1012. terms.Add("Bluray");
  1013. }
  1014. else if (video.VideoType == VideoType.Dvd)
  1015. {
  1016. terms.Add("DVD");
  1017. }
  1018. else if (video.VideoType == VideoType.Iso)
  1019. {
  1020. if (video.IsoType.HasValue)
  1021. {
  1022. if (video.IsoType.Value == Model.Entities.IsoType.BluRay)
  1023. {
  1024. terms.Add("Bluray");
  1025. }
  1026. else if (video.IsoType.Value == Model.Entities.IsoType.Dvd)
  1027. {
  1028. terms.Add("DVD");
  1029. }
  1030. }
  1031. else
  1032. {
  1033. terms.Add("ISO");
  1034. }
  1035. }
  1036. }
  1037. return string.Join("/", terms.ToArray());
  1038. }
  1039. /// <summary>
  1040. /// Loads the theme songs.
  1041. /// </summary>
  1042. /// <returns>List{Audio.Audio}.</returns>
  1043. private static Audio.Audio[] LoadThemeSongs(List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  1044. {
  1045. var files = fileSystemChildren.Where(i => i.IsDirectory)
  1046. .Where(i => string.Equals(i.Name, ThemeSongsFolderName, StringComparison.OrdinalIgnoreCase))
  1047. .SelectMany(i => FileSystem.GetFiles(i.FullName))
  1048. .ToList();
  1049. // Support plex/xbmc convention
  1050. files.AddRange(fileSystemChildren
  1051. .Where(i => !i.IsDirectory && string.Equals(FileSystem.GetFileNameWithoutExtension(i), ThemeSongFilename, StringComparison.OrdinalIgnoreCase))
  1052. );
  1053. return LibraryManager.ResolvePaths(files, directoryService, null, new LibraryOptions())
  1054. .OfType<Audio.Audio>()
  1055. .Select(audio =>
  1056. {
  1057. // Try to retrieve it from the db. If we don't find it, use the resolved version
  1058. var dbItem = LibraryManager.GetItemById(audio.Id) as Audio.Audio;
  1059. if (dbItem != null)
  1060. {
  1061. audio = dbItem;
  1062. }
  1063. else
  1064. {
  1065. // item is new
  1066. audio.ExtraType = MediaBrowser.Model.Entities.ExtraType.ThemeSong;
  1067. }
  1068. return audio;
  1069. // Sort them so that the list can be easily compared for changes
  1070. }).OrderBy(i => i.Path).ToArray();
  1071. }
  1072. /// <summary>
  1073. /// Loads the video backdrops.
  1074. /// </summary>
  1075. /// <returns>List{Video}.</returns>
  1076. private static Video[] LoadThemeVideos(IEnumerable<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  1077. {
  1078. var files = fileSystemChildren.Where(i => i.IsDirectory)
  1079. .Where(i => string.Equals(i.Name, ThemeVideosFolderName, StringComparison.OrdinalIgnoreCase))
  1080. .SelectMany(i => FileSystem.GetFiles(i.FullName));
  1081. return LibraryManager.ResolvePaths(files, directoryService, null, new LibraryOptions())
  1082. .OfType<Video>()
  1083. .Select(item =>
  1084. {
  1085. // Try to retrieve it from the db. If we don't find it, use the resolved version
  1086. if (LibraryManager.GetItemById(item.Id) is Video dbItem)
  1087. {
  1088. item = dbItem;
  1089. }
  1090. else
  1091. {
  1092. // item is new
  1093. item.ExtraType = Model.Entities.ExtraType.ThemeVideo;
  1094. }
  1095. return item;
  1096. // Sort them so that the list can be easily compared for changes
  1097. }).OrderBy(i => i.Path).ToArray();
  1098. }
  1099. protected virtual BaseItem[] LoadExtras(List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  1100. {
  1101. var extras = new List<Video>();
  1102. var folders = fileSystemChildren.Where(i => i.IsDirectory).ToArray();
  1103. foreach (var extraFolderName in AllExtrasTypesFolderNames)
  1104. {
  1105. var files = folders
  1106. .Where(i => string.Equals(i.Name, extraFolderName, StringComparison.OrdinalIgnoreCase))
  1107. .SelectMany(i => FileSystem.GetFiles(i.FullName));
  1108. extras.AddRange(LibraryManager.ResolvePaths(files, directoryService, null, new LibraryOptions())
  1109. .OfType<Video>()
  1110. .Select(item =>
  1111. {
  1112. // Try to retrieve it from the db. If we don't find it, use the resolved version
  1113. if (LibraryManager.GetItemById(item.Id) is Video dbItem)
  1114. {
  1115. item = dbItem;
  1116. }
  1117. // Use some hackery to get the extra type based on foldername
  1118. item.ExtraType = Enum.TryParse(extraFolderName.Replace(" ", string.Empty), true, out ExtraType extraType)
  1119. ? extraType
  1120. : Model.Entities.ExtraType.Unknown;
  1121. return item;
  1122. // Sort them so that the list can be easily compared for changes
  1123. }).OrderBy(i => i.Path));
  1124. }
  1125. return extras.ToArray();
  1126. }
  1127. public Task RefreshMetadata(CancellationToken cancellationToken)
  1128. {
  1129. return RefreshMetadata(new MetadataRefreshOptions(new DirectoryService(FileSystem)), cancellationToken);
  1130. }
  1131. protected virtual void TriggerOnRefreshStart()
  1132. {
  1133. }
  1134. protected virtual void TriggerOnRefreshComplete()
  1135. {
  1136. }
  1137. /// <summary>
  1138. /// Overrides the base implementation to refresh metadata for local trailers
  1139. /// </summary>
  1140. /// <param name="options">The options.</param>
  1141. /// <param name="cancellationToken">The cancellation token.</param>
  1142. /// <returns>true if a provider reports we changed</returns>
  1143. public async Task<ItemUpdateType> RefreshMetadata(MetadataRefreshOptions options, CancellationToken cancellationToken)
  1144. {
  1145. TriggerOnRefreshStart();
  1146. var requiresSave = false;
  1147. if (SupportsOwnedItems)
  1148. {
  1149. try
  1150. {
  1151. var files = IsFileProtocol ?
  1152. GetFileSystemChildren(options.DirectoryService).ToList() :
  1153. new List<FileSystemMetadata>();
  1154. var ownedItemsChanged = await RefreshedOwnedItems(options, files, cancellationToken).ConfigureAwait(false);
  1155. if (ownedItemsChanged)
  1156. {
  1157. requiresSave = true;
  1158. }
  1159. }
  1160. catch (Exception ex)
  1161. {
  1162. Logger.LogError(ex, "Error refreshing owned items for {path}", Path ?? Name);
  1163. }
  1164. }
  1165. try
  1166. {
  1167. var refreshOptions = requiresSave
  1168. ? new MetadataRefreshOptions(options)
  1169. {
  1170. ForceSave = true
  1171. }
  1172. : options;
  1173. return await ProviderManager.RefreshSingleItem(this, refreshOptions, cancellationToken).ConfigureAwait(false);
  1174. }
  1175. finally
  1176. {
  1177. TriggerOnRefreshComplete();
  1178. }
  1179. }
  1180. [JsonIgnore]
  1181. protected virtual bool SupportsOwnedItems => !ParentId.Equals(Guid.Empty) && IsFileProtocol;
  1182. [JsonIgnore]
  1183. public virtual bool SupportsPeople => false;
  1184. [JsonIgnore]
  1185. public virtual bool SupportsThemeMedia => false;
  1186. /// <summary>
  1187. /// Refreshes owned items such as trailers, theme videos, special features, etc.
  1188. /// Returns true or false indicating if changes were found.
  1189. /// </summary>
  1190. /// <param name="options"></param>
  1191. /// <param name="fileSystemChildren"></param>
  1192. /// <param name="cancellationToken"></param>
  1193. /// <returns></returns>
  1194. protected virtual async Task<bool> RefreshedOwnedItems(MetadataRefreshOptions options, List<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
  1195. {
  1196. var themeSongsChanged = false;
  1197. var themeVideosChanged = false;
  1198. var extrasChanged = false;
  1199. var localTrailersChanged = false;
  1200. if (IsFileProtocol && SupportsOwnedItems)
  1201. {
  1202. if (SupportsThemeMedia)
  1203. {
  1204. if (!IsInMixedFolder)
  1205. {
  1206. themeSongsChanged = await RefreshThemeSongs(this, options, fileSystemChildren, cancellationToken).ConfigureAwait(false);
  1207. themeVideosChanged = await RefreshThemeVideos(this, options, fileSystemChildren, cancellationToken).ConfigureAwait(false);
  1208. extrasChanged = await RefreshExtras(this, options, fileSystemChildren, cancellationToken).ConfigureAwait(false);
  1209. }
  1210. }
  1211. var hasTrailers = this as IHasTrailers;
  1212. if (hasTrailers != null)
  1213. {
  1214. localTrailersChanged = await RefreshLocalTrailers(hasTrailers, options, fileSystemChildren, cancellationToken).ConfigureAwait(false);
  1215. }
  1216. }
  1217. return themeSongsChanged || themeVideosChanged || extrasChanged || localTrailersChanged;
  1218. }
  1219. protected virtual FileSystemMetadata[] GetFileSystemChildren(IDirectoryService directoryService)
  1220. {
  1221. var path = ContainingFolderPath;
  1222. return directoryService.GetFileSystemEntries(path);
  1223. }
  1224. private async Task<bool> RefreshLocalTrailers(IHasTrailers item, MetadataRefreshOptions options, List<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
  1225. {
  1226. var newItems = LibraryManager.FindTrailers(this, fileSystemChildren, options.DirectoryService);
  1227. var newItemIds = newItems.Select(i => i.Id);
  1228. var itemsChanged = !item.LocalTrailerIds.SequenceEqual(newItemIds);
  1229. var ownerId = item.Id;
  1230. var tasks = newItems.Select(i =>
  1231. {
  1232. var subOptions = new MetadataRefreshOptions(options);
  1233. if (i.ExtraType != Model.Entities.ExtraType.Trailer ||
  1234. i.OwnerId != ownerId ||
  1235. !i.ParentId.Equals(Guid.Empty))
  1236. {
  1237. i.ExtraType = Model.Entities.ExtraType.Trailer;
  1238. i.OwnerId = ownerId;
  1239. i.ParentId = Guid.Empty;
  1240. subOptions.ForceSave = true;
  1241. }
  1242. return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
  1243. });
  1244. await Task.WhenAll(tasks).ConfigureAwait(false);
  1245. item.LocalTrailerIds = newItemIds.ToArray();
  1246. return itemsChanged;
  1247. }
  1248. private async Task<bool> RefreshExtras(BaseItem item, MetadataRefreshOptions options, List<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
  1249. {
  1250. var extras = LoadExtras(fileSystemChildren, options.DirectoryService);
  1251. var themeVideos = LoadThemeVideos(fileSystemChildren, options.DirectoryService);
  1252. var themeSongs = LoadThemeSongs(fileSystemChildren, options.DirectoryService);
  1253. var newExtras = new BaseItem[extras.Length + themeVideos.Length + themeSongs.Length];
  1254. extras.CopyTo(newExtras, 0);
  1255. themeVideos.CopyTo(newExtras, extras.Length);
  1256. themeSongs.CopyTo(newExtras, extras.Length + themeVideos.Length);
  1257. var newExtraIds = newExtras.Select(i => i.Id).ToArray();
  1258. var extrasChanged = !item.ExtraIds.SequenceEqual(newExtraIds);
  1259. if (extrasChanged)
  1260. {
  1261. var ownerId = item.Id;
  1262. var tasks = newExtras.Select(i =>
  1263. {
  1264. var subOptions = new MetadataRefreshOptions(options);
  1265. if (i.OwnerId != ownerId || i.ParentId != Guid.Empty)
  1266. {
  1267. i.OwnerId = ownerId;
  1268. i.ParentId = Guid.Empty;
  1269. subOptions.ForceSave = true;
  1270. }
  1271. return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
  1272. });
  1273. await Task.WhenAll(tasks).ConfigureAwait(false);
  1274. item.ExtraIds = newExtraIds;
  1275. }
  1276. return extrasChanged;
  1277. }
  1278. private async Task<bool> RefreshThemeVideos(BaseItem item, MetadataRefreshOptions options, IEnumerable<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
  1279. {
  1280. var newThemeVideos = LoadThemeVideos(fileSystemChildren, options.DirectoryService);
  1281. var newThemeVideoIds = newThemeVideos.Select(i => i.Id).ToArray();
  1282. var themeVideosChanged = !item.ThemeVideoIds.SequenceEqual(newThemeVideoIds);
  1283. var ownerId = item.Id;
  1284. var tasks = newThemeVideos.Select(i =>
  1285. {
  1286. var subOptions = new MetadataRefreshOptions(options);
  1287. if (!i.ExtraType.HasValue ||
  1288. i.ExtraType.Value != Model.Entities.ExtraType.ThemeVideo ||
  1289. i.OwnerId != ownerId ||
  1290. !i.ParentId.Equals(Guid.Empty))
  1291. {
  1292. i.ExtraType = Model.Entities.ExtraType.ThemeVideo;
  1293. i.OwnerId = ownerId;
  1294. i.ParentId = Guid.Empty;
  1295. subOptions.ForceSave = true;
  1296. }
  1297. return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
  1298. });
  1299. await Task.WhenAll(tasks).ConfigureAwait(false);
  1300. item.ThemeVideoIds = newThemeVideoIds;
  1301. return themeVideosChanged;
  1302. }
  1303. /// <summary>
  1304. /// Refreshes the theme songs.
  1305. /// </summary>
  1306. private async Task<bool> RefreshThemeSongs(BaseItem item, MetadataRefreshOptions options, List<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
  1307. {
  1308. var newThemeSongs = LoadThemeSongs(fileSystemChildren, options.DirectoryService);
  1309. var newThemeSongIds = newThemeSongs.Select(i => i.Id).ToArray();
  1310. var themeSongsChanged = !item.ThemeSongIds.SequenceEqual(newThemeSongIds);
  1311. var ownerId = item.Id;
  1312. var tasks = newThemeSongs.Select(i =>
  1313. {
  1314. var subOptions = new MetadataRefreshOptions(options);
  1315. if (!i.ExtraType.HasValue ||
  1316. i.ExtraType.Value != Model.Entities.ExtraType.ThemeSong ||
  1317. i.OwnerId != ownerId ||
  1318. !i.ParentId.Equals(Guid.Empty))
  1319. {
  1320. i.ExtraType = Model.Entities.ExtraType.ThemeSong;
  1321. i.OwnerId = ownerId;
  1322. i.ParentId = Guid.Empty;
  1323. subOptions.ForceSave = true;
  1324. }
  1325. return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
  1326. });
  1327. await Task.WhenAll(tasks).ConfigureAwait(false);
  1328. item.ThemeSongIds = newThemeSongIds;
  1329. return themeSongsChanged;
  1330. }
  1331. /// <summary>
  1332. /// Gets or sets the provider ids.
  1333. /// </summary>
  1334. /// <value>The provider ids.</value>
  1335. [JsonIgnore]
  1336. public Dictionary<string, string> ProviderIds { get; set; }
  1337. [JsonIgnore]
  1338. public virtual Folder LatestItemsIndexContainer => null;
  1339. public virtual double GetDefaultPrimaryImageAspectRatio()
  1340. {
  1341. return 0;
  1342. }
  1343. public virtual string CreatePresentationUniqueKey()
  1344. {
  1345. return Id.ToString("N", CultureInfo.InvariantCulture);
  1346. }
  1347. [JsonIgnore]
  1348. public string PresentationUniqueKey { get; set; }
  1349. public string GetPresentationUniqueKey()
  1350. {
  1351. return PresentationUniqueKey ?? CreatePresentationUniqueKey();
  1352. }
  1353. public virtual bool RequiresRefresh()
  1354. {
  1355. return false;
  1356. }
  1357. public virtual List<string> GetUserDataKeys()
  1358. {
  1359. var list = new List<string>();
  1360. if (SourceType == SourceType.Channel)
  1361. {
  1362. if (!string.IsNullOrEmpty(ExternalId))
  1363. {
  1364. list.Add(ExternalId);
  1365. }
  1366. }
  1367. list.Add(Id.ToString());
  1368. return list;
  1369. }
  1370. internal virtual ItemUpdateType UpdateFromResolvedItem(BaseItem newItem)
  1371. {
  1372. var updateType = ItemUpdateType.None;
  1373. if (IsInMixedFolder != newItem.IsInMixedFolder)
  1374. {
  1375. IsInMixedFolder = newItem.IsInMixedFolder;
  1376. updateType |= ItemUpdateType.MetadataImport;
  1377. }
  1378. return updateType;
  1379. }
  1380. public void AfterMetadataRefresh()
  1381. {
  1382. _sortName = null;
  1383. }
  1384. /// <summary>
  1385. /// Gets the preferred metadata language.
  1386. /// </summary>
  1387. /// <returns>System.String.</returns>
  1388. public string GetPreferredMetadataLanguage()
  1389. {
  1390. string lang = PreferredMetadataLanguage;
  1391. if (string.IsNullOrEmpty(lang))
  1392. {
  1393. lang = GetParents()
  1394. .Select(i => i.PreferredMetadataLanguage)
  1395. .FirstOrDefault(i => !string.IsNullOrEmpty(i));
  1396. }
  1397. if (string.IsNullOrEmpty(lang))
  1398. {
  1399. lang = LibraryManager.GetCollectionFolders(this)
  1400. .Select(i => i.PreferredMetadataLanguage)
  1401. .FirstOrDefault(i => !string.IsNullOrEmpty(i));
  1402. }
  1403. if (string.IsNullOrEmpty(lang))
  1404. {
  1405. lang = LibraryManager.GetLibraryOptions(this).PreferredMetadataLanguage;
  1406. }
  1407. if (string.IsNullOrEmpty(lang))
  1408. {
  1409. lang = ConfigurationManager.Configuration.PreferredMetadataLanguage;
  1410. }
  1411. return lang;
  1412. }
  1413. /// <summary>
  1414. /// Gets the preferred metadata language.
  1415. /// </summary>
  1416. /// <returns>System.String.</returns>
  1417. public string GetPreferredMetadataCountryCode()
  1418. {
  1419. string lang = PreferredMetadataCountryCode;
  1420. if (string.IsNullOrEmpty(lang))
  1421. {
  1422. lang = GetParents()
  1423. .Select(i => i.PreferredMetadataCountryCode)
  1424. .FirstOrDefault(i => !string.IsNullOrEmpty(i));
  1425. }
  1426. if (string.IsNullOrEmpty(lang))
  1427. {
  1428. lang = LibraryManager.GetCollectionFolders(this)
  1429. .Select(i => i.PreferredMetadataCountryCode)
  1430. .FirstOrDefault(i => !string.IsNullOrEmpty(i));
  1431. }
  1432. if (string.IsNullOrEmpty(lang))
  1433. {
  1434. lang = LibraryManager.GetLibraryOptions(this).MetadataCountryCode;
  1435. }
  1436. if (string.IsNullOrEmpty(lang))
  1437. {
  1438. lang = ConfigurationManager.Configuration.MetadataCountryCode;
  1439. }
  1440. return lang;
  1441. }
  1442. public virtual bool IsSaveLocalMetadataEnabled()
  1443. {
  1444. if (SourceType == SourceType.Channel)
  1445. {
  1446. return false;
  1447. }
  1448. var libraryOptions = LibraryManager.GetLibraryOptions(this);
  1449. return libraryOptions.SaveLocalMetadata;
  1450. }
  1451. /// <summary>
  1452. /// Determines if a given user has access to this item
  1453. /// </summary>
  1454. /// <param name="user">The user.</param>
  1455. /// <returns><c>true</c> if [is parental allowed] [the specified user]; otherwise, <c>false</c>.</returns>
  1456. /// <exception cref="ArgumentNullException">user</exception>
  1457. public bool IsParentalAllowed(User user)
  1458. {
  1459. if (user == null)
  1460. {
  1461. throw new ArgumentNullException(nameof(user));
  1462. }
  1463. if (!IsVisibleViaTags(user))
  1464. {
  1465. return false;
  1466. }
  1467. var maxAllowedRating = user.Policy.MaxParentalRating;
  1468. if (maxAllowedRating == null)
  1469. {
  1470. return true;
  1471. }
  1472. var rating = CustomRatingForComparison;
  1473. if (string.IsNullOrEmpty(rating))
  1474. {
  1475. rating = OfficialRatingForComparison;
  1476. }
  1477. if (string.IsNullOrEmpty(rating))
  1478. {
  1479. return !GetBlockUnratedValue(user.Policy);
  1480. }
  1481. var value = LocalizationManager.GetRatingLevel(rating);
  1482. // Could not determine the integer value
  1483. if (!value.HasValue)
  1484. {
  1485. var isAllowed = !GetBlockUnratedValue(user.Policy);
  1486. if (!isAllowed)
  1487. {
  1488. Logger.LogDebug("{0} has an unrecognized parental rating of {1}.", Name, rating);
  1489. }
  1490. return isAllowed;
  1491. }
  1492. return value.Value <= maxAllowedRating.Value;
  1493. }
  1494. public int? GetParentalRatingValue()
  1495. {
  1496. var rating = CustomRating;
  1497. if (string.IsNullOrEmpty(rating))
  1498. {
  1499. rating = OfficialRating;
  1500. }
  1501. if (string.IsNullOrEmpty(rating))
  1502. {
  1503. return null;
  1504. }
  1505. return LocalizationManager.GetRatingLevel(rating);
  1506. }
  1507. public int? GetInheritedParentalRatingValue()
  1508. {
  1509. var rating = CustomRatingForComparison;
  1510. if (string.IsNullOrEmpty(rating))
  1511. {
  1512. rating = OfficialRatingForComparison;
  1513. }
  1514. if (string.IsNullOrEmpty(rating))
  1515. {
  1516. return null;
  1517. }
  1518. return LocalizationManager.GetRatingLevel(rating);
  1519. }
  1520. public List<string> GetInheritedTags()
  1521. {
  1522. var list = new List<string>();
  1523. list.AddRange(Tags);
  1524. foreach (var parent in GetParents())
  1525. {
  1526. list.AddRange(parent.Tags);
  1527. }
  1528. return list.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
  1529. }
  1530. private bool IsVisibleViaTags(User user)
  1531. {
  1532. var policy = user.Policy;
  1533. if (policy.BlockedTags.Any(i => Tags.Contains(i, StringComparer.OrdinalIgnoreCase)))
  1534. {
  1535. return false;
  1536. }
  1537. return true;
  1538. }
  1539. protected virtual bool IsAllowTagFilterEnforced()
  1540. {
  1541. return true;
  1542. }
  1543. public virtual UnratedItem GetBlockUnratedType()
  1544. {
  1545. if (SourceType == SourceType.Channel)
  1546. {
  1547. return UnratedItem.ChannelContent;
  1548. }
  1549. return UnratedItem.Other;
  1550. }
  1551. /// <summary>
  1552. /// Gets the block unrated value.
  1553. /// </summary>
  1554. /// <param name="config">The configuration.</param>
  1555. /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
  1556. protected virtual bool GetBlockUnratedValue(UserPolicy config)
  1557. {
  1558. // Don't block plain folders that are unrated. Let the media underneath get blocked
  1559. // Special folders like series and albums will override this method.
  1560. if (IsFolder)
  1561. {
  1562. return false;
  1563. }
  1564. if (this is IItemByName)
  1565. {
  1566. return false;
  1567. }
  1568. return config.BlockUnratedItems.Contains(GetBlockUnratedType());
  1569. }
  1570. /// <summary>
  1571. /// Determines if this folder should be visible to a given user.
  1572. /// Default is just parental allowed. Can be overridden for more functionality.
  1573. /// </summary>
  1574. /// <param name="user">The user.</param>
  1575. /// <returns><c>true</c> if the specified user is visible; otherwise, <c>false</c>.</returns>
  1576. /// <exception cref="ArgumentNullException">user</exception>
  1577. public virtual bool IsVisible(User user)
  1578. {
  1579. if (user == null)
  1580. {
  1581. throw new ArgumentNullException(nameof(user));
  1582. }
  1583. return IsParentalAllowed(user);
  1584. }
  1585. public virtual bool IsVisibleStandalone(User user)
  1586. {
  1587. if (SourceType == SourceType.Channel)
  1588. {
  1589. return IsVisibleStandaloneInternal(user, false) && Channel.IsChannelVisible(this, user);
  1590. }
  1591. return IsVisibleStandaloneInternal(user, true);
  1592. }
  1593. [JsonIgnore]
  1594. public virtual bool SupportsInheritedParentImages => false;
  1595. protected bool IsVisibleStandaloneInternal(User user, bool checkFolders)
  1596. {
  1597. if (!IsVisible(user))
  1598. {
  1599. return false;
  1600. }
  1601. if (GetParents().Any(i => !i.IsVisible(user)))
  1602. {
  1603. return false;
  1604. }
  1605. if (checkFolders)
  1606. {
  1607. var topParent = GetParents().LastOrDefault() ?? this;
  1608. if (string.IsNullOrEmpty(topParent.Path))
  1609. {
  1610. return true;
  1611. }
  1612. var itemCollectionFolders = LibraryManager.GetCollectionFolders(this).Select(i => i.Id).ToList();
  1613. if (itemCollectionFolders.Count > 0)
  1614. {
  1615. var userCollectionFolders = LibraryManager.GetUserRootFolder().GetChildren(user, true).Select(i => i.Id).ToList();
  1616. if (!itemCollectionFolders.Any(userCollectionFolders.Contains))
  1617. {
  1618. return false;
  1619. }
  1620. }
  1621. }
  1622. return true;
  1623. }
  1624. /// <summary>
  1625. /// Gets a value indicating whether this instance is folder.
  1626. /// </summary>
  1627. /// <value><c>true</c> if this instance is folder; otherwise, <c>false</c>.</value>
  1628. [JsonIgnore]
  1629. public virtual bool IsFolder => false;
  1630. [JsonIgnore]
  1631. public virtual bool IsDisplayedAsFolder => false;
  1632. public virtual string GetClientTypeName()
  1633. {
  1634. if (IsFolder && SourceType == SourceType.Channel && !(this is Channel))
  1635. {
  1636. return "ChannelFolderItem";
  1637. }
  1638. return GetType().Name;
  1639. }
  1640. /// <summary>
  1641. /// Gets the linked child.
  1642. /// </summary>
  1643. /// <param name="info">The info.</param>
  1644. /// <returns>BaseItem.</returns>
  1645. protected BaseItem GetLinkedChild(LinkedChild info)
  1646. {
  1647. // First get using the cached Id
  1648. if (info.ItemId.HasValue)
  1649. {
  1650. if (info.ItemId.Value.Equals(Guid.Empty))
  1651. {
  1652. return null;
  1653. }
  1654. var itemById = LibraryManager.GetItemById(info.ItemId.Value);
  1655. if (itemById != null)
  1656. {
  1657. return itemById;
  1658. }
  1659. }
  1660. var item = FindLinkedChild(info);
  1661. // If still null, log
  1662. if (item == null)
  1663. {
  1664. // Don't keep searching over and over
  1665. info.ItemId = Guid.Empty;
  1666. }
  1667. else
  1668. {
  1669. // Cache the id for next time
  1670. info.ItemId = item.Id;
  1671. }
  1672. return item;
  1673. }
  1674. private BaseItem FindLinkedChild(LinkedChild info)
  1675. {
  1676. var path = info.Path;
  1677. if (!string.IsNullOrEmpty(path))
  1678. {
  1679. path = FileSystem.MakeAbsolutePath(ContainingFolderPath, path);
  1680. var itemByPath = LibraryManager.FindByPath(path, null);
  1681. if (itemByPath == null)
  1682. {
  1683. Logger.LogWarning("Unable to find linked item at path {0}", info.Path);
  1684. }
  1685. return itemByPath;
  1686. }
  1687. if (!string.IsNullOrEmpty(info.LibraryItemId))
  1688. {
  1689. var item = LibraryManager.GetItemById(info.LibraryItemId);
  1690. if (item == null)
  1691. {
  1692. Logger.LogWarning("Unable to find linked item at path {0}", info.Path);
  1693. }
  1694. return item;
  1695. }
  1696. return null;
  1697. }
  1698. [JsonIgnore]
  1699. public virtual bool EnableRememberingTrackSelections => true;
  1700. /// <summary>
  1701. /// Adds a studio to the item
  1702. /// </summary>
  1703. /// <param name="name">The name.</param>
  1704. /// <exception cref="ArgumentNullException"></exception>
  1705. public void AddStudio(string name)
  1706. {
  1707. if (string.IsNullOrEmpty(name))
  1708. {
  1709. throw new ArgumentNullException(nameof(name));
  1710. }
  1711. var current = Studios;
  1712. if (!current.Contains(name, StringComparer.OrdinalIgnoreCase))
  1713. {
  1714. int curLen = current.Length;
  1715. if (curLen == 0)
  1716. {
  1717. Studios = new[] { name };
  1718. }
  1719. else
  1720. {
  1721. var newArr = new string[curLen + 1];
  1722. current.CopyTo(newArr, 0);
  1723. newArr[curLen] = name;
  1724. Studios = newArr;
  1725. }
  1726. }
  1727. }
  1728. public void SetStudios(IEnumerable<string> names)
  1729. {
  1730. Studios = names.Distinct().ToArray();
  1731. }
  1732. /// <summary>
  1733. /// Adds a genre to the item
  1734. /// </summary>
  1735. /// <param name="name">The name.</param>
  1736. /// <exception cref="ArgumentNullException"></exception>
  1737. public void AddGenre(string name)
  1738. {
  1739. if (string.IsNullOrEmpty(name))
  1740. {
  1741. throw new ArgumentNullException(nameof(name));
  1742. }
  1743. var genres = Genres;
  1744. if (!genres.Contains(name, StringComparer.OrdinalIgnoreCase))
  1745. {
  1746. var list = genres.ToList();
  1747. list.Add(name);
  1748. Genres = list.ToArray();
  1749. }
  1750. }
  1751. /// <summary>
  1752. /// Marks the played.
  1753. /// </summary>
  1754. /// <param name="user">The user.</param>
  1755. /// <param name="datePlayed">The date played.</param>
  1756. /// <param name="resetPosition">if set to <c>true</c> [reset position].</param>
  1757. /// <returns>Task.</returns>
  1758. /// <exception cref="ArgumentNullException"></exception>
  1759. public virtual void MarkPlayed(User user,
  1760. DateTime? datePlayed,
  1761. bool resetPosition)
  1762. {
  1763. if (user == null)
  1764. {
  1765. throw new ArgumentNullException(nameof(user));
  1766. }
  1767. var data = UserDataManager.GetUserData(user, this);
  1768. if (datePlayed.HasValue)
  1769. {
  1770. // Increment
  1771. data.PlayCount++;
  1772. }
  1773. // Ensure it's at least one
  1774. data.PlayCount = Math.Max(data.PlayCount, 1);
  1775. if (resetPosition)
  1776. {
  1777. data.PlaybackPositionTicks = 0;
  1778. }
  1779. data.LastPlayedDate = datePlayed ?? data.LastPlayedDate ?? DateTime.UtcNow;
  1780. data.Played = true;
  1781. UserDataManager.SaveUserData(user.Id, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None);
  1782. }
  1783. /// <summary>
  1784. /// Marks the unplayed.
  1785. /// </summary>
  1786. /// <param name="user">The user.</param>
  1787. /// <returns>Task.</returns>
  1788. /// <exception cref="ArgumentNullException"></exception>
  1789. public virtual void MarkUnplayed(User user)
  1790. {
  1791. if (user == null)
  1792. {
  1793. throw new ArgumentNullException(nameof(user));
  1794. }
  1795. var data = UserDataManager.GetUserData(user, this);
  1796. //I think it is okay to do this here.
  1797. // if this is only called when a user is manually forcing something to un-played
  1798. // then it probably is what we want to do...
  1799. data.PlayCount = 0;
  1800. data.PlaybackPositionTicks = 0;
  1801. data.LastPlayedDate = null;
  1802. data.Played = false;
  1803. UserDataManager.SaveUserData(user.Id, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None);
  1804. }
  1805. /// <summary>
  1806. /// Do whatever refreshing is necessary when the filesystem pertaining to this item has changed.
  1807. /// </summary>
  1808. public virtual void ChangedExternally()
  1809. {
  1810. ProviderManager.QueueRefresh(Id, new MetadataRefreshOptions(new DirectoryService(FileSystem)), RefreshPriority.High);
  1811. }
  1812. /// <summary>
  1813. /// Gets an image
  1814. /// </summary>
  1815. /// <param name="type">The type.</param>
  1816. /// <param name="imageIndex">Index of the image.</param>
  1817. /// <returns><c>true</c> if the specified type has image; otherwise, <c>false</c>.</returns>
  1818. /// <exception cref="ArgumentException">Backdrops should be accessed using Item.Backdrops</exception>
  1819. public bool HasImage(ImageType type, int imageIndex)
  1820. {
  1821. return GetImageInfo(type, imageIndex) != null;
  1822. }
  1823. public void SetImage(ItemImageInfo image, int index)
  1824. {
  1825. if (image.Type == ImageType.Chapter)
  1826. {
  1827. throw new ArgumentException("Cannot set chapter images using SetImagePath");
  1828. }
  1829. var existingImage = GetImageInfo(image.Type, index);
  1830. if (existingImage != null)
  1831. {
  1832. existingImage.Path = image.Path;
  1833. existingImage.DateModified = image.DateModified;
  1834. existingImage.Width = image.Width;
  1835. existingImage.Height = image.Height;
  1836. existingImage.Hash = image.Hash;
  1837. }
  1838. else
  1839. {
  1840. var current = ImageInfos;
  1841. var currentCount = current.Length;
  1842. var newArr = new ItemImageInfo[currentCount + 1];
  1843. current.CopyTo(newArr, 0);
  1844. newArr[currentCount] = image;
  1845. ImageInfos = newArr;
  1846. }
  1847. }
  1848. public void SetImagePath(ImageType type, int index, FileSystemMetadata file)
  1849. {
  1850. if (type == ImageType.Chapter)
  1851. {
  1852. throw new ArgumentException("Cannot set chapter images using SetImagePath");
  1853. }
  1854. var image = GetImageInfo(type, index);
  1855. if (image == null)
  1856. {
  1857. ImageInfos = ImageInfos.Concat(new[] { GetImageInfo(file, type) }).ToArray();
  1858. }
  1859. else
  1860. {
  1861. var imageInfo = GetImageInfo(file, type);
  1862. image.Path = file.FullName;
  1863. image.DateModified = imageInfo.DateModified;
  1864. // reset these values
  1865. image.Width = 0;
  1866. image.Height = 0;
  1867. }
  1868. }
  1869. /// <summary>
  1870. /// Deletes the image.
  1871. /// </summary>
  1872. /// <param name="type">The type.</param>
  1873. /// <param name="index">The index.</param>
  1874. public void DeleteImage(ImageType type, int index)
  1875. {
  1876. var info = GetImageInfo(type, index);
  1877. if (info == null)
  1878. {
  1879. // Nothing to do
  1880. return;
  1881. }
  1882. // Remove it from the item
  1883. RemoveImage(info);
  1884. if (info.IsLocalFile)
  1885. {
  1886. FileSystem.DeleteFile(info.Path);
  1887. }
  1888. UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None);
  1889. }
  1890. public void RemoveImage(ItemImageInfo image)
  1891. {
  1892. RemoveImages(new List<ItemImageInfo> { image });
  1893. }
  1894. public void RemoveImages(List<ItemImageInfo> deletedImages)
  1895. {
  1896. ImageInfos = ImageInfos.Except(deletedImages).ToArray();
  1897. }
  1898. public virtual void UpdateToRepository(ItemUpdateType updateReason, CancellationToken cancellationToken)
  1899. {
  1900. LibraryManager.UpdateItem(this, GetParent(), updateReason, cancellationToken);
  1901. }
  1902. /// <summary>
  1903. /// Validates that images within the item are still on the filesystem.
  1904. /// </summary>
  1905. public bool ValidateImages(IDirectoryService directoryService)
  1906. {
  1907. var allFiles = ImageInfos
  1908. .Where(i => i.IsLocalFile)
  1909. .Select(i => System.IO.Path.GetDirectoryName(i.Path))
  1910. .Distinct(StringComparer.OrdinalIgnoreCase)
  1911. .SelectMany(i => directoryService.GetFilePaths(i))
  1912. .ToList();
  1913. var deletedImages = ImageInfos
  1914. .Where(image => image.IsLocalFile && !allFiles.Contains(image.Path, StringComparer.OrdinalIgnoreCase))
  1915. .ToList();
  1916. if (deletedImages.Count > 0)
  1917. {
  1918. ImageInfos = ImageInfos.Except(deletedImages).ToArray();
  1919. }
  1920. return deletedImages.Count > 0;
  1921. }
  1922. /// <summary>
  1923. /// Gets the image path.
  1924. /// </summary>
  1925. /// <param name="imageType">Type of the image.</param>
  1926. /// <param name="imageIndex">Index of the image.</param>
  1927. /// <returns>System.String.</returns>
  1928. /// <exception cref="InvalidOperationException">
  1929. /// </exception>
  1930. /// <exception cref="ArgumentNullException">item</exception>
  1931. public string GetImagePath(ImageType imageType, int imageIndex)
  1932. => GetImageInfo(imageType, imageIndex)?.Path;
  1933. /// <summary>
  1934. /// Gets the image information.
  1935. /// </summary>
  1936. /// <param name="imageType">Type of the image.</param>
  1937. /// <param name="imageIndex">Index of the image.</param>
  1938. /// <returns>ItemImageInfo.</returns>
  1939. public ItemImageInfo GetImageInfo(ImageType imageType, int imageIndex)
  1940. {
  1941. if (imageType == ImageType.Chapter)
  1942. {
  1943. var chapter = ItemRepository.GetChapter(this, imageIndex);
  1944. if (chapter == null)
  1945. {
  1946. return null;
  1947. }
  1948. var path = chapter.ImagePath;
  1949. if (string.IsNullOrEmpty(path))
  1950. {
  1951. return null;
  1952. }
  1953. return new ItemImageInfo
  1954. {
  1955. Path = path,
  1956. DateModified = chapter.ImageDateModified,
  1957. Type = imageType
  1958. };
  1959. }
  1960. return GetImages(imageType)
  1961. .ElementAtOrDefault(imageIndex);
  1962. }
  1963. public IEnumerable<ItemImageInfo> GetImages(ImageType imageType)
  1964. {
  1965. if (imageType == ImageType.Chapter)
  1966. {
  1967. throw new ArgumentException("No image info for chapter images");
  1968. }
  1969. return ImageInfos.Where(i => i.Type == imageType);
  1970. }
  1971. /// <summary>
  1972. /// Adds the images.
  1973. /// </summary>
  1974. /// <param name="imageType">Type of the image.</param>
  1975. /// <param name="images">The images.</param>
  1976. /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
  1977. /// <exception cref="ArgumentException">Cannot call AddImages with chapter images</exception>
  1978. public bool AddImages(ImageType imageType, List<FileSystemMetadata> images)
  1979. {
  1980. if (imageType == ImageType.Chapter)
  1981. {
  1982. throw new ArgumentException("Cannot call AddImages with chapter images");
  1983. }
  1984. var existingImages = GetImages(imageType)
  1985. .ToList();
  1986. var newImageList = new List<FileSystemMetadata>();
  1987. var imageAdded = false;
  1988. var imageUpdated = false;
  1989. foreach (var newImage in images)
  1990. {
  1991. if (newImage == null)
  1992. {
  1993. throw new ArgumentException("null image found in list");
  1994. }
  1995. var existing = existingImages
  1996. .FirstOrDefault(i => string.Equals(i.Path, newImage.FullName, StringComparison.OrdinalIgnoreCase));
  1997. if (existing == null)
  1998. {
  1999. newImageList.Add(newImage);
  2000. imageAdded = true;
  2001. }
  2002. else
  2003. {
  2004. if (existing.IsLocalFile)
  2005. {
  2006. var newDateModified = FileSystem.GetLastWriteTimeUtc(newImage);
  2007. // If date changed then we need to reset saved image dimensions
  2008. if (existing.DateModified != newDateModified && (existing.Width > 0 || existing.Height > 0))
  2009. {
  2010. existing.Width = 0;
  2011. existing.Height = 0;
  2012. imageUpdated = true;
  2013. }
  2014. existing.DateModified = newDateModified;
  2015. }
  2016. }
  2017. }
  2018. if (imageAdded || images.Count != existingImages.Count)
  2019. {
  2020. var newImagePaths = images.Select(i => i.FullName).ToList();
  2021. var deleted = existingImages
  2022. .Where(i => i.IsLocalFile && !newImagePaths.Contains(i.Path, StringComparer.OrdinalIgnoreCase) && !File.Exists(i.Path))
  2023. .ToList();
  2024. if (deleted.Count > 0)
  2025. {
  2026. ImageInfos = ImageInfos.Except(deleted).ToArray();
  2027. }
  2028. }
  2029. if (newImageList.Count > 0)
  2030. {
  2031. ImageInfos = ImageInfos.Concat(newImageList.Select(i => GetImageInfo(i, imageType))).ToArray();
  2032. }
  2033. return imageUpdated || newImageList.Count > 0;
  2034. }
  2035. private ItemImageInfo GetImageInfo(FileSystemMetadata file, ImageType type)
  2036. {
  2037. return new ItemImageInfo
  2038. {
  2039. Path = file.FullName,
  2040. Type = type,
  2041. DateModified = FileSystem.GetLastWriteTimeUtc(file)
  2042. };
  2043. }
  2044. /// <summary>
  2045. /// Gets the file system path to delete when the item is to be deleted
  2046. /// </summary>
  2047. /// <returns></returns>
  2048. public virtual IEnumerable<FileSystemMetadata> GetDeletePaths()
  2049. {
  2050. return new[] {
  2051. new FileSystemMetadata
  2052. {
  2053. FullName = Path,
  2054. IsDirectory = IsFolder
  2055. }
  2056. }.Concat(GetLocalMetadataFilesToDelete());
  2057. }
  2058. protected List<FileSystemMetadata> GetLocalMetadataFilesToDelete()
  2059. {
  2060. if (IsFolder || !IsInMixedFolder)
  2061. {
  2062. return new List<FileSystemMetadata>();
  2063. }
  2064. var filename = System.IO.Path.GetFileNameWithoutExtension(Path);
  2065. return FileSystem.GetFiles(System.IO.Path.GetDirectoryName(Path), _supportedExtensions, false, false)
  2066. .Where(i => System.IO.Path.GetFileNameWithoutExtension(i.FullName).StartsWith(filename, StringComparison.OrdinalIgnoreCase))
  2067. .ToList();
  2068. }
  2069. public bool AllowsMultipleImages(ImageType type)
  2070. {
  2071. return type == ImageType.Backdrop || type == ImageType.Screenshot || type == ImageType.Chapter;
  2072. }
  2073. public void SwapImages(ImageType type, int index1, int index2)
  2074. {
  2075. if (!AllowsMultipleImages(type))
  2076. {
  2077. throw new ArgumentException("The change index operation is only applicable to backdrops and screenshots");
  2078. }
  2079. var info1 = GetImageInfo(type, index1);
  2080. var info2 = GetImageInfo(type, index2);
  2081. if (info1 == null || info2 == null)
  2082. {
  2083. // Nothing to do
  2084. return;
  2085. }
  2086. if (!info1.IsLocalFile || !info2.IsLocalFile)
  2087. {
  2088. // TODO: Not supported yet
  2089. return;
  2090. }
  2091. var path1 = info1.Path;
  2092. var path2 = info2.Path;
  2093. FileSystem.SwapFiles(path1, path2);
  2094. // Refresh these values
  2095. info1.DateModified = FileSystem.GetLastWriteTimeUtc(info1.Path);
  2096. info2.DateModified = FileSystem.GetLastWriteTimeUtc(info2.Path);
  2097. info1.Width = 0;
  2098. info1.Height = 0;
  2099. info2.Width = 0;
  2100. info2.Height = 0;
  2101. UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None);
  2102. }
  2103. public virtual bool IsPlayed(User user)
  2104. {
  2105. var userdata = UserDataManager.GetUserData(user, this);
  2106. return userdata != null && userdata.Played;
  2107. }
  2108. public bool IsFavoriteOrLiked(User user)
  2109. {
  2110. var userdata = UserDataManager.GetUserData(user, this);
  2111. return userdata != null && (userdata.IsFavorite || (userdata.Likes ?? false));
  2112. }
  2113. public virtual bool IsUnplayed(User user)
  2114. {
  2115. if (user == null)
  2116. {
  2117. throw new ArgumentNullException(nameof(user));
  2118. }
  2119. var userdata = UserDataManager.GetUserData(user, this);
  2120. return userdata == null || !userdata.Played;
  2121. }
  2122. ItemLookupInfo IHasLookupInfo<ItemLookupInfo>.GetLookupInfo()
  2123. {
  2124. return GetItemLookupInfo<ItemLookupInfo>();
  2125. }
  2126. protected T GetItemLookupInfo<T>()
  2127. where T : ItemLookupInfo, new()
  2128. {
  2129. return new T
  2130. {
  2131. MetadataCountryCode = GetPreferredMetadataCountryCode(),
  2132. MetadataLanguage = GetPreferredMetadataLanguage(),
  2133. Name = GetNameForMetadataLookup(),
  2134. ProviderIds = ProviderIds,
  2135. IndexNumber = IndexNumber,
  2136. ParentIndexNumber = ParentIndexNumber,
  2137. Year = ProductionYear,
  2138. PremiereDate = PremiereDate
  2139. };
  2140. }
  2141. protected virtual string GetNameForMetadataLookup()
  2142. {
  2143. return Name;
  2144. }
  2145. /// <summary>
  2146. /// This is called before any metadata refresh and returns true if changes were made.
  2147. /// </summary>
  2148. public virtual bool BeforeMetadataRefresh(bool replaceAllMetdata)
  2149. {
  2150. _sortName = null;
  2151. var hasChanges = false;
  2152. if (string.IsNullOrEmpty(Name) && !string.IsNullOrEmpty(Path))
  2153. {
  2154. Name = System.IO.Path.GetFileNameWithoutExtension(Path);
  2155. hasChanges = true;
  2156. }
  2157. return hasChanges;
  2158. }
  2159. protected static string GetMappedPath(BaseItem item, string path, MediaProtocol? protocol)
  2160. {
  2161. if (protocol.HasValue && protocol.Value == MediaProtocol.File)
  2162. {
  2163. return LibraryManager.GetPathAfterNetworkSubstitution(path, item);
  2164. }
  2165. return path;
  2166. }
  2167. public virtual void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields)
  2168. {
  2169. if (RunTimeTicks.HasValue)
  2170. {
  2171. double pct = RunTimeTicks.Value;
  2172. if (pct > 0)
  2173. {
  2174. pct = userData.PlaybackPositionTicks / pct;
  2175. if (pct > 0)
  2176. {
  2177. dto.PlayedPercentage = 100 * pct;
  2178. }
  2179. }
  2180. }
  2181. }
  2182. protected Task RefreshMetadataForOwnedItem(BaseItem ownedItem, bool copyTitleMetadata, MetadataRefreshOptions options, CancellationToken cancellationToken)
  2183. {
  2184. var newOptions = new MetadataRefreshOptions(options);
  2185. newOptions.SearchResult = null;
  2186. var item = this;
  2187. if (copyTitleMetadata)
  2188. {
  2189. // Take some data from the main item, for querying purposes
  2190. if (!item.Genres.SequenceEqual(ownedItem.Genres, StringComparer.Ordinal))
  2191. {
  2192. newOptions.ForceSave = true;
  2193. ownedItem.Genres = item.Genres;
  2194. }
  2195. if (!item.Studios.SequenceEqual(ownedItem.Studios, StringComparer.Ordinal))
  2196. {
  2197. newOptions.ForceSave = true;
  2198. ownedItem.Studios = item.Studios;
  2199. }
  2200. if (!item.ProductionLocations.SequenceEqual(ownedItem.ProductionLocations, StringComparer.Ordinal))
  2201. {
  2202. newOptions.ForceSave = true;
  2203. ownedItem.ProductionLocations = item.ProductionLocations;
  2204. }
  2205. if (item.CommunityRating != ownedItem.CommunityRating)
  2206. {
  2207. ownedItem.CommunityRating = item.CommunityRating;
  2208. newOptions.ForceSave = true;
  2209. }
  2210. if (item.CriticRating != ownedItem.CriticRating)
  2211. {
  2212. ownedItem.CriticRating = item.CriticRating;
  2213. newOptions.ForceSave = true;
  2214. }
  2215. if (!string.Equals(item.Overview, ownedItem.Overview, StringComparison.Ordinal))
  2216. {
  2217. ownedItem.Overview = item.Overview;
  2218. newOptions.ForceSave = true;
  2219. }
  2220. if (!string.Equals(item.OfficialRating, ownedItem.OfficialRating, StringComparison.Ordinal))
  2221. {
  2222. ownedItem.OfficialRating = item.OfficialRating;
  2223. newOptions.ForceSave = true;
  2224. }
  2225. if (!string.Equals(item.CustomRating, ownedItem.CustomRating, StringComparison.Ordinal))
  2226. {
  2227. ownedItem.CustomRating = item.CustomRating;
  2228. newOptions.ForceSave = true;
  2229. }
  2230. }
  2231. return ownedItem.RefreshMetadata(newOptions, cancellationToken);
  2232. }
  2233. protected Task RefreshMetadataForOwnedVideo(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
  2234. {
  2235. var newOptions = new MetadataRefreshOptions(options);
  2236. newOptions.SearchResult = null;
  2237. var id = LibraryManager.GetNewItemId(path, typeof(Video));
  2238. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2239. var video = LibraryManager.GetItemById(id) as Video;
  2240. if (video == null)
  2241. {
  2242. video = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Video;
  2243. newOptions.ForceSave = true;
  2244. }
  2245. //var parentId = Id;
  2246. //if (!video.IsOwnedItem || video.ParentId != parentId)
  2247. //{
  2248. // video.IsOwnedItem = true;
  2249. // video.ParentId = parentId;
  2250. // newOptions.ForceSave = true;
  2251. //}
  2252. if (video == null)
  2253. {
  2254. return Task.FromResult(true);
  2255. }
  2256. return RefreshMetadataForOwnedItem(video, copyTitleMetadata, newOptions, cancellationToken);
  2257. }
  2258. public string GetEtag(User user)
  2259. {
  2260. var list = GetEtagValues(user);
  2261. return string.Join("|", list).GetMD5().ToString("N", CultureInfo.InvariantCulture);
  2262. }
  2263. protected virtual List<string> GetEtagValues(User user)
  2264. {
  2265. return new List<string>
  2266. {
  2267. DateLastSaved.Ticks.ToString(CultureInfo.InvariantCulture)
  2268. };
  2269. }
  2270. public virtual IEnumerable<Guid> GetAncestorIds()
  2271. {
  2272. return GetParents().Select(i => i.Id).Concat(LibraryManager.GetCollectionFolders(this).Select(i => i.Id));
  2273. }
  2274. public BaseItem GetTopParent()
  2275. {
  2276. if (IsTopParent)
  2277. {
  2278. return this;
  2279. }
  2280. foreach (var parent in GetParents())
  2281. {
  2282. if (parent.IsTopParent)
  2283. {
  2284. return parent;
  2285. }
  2286. }
  2287. return null;
  2288. }
  2289. [JsonIgnore]
  2290. public virtual bool IsTopParent
  2291. {
  2292. get
  2293. {
  2294. if (this is BasePluginFolder || this is Channel)
  2295. {
  2296. return true;
  2297. }
  2298. if (this is IHasCollectionType view)
  2299. {
  2300. if (string.Equals(view.CollectionType, CollectionType.LiveTv, StringComparison.OrdinalIgnoreCase))
  2301. {
  2302. return true;
  2303. }
  2304. }
  2305. if (GetParent() is AggregateFolder)
  2306. {
  2307. return true;
  2308. }
  2309. return false;
  2310. }
  2311. }
  2312. [JsonIgnore]
  2313. public virtual bool SupportsAncestors => true;
  2314. [JsonIgnore]
  2315. public virtual bool StopRefreshIfLocalMetadataFound => true;
  2316. public virtual IEnumerable<Guid> GetIdsForAncestorQuery()
  2317. {
  2318. return new[] { Id };
  2319. }
  2320. public virtual List<ExternalUrl> GetRelatedUrls()
  2321. {
  2322. return new List<ExternalUrl>();
  2323. }
  2324. public virtual double? GetRefreshProgress()
  2325. {
  2326. return null;
  2327. }
  2328. public virtual ItemUpdateType OnMetadataChanged()
  2329. {
  2330. var updateType = ItemUpdateType.None;
  2331. var item = this;
  2332. var inheritedParentalRatingValue = item.GetInheritedParentalRatingValue() ?? 0;
  2333. if (inheritedParentalRatingValue != item.InheritedParentalRatingValue)
  2334. {
  2335. item.InheritedParentalRatingValue = inheritedParentalRatingValue;
  2336. updateType |= ItemUpdateType.MetadataImport;
  2337. }
  2338. return updateType;
  2339. }
  2340. /// <summary>
  2341. /// Updates the official rating based on content and returns true or false indicating if it changed.
  2342. /// </summary>
  2343. /// <returns></returns>
  2344. public bool UpdateRatingToItems(IList<BaseItem> children)
  2345. {
  2346. var currentOfficialRating = OfficialRating;
  2347. // Gather all possible ratings
  2348. var ratings = children
  2349. .Select(i => i.OfficialRating)
  2350. .Where(i => !string.IsNullOrEmpty(i))
  2351. .Distinct(StringComparer.OrdinalIgnoreCase)
  2352. .Select(i => new Tuple<string, int?>(i, LocalizationManager.GetRatingLevel(i)))
  2353. .OrderBy(i => i.Item2 ?? 1000)
  2354. .Select(i => i.Item1);
  2355. OfficialRating = ratings.FirstOrDefault() ?? currentOfficialRating;
  2356. return !string.Equals(currentOfficialRating ?? string.Empty, OfficialRating ?? string.Empty,
  2357. StringComparison.OrdinalIgnoreCase);
  2358. }
  2359. public IEnumerable<BaseItem> GetThemeSongs()
  2360. {
  2361. return ThemeVideoIds.Select(LibraryManager.GetItemById).Where(i => i.ExtraType.Equals(Model.Entities.ExtraType.ThemeSong)).OrderBy(i => i.SortName);
  2362. }
  2363. public IEnumerable<BaseItem> GetThemeVideos()
  2364. {
  2365. return ThemeVideoIds.Select(LibraryManager.GetItemById).Where(i => i.ExtraType.Equals(Model.Entities.ExtraType.ThemeVideo)).OrderBy(i => i.SortName);
  2366. }
  2367. /// <summary>
  2368. /// Gets or sets the remote trailers.
  2369. /// </summary>
  2370. /// <value>The remote trailers.</value>
  2371. public IReadOnlyList<MediaUrl> RemoteTrailers { get; set; }
  2372. /// <summary>
  2373. /// Get all extras associated with this item, sorted by <see cref="SortName"/>.
  2374. /// </summary>
  2375. /// <returns>An enumerable containing the items.</returns>
  2376. public IEnumerable<BaseItem> GetExtras()
  2377. {
  2378. return ExtraIds
  2379. .Select(LibraryManager.GetItemById)
  2380. .Where(i => i != null)
  2381. .OrderBy(i => i.SortName);
  2382. }
  2383. /// <summary>
  2384. /// Get all extras with specific types that are associated with this item.
  2385. /// </summary>
  2386. /// <param name="extraTypes">The types of extras to retrieve.</param>
  2387. /// <returns>An enumerable containing the extras.</returns>
  2388. public IEnumerable<BaseItem> GetExtras(IReadOnlyCollection<ExtraType> extraTypes)
  2389. {
  2390. return ExtraIds
  2391. .Select(LibraryManager.GetItemById)
  2392. .Where(i => i != null)
  2393. .Where(i => i.ExtraType.HasValue && extraTypes.Contains(i.ExtraType.Value));
  2394. }
  2395. public IEnumerable<BaseItem> GetTrailers()
  2396. {
  2397. if (this is IHasTrailers)
  2398. return ((IHasTrailers)this).LocalTrailerIds.Select(LibraryManager.GetItemById).Where(i => i != null).OrderBy(i => i.SortName);
  2399. else
  2400. return Array.Empty<BaseItem>();
  2401. }
  2402. public virtual bool IsHD => Height >= 720;
  2403. public bool IsShortcut { get; set; }
  2404. public string ShortcutPath { get; set; }
  2405. public int Width { get; set; }
  2406. public int Height { get; set; }
  2407. public Guid[] ExtraIds { get; set; }
  2408. public virtual long GetRunTimeTicksForPlayState()
  2409. {
  2410. return RunTimeTicks ?? 0;
  2411. }
  2412. /// <summary>
  2413. /// Extra types that should be counted and displayed as "Special Features" in the UI.
  2414. /// </summary>
  2415. public static readonly IReadOnlyCollection<ExtraType> DisplayExtraTypes = new HashSet<ExtraType>
  2416. {
  2417. Model.Entities.ExtraType.Unknown,
  2418. Model.Entities.ExtraType.BehindTheScenes,
  2419. Model.Entities.ExtraType.Clip,
  2420. Model.Entities.ExtraType.DeletedScene,
  2421. Model.Entities.ExtraType.Interview,
  2422. Model.Entities.ExtraType.Sample,
  2423. Model.Entities.ExtraType.Scene
  2424. };
  2425. public virtual bool SupportsExternalTransfer => false;
  2426. /// <inheritdoc />
  2427. public override bool Equals(object obj)
  2428. {
  2429. return obj is BaseItem baseItem && this.Equals(baseItem);
  2430. }
  2431. /// <inheritdoc />
  2432. public bool Equals(BaseItem item) => Object.Equals(Id, item?.Id);
  2433. /// <inheritdoc />
  2434. public override int GetHashCode() => HashCode.Combine(Id);
  2435. }
  2436. }