LibraryManager.cs 114 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288
  1. #nullable disable
  2. #pragma warning disable CS1591
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Globalization;
  6. using System.IO;
  7. using System.Linq;
  8. using System.Net;
  9. using System.Net.Http;
  10. using System.Threading;
  11. using System.Threading.Tasks;
  12. using Emby.Naming.Audio;
  13. using Emby.Naming.Common;
  14. using Emby.Naming.TV;
  15. using Emby.Naming.Video;
  16. using Emby.Server.Implementations.Library.Resolvers;
  17. using Emby.Server.Implementations.Library.Validators;
  18. using Emby.Server.Implementations.Playlists;
  19. using Emby.Server.Implementations.ScheduledTasks;
  20. using Jellyfin.Data.Entities;
  21. using Jellyfin.Data.Enums;
  22. using Jellyfin.Extensions;
  23. using MediaBrowser.Common.Extensions;
  24. using MediaBrowser.Common.Progress;
  25. using MediaBrowser.Controller;
  26. using MediaBrowser.Controller.Configuration;
  27. using MediaBrowser.Controller.Drawing;
  28. using MediaBrowser.Controller.Dto;
  29. using MediaBrowser.Controller.Entities;
  30. using MediaBrowser.Controller.Entities.Audio;
  31. using MediaBrowser.Controller.IO;
  32. using MediaBrowser.Controller.Library;
  33. using MediaBrowser.Controller.LiveTv;
  34. using MediaBrowser.Controller.MediaEncoding;
  35. using MediaBrowser.Controller.Persistence;
  36. using MediaBrowser.Controller.Providers;
  37. using MediaBrowser.Controller.Resolvers;
  38. using MediaBrowser.Controller.Sorting;
  39. using MediaBrowser.Model.Configuration;
  40. using MediaBrowser.Model.Dlna;
  41. using MediaBrowser.Model.Drawing;
  42. using MediaBrowser.Model.Dto;
  43. using MediaBrowser.Model.Entities;
  44. using MediaBrowser.Model.IO;
  45. using MediaBrowser.Model.Library;
  46. using MediaBrowser.Model.Querying;
  47. using MediaBrowser.Model.Tasks;
  48. using MediaBrowser.Providers.MediaInfo;
  49. using Microsoft.Extensions.Caching.Memory;
  50. using Microsoft.Extensions.Logging;
  51. using Episode = MediaBrowser.Controller.Entities.TV.Episode;
  52. using EpisodeInfo = Emby.Naming.TV.EpisodeInfo;
  53. using Genre = MediaBrowser.Controller.Entities.Genre;
  54. using Person = MediaBrowser.Controller.Entities.Person;
  55. using VideoResolver = Emby.Naming.Video.VideoResolver;
  56. namespace Emby.Server.Implementations.Library
  57. {
  58. /// <summary>
  59. /// Class LibraryManager.
  60. /// </summary>
  61. public class LibraryManager : ILibraryManager
  62. {
  63. private const string ShortcutFileExtension = ".mblink";
  64. private readonly ILogger<LibraryManager> _logger;
  65. private readonly IMemoryCache _memoryCache;
  66. private readonly ITaskManager _taskManager;
  67. private readonly IUserManager _userManager;
  68. private readonly IUserDataManager _userDataRepository;
  69. private readonly IServerConfigurationManager _configurationManager;
  70. private readonly Lazy<ILibraryMonitor> _libraryMonitorFactory;
  71. private readonly Lazy<IProviderManager> _providerManagerFactory;
  72. private readonly Lazy<IUserViewManager> _userviewManagerFactory;
  73. private readonly IServerApplicationHost _appHost;
  74. private readonly IMediaEncoder _mediaEncoder;
  75. private readonly IFileSystem _fileSystem;
  76. private readonly IItemRepository _itemRepository;
  77. private readonly IImageProcessor _imageProcessor;
  78. /// <summary>
  79. /// The _root folder sync lock.
  80. /// </summary>
  81. private readonly object _rootFolderSyncLock = new object();
  82. private readonly object _userRootFolderSyncLock = new object();
  83. private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
  84. private NamingOptions _namingOptions;
  85. private string[] _videoFileExtensions;
  86. /// <summary>
  87. /// The _root folder.
  88. /// </summary>
  89. private volatile AggregateFolder _rootFolder;
  90. private volatile UserRootFolder _userRootFolder;
  91. private bool _wizardCompleted;
  92. /// <summary>
  93. /// Initializes a new instance of the <see cref="LibraryManager" /> class.
  94. /// </summary>
  95. /// <param name="appHost">The application host.</param>
  96. /// <param name="logger">The logger.</param>
  97. /// <param name="taskManager">The task manager.</param>
  98. /// <param name="userManager">The user manager.</param>
  99. /// <param name="configurationManager">The configuration manager.</param>
  100. /// <param name="userDataRepository">The user data repository.</param>
  101. /// <param name="libraryMonitorFactory">The library monitor.</param>
  102. /// <param name="fileSystem">The file system.</param>
  103. /// <param name="providerManagerFactory">The provider manager.</param>
  104. /// <param name="userviewManagerFactory">The userview manager.</param>
  105. /// <param name="mediaEncoder">The media encoder.</param>
  106. /// <param name="itemRepository">The item repository.</param>
  107. /// <param name="imageProcessor">The image processor.</param>
  108. /// <param name="memoryCache">The memory cache.</param>
  109. public LibraryManager(
  110. IServerApplicationHost appHost,
  111. ILogger<LibraryManager> logger,
  112. ITaskManager taskManager,
  113. IUserManager userManager,
  114. IServerConfigurationManager configurationManager,
  115. IUserDataManager userDataRepository,
  116. Lazy<ILibraryMonitor> libraryMonitorFactory,
  117. IFileSystem fileSystem,
  118. Lazy<IProviderManager> providerManagerFactory,
  119. Lazy<IUserViewManager> userviewManagerFactory,
  120. IMediaEncoder mediaEncoder,
  121. IItemRepository itemRepository,
  122. IImageProcessor imageProcessor,
  123. IMemoryCache memoryCache)
  124. {
  125. _appHost = appHost;
  126. _logger = logger;
  127. _taskManager = taskManager;
  128. _userManager = userManager;
  129. _configurationManager = configurationManager;
  130. _userDataRepository = userDataRepository;
  131. _libraryMonitorFactory = libraryMonitorFactory;
  132. _fileSystem = fileSystem;
  133. _providerManagerFactory = providerManagerFactory;
  134. _userviewManagerFactory = userviewManagerFactory;
  135. _mediaEncoder = mediaEncoder;
  136. _itemRepository = itemRepository;
  137. _imageProcessor = imageProcessor;
  138. _memoryCache = memoryCache;
  139. _configurationManager.ConfigurationUpdated += ConfigurationUpdated;
  140. RecordConfigurationValues(configurationManager.Configuration);
  141. }
  142. /// <summary>
  143. /// Occurs when [item added].
  144. /// </summary>
  145. public event EventHandler<ItemChangeEventArgs> ItemAdded;
  146. /// <summary>
  147. /// Occurs when [item updated].
  148. /// </summary>
  149. public event EventHandler<ItemChangeEventArgs> ItemUpdated;
  150. /// <summary>
  151. /// Occurs when [item removed].
  152. /// </summary>
  153. public event EventHandler<ItemChangeEventArgs> ItemRemoved;
  154. /// <summary>
  155. /// Gets the root folder.
  156. /// </summary>
  157. /// <value>The root folder.</value>
  158. public AggregateFolder RootFolder
  159. {
  160. get
  161. {
  162. if (_rootFolder == null)
  163. {
  164. lock (_rootFolderSyncLock)
  165. {
  166. _rootFolder ??= CreateRootFolder();
  167. }
  168. }
  169. return _rootFolder;
  170. }
  171. }
  172. private ILibraryMonitor LibraryMonitor => _libraryMonitorFactory.Value;
  173. private IProviderManager ProviderManager => _providerManagerFactory.Value;
  174. private IUserViewManager UserViewManager => _userviewManagerFactory.Value;
  175. /// <summary>
  176. /// Gets or sets the postscan tasks.
  177. /// </summary>
  178. /// <value>The postscan tasks.</value>
  179. private ILibraryPostScanTask[] PostscanTasks { get; set; } = Array.Empty<ILibraryPostScanTask>();
  180. /// <summary>
  181. /// Gets or sets the intro providers.
  182. /// </summary>
  183. /// <value>The intro providers.</value>
  184. private IIntroProvider[] IntroProviders { get; set; } = Array.Empty<IIntroProvider>();
  185. /// <summary>
  186. /// Gets or sets the list of entity resolution ignore rules.
  187. /// </summary>
  188. /// <value>The entity resolution ignore rules.</value>
  189. private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; } = Array.Empty<IResolverIgnoreRule>();
  190. /// <summary>
  191. /// Gets or sets the list of currently registered entity resolvers.
  192. /// </summary>
  193. /// <value>The entity resolvers enumerable.</value>
  194. private IItemResolver[] EntityResolvers { get; set; } = Array.Empty<IItemResolver>();
  195. private IMultiItemResolver[] MultiItemResolvers { get; set; } = Array.Empty<IMultiItemResolver>();
  196. /// <summary>
  197. /// Gets or sets the comparers.
  198. /// </summary>
  199. /// <value>The comparers.</value>
  200. private IBaseItemComparer[] Comparers { get; set; } = Array.Empty<IBaseItemComparer>();
  201. public bool IsScanRunning { get; private set; }
  202. /// <summary>
  203. /// Adds the parts.
  204. /// </summary>
  205. /// <param name="rules">The rules.</param>
  206. /// <param name="resolvers">The resolvers.</param>
  207. /// <param name="introProviders">The intro providers.</param>
  208. /// <param name="itemComparers">The item comparers.</param>
  209. /// <param name="postscanTasks">The post scan tasks.</param>
  210. public void AddParts(
  211. IEnumerable<IResolverIgnoreRule> rules,
  212. IEnumerable<IItemResolver> resolvers,
  213. IEnumerable<IIntroProvider> introProviders,
  214. IEnumerable<IBaseItemComparer> itemComparers,
  215. IEnumerable<ILibraryPostScanTask> postscanTasks)
  216. {
  217. EntityResolutionIgnoreRules = rules.ToArray();
  218. EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
  219. MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
  220. IntroProviders = introProviders.ToArray();
  221. Comparers = itemComparers.ToArray();
  222. PostscanTasks = postscanTasks.ToArray();
  223. }
  224. /// <summary>
  225. /// Records the configuration values.
  226. /// </summary>
  227. /// <param name="configuration">The configuration.</param>
  228. private void RecordConfigurationValues(ServerConfiguration configuration)
  229. {
  230. _wizardCompleted = configuration.IsStartupWizardCompleted;
  231. }
  232. /// <summary>
  233. /// Configurations the updated.
  234. /// </summary>
  235. /// <param name="sender">The sender.</param>
  236. /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
  237. private void ConfigurationUpdated(object sender, EventArgs e)
  238. {
  239. var config = _configurationManager.Configuration;
  240. var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
  241. RecordConfigurationValues(config);
  242. if (wizardChanged)
  243. {
  244. _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
  245. }
  246. }
  247. public void RegisterItem(BaseItem item)
  248. {
  249. if (item == null)
  250. {
  251. throw new ArgumentNullException(nameof(item));
  252. }
  253. if (item is IItemByName)
  254. {
  255. if (item is not MusicArtist)
  256. {
  257. return;
  258. }
  259. }
  260. else if (!item.IsFolder)
  261. {
  262. if (item is not Video && item is not LiveTvChannel)
  263. {
  264. return;
  265. }
  266. }
  267. _memoryCache.Set(item.Id, item);
  268. }
  269. public void DeleteItem(BaseItem item, DeleteOptions options)
  270. {
  271. DeleteItem(item, options, false);
  272. }
  273. public void DeleteItem(BaseItem item, DeleteOptions options, bool notifyParentItem)
  274. {
  275. if (item == null)
  276. {
  277. throw new ArgumentNullException(nameof(item));
  278. }
  279. var parent = item.GetOwner() ?? item.GetParent();
  280. DeleteItem(item, options, parent, notifyParentItem);
  281. }
  282. public void DeleteItem(BaseItem item, DeleteOptions options, BaseItem parent, bool notifyParentItem)
  283. {
  284. if (item == null)
  285. {
  286. throw new ArgumentNullException(nameof(item));
  287. }
  288. if (item.SourceType == SourceType.Channel)
  289. {
  290. if (options.DeleteFromExternalProvider)
  291. {
  292. try
  293. {
  294. var task = BaseItem.ChannelManager.DeleteItem(item);
  295. Task.WaitAll(task);
  296. }
  297. catch (ArgumentException)
  298. {
  299. // channel no longer installed
  300. }
  301. }
  302. options.DeleteFileLocation = false;
  303. }
  304. if (item is LiveTvProgram)
  305. {
  306. _logger.LogDebug(
  307. "Removing item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
  308. item.GetType().Name,
  309. item.Name ?? "Unknown name",
  310. item.Path ?? string.Empty,
  311. item.Id);
  312. }
  313. else
  314. {
  315. _logger.LogInformation(
  316. "Removing item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
  317. item.GetType().Name,
  318. item.Name ?? "Unknown name",
  319. item.Path ?? string.Empty,
  320. item.Id);
  321. }
  322. var children = item.IsFolder
  323. ? ((Folder)item).GetRecursiveChildren(false).ToList()
  324. : new List<BaseItem>();
  325. foreach (var metadataPath in GetMetadataPaths(item, children))
  326. {
  327. if (!Directory.Exists(metadataPath))
  328. {
  329. continue;
  330. }
  331. _logger.LogDebug(
  332. "Deleting metadata path, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
  333. item.GetType().Name,
  334. item.Name ?? "Unknown name",
  335. metadataPath,
  336. item.Id);
  337. try
  338. {
  339. Directory.Delete(metadataPath, true);
  340. }
  341. catch (Exception ex)
  342. {
  343. _logger.LogError(ex, "Error deleting {MetadataPath}", metadataPath);
  344. }
  345. }
  346. if (options.DeleteFileLocation && item.IsFileProtocol)
  347. {
  348. // Assume only the first is required
  349. // Add this flag to GetDeletePaths if required in the future
  350. var isRequiredForDelete = true;
  351. foreach (var fileSystemInfo in item.GetDeletePaths())
  352. {
  353. if (Directory.Exists(fileSystemInfo.FullName) || File.Exists(fileSystemInfo.FullName))
  354. {
  355. try
  356. {
  357. _logger.LogInformation(
  358. "Deleting item path, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
  359. item.GetType().Name,
  360. item.Name ?? "Unknown name",
  361. fileSystemInfo.FullName,
  362. item.Id);
  363. if (fileSystemInfo.IsDirectory)
  364. {
  365. Directory.Delete(fileSystemInfo.FullName, true);
  366. }
  367. else
  368. {
  369. File.Delete(fileSystemInfo.FullName);
  370. }
  371. }
  372. catch (IOException)
  373. {
  374. if (isRequiredForDelete)
  375. {
  376. throw;
  377. }
  378. }
  379. catch (UnauthorizedAccessException)
  380. {
  381. if (isRequiredForDelete)
  382. {
  383. throw;
  384. }
  385. }
  386. }
  387. isRequiredForDelete = false;
  388. }
  389. }
  390. item.SetParent(null);
  391. _itemRepository.DeleteItem(item.Id);
  392. foreach (var child in children)
  393. {
  394. _itemRepository.DeleteItem(child.Id);
  395. }
  396. _memoryCache.Remove(item.Id);
  397. ReportItemRemoved(item, parent);
  398. }
  399. private static IEnumerable<string> GetMetadataPaths(BaseItem item, IEnumerable<BaseItem> children)
  400. {
  401. var list = new List<string>
  402. {
  403. item.GetInternalMetadataPath()
  404. };
  405. list.AddRange(children.Select(i => i.GetInternalMetadataPath()));
  406. return list;
  407. }
  408. /// <summary>
  409. /// Resolves the item.
  410. /// </summary>
  411. /// <param name="args">The args.</param>
  412. /// <param name="resolvers">The resolvers.</param>
  413. /// <returns>BaseItem.</returns>
  414. private BaseItem ResolveItem(ItemResolveArgs args, IItemResolver[] resolvers)
  415. {
  416. var item = (resolvers ?? EntityResolvers).Select(r => Resolve(args, r))
  417. .FirstOrDefault(i => i != null);
  418. if (item != null)
  419. {
  420. ResolverHelper.SetInitialItemValues(item, args, _fileSystem, this);
  421. }
  422. return item;
  423. }
  424. private BaseItem Resolve(ItemResolveArgs args, IItemResolver resolver)
  425. {
  426. try
  427. {
  428. return resolver.ResolvePath(args);
  429. }
  430. catch (Exception ex)
  431. {
  432. _logger.LogError(ex, "Error in {resolver} resolving {path}", resolver.GetType().Name, args.Path);
  433. return null;
  434. }
  435. }
  436. public Guid GetNewItemId(string key, Type type)
  437. {
  438. return GetNewItemIdInternal(key, type, false);
  439. }
  440. private Guid GetNewItemIdInternal(string key, Type type, bool forceCaseInsensitive)
  441. {
  442. if (string.IsNullOrEmpty(key))
  443. {
  444. throw new ArgumentNullException(nameof(key));
  445. }
  446. if (type == null)
  447. {
  448. throw new ArgumentNullException(nameof(type));
  449. }
  450. string programDataPath = _configurationManager.ApplicationPaths.ProgramDataPath;
  451. if (key.StartsWith(programDataPath, StringComparison.Ordinal))
  452. {
  453. // Try to normalize paths located underneath program-data in an attempt to make them more portable
  454. key = key.Substring(programDataPath.Length)
  455. .TrimStart('/', '\\')
  456. .Replace('/', '\\');
  457. }
  458. if (forceCaseInsensitive || !_configurationManager.Configuration.EnableCaseSensitiveItemIds)
  459. {
  460. key = key.ToLowerInvariant();
  461. }
  462. key = type.FullName + key;
  463. return key.GetMD5();
  464. }
  465. public BaseItem ResolvePath(FileSystemMetadata fileInfo, Folder parent = null)
  466. => ResolvePath(fileInfo, new DirectoryService(_fileSystem), null, parent);
  467. private BaseItem ResolvePath(
  468. FileSystemMetadata fileInfo,
  469. IDirectoryService directoryService,
  470. IItemResolver[] resolvers,
  471. Folder parent = null,
  472. string collectionType = null,
  473. LibraryOptions libraryOptions = null)
  474. {
  475. if (fileInfo == null)
  476. {
  477. throw new ArgumentNullException(nameof(fileInfo));
  478. }
  479. var fullPath = fileInfo.FullName;
  480. if (string.IsNullOrEmpty(collectionType) && parent != null)
  481. {
  482. collectionType = GetContentTypeOverride(fullPath, true);
  483. }
  484. var args = new ItemResolveArgs(_configurationManager.ApplicationPaths, directoryService)
  485. {
  486. Parent = parent,
  487. FileInfo = fileInfo,
  488. CollectionType = collectionType,
  489. LibraryOptions = libraryOptions
  490. };
  491. // Return null if ignore rules deem that we should do so
  492. if (IgnoreFile(args.FileInfo, args.Parent))
  493. {
  494. return null;
  495. }
  496. // Gather child folder and files
  497. if (args.IsDirectory)
  498. {
  499. var isPhysicalRoot = args.IsPhysicalRoot;
  500. // When resolving the root, we need it's grandchildren (children of user views)
  501. var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
  502. FileSystemMetadata[] files;
  503. var isVf = args.IsVf;
  504. try
  505. {
  506. files = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _appHost, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || isVf);
  507. }
  508. catch (Exception ex)
  509. {
  510. if (parent != null && parent.IsPhysicalRoot)
  511. {
  512. _logger.LogError(ex, "Error in GetFilteredFileSystemEntries isPhysicalRoot: {0} IsVf: {1}", isPhysicalRoot, isVf);
  513. files = Array.Empty<FileSystemMetadata>();
  514. }
  515. else
  516. {
  517. throw;
  518. }
  519. }
  520. // Need to remove subpaths that may have been resolved from shortcuts
  521. // Example: if \\server\movies exists, then strip out \\server\movies\action
  522. if (isPhysicalRoot)
  523. {
  524. files = NormalizeRootPathList(files).ToArray();
  525. }
  526. args.FileSystemChildren = files;
  527. }
  528. // Check to see if we should resolve based on our contents
  529. if (args.IsDirectory && !ShouldResolvePathContents(args))
  530. {
  531. return null;
  532. }
  533. return ResolveItem(args, resolvers);
  534. }
  535. public bool IgnoreFile(FileSystemMetadata file, BaseItem parent)
  536. => EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(file, parent));
  537. public List<FileSystemMetadata> NormalizeRootPathList(IEnumerable<FileSystemMetadata> paths)
  538. {
  539. var originalList = paths.ToList();
  540. var list = originalList.Where(i => i.IsDirectory)
  541. .Select(i => _fileSystem.NormalizePath(i.FullName))
  542. .Distinct(StringComparer.OrdinalIgnoreCase)
  543. .ToList();
  544. var dupes = list.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && list.Any(i => _fileSystem.ContainsSubPath(i, subPath)))
  545. .ToList();
  546. foreach (var dupe in dupes)
  547. {
  548. _logger.LogInformation("Found duplicate path: {0}", dupe);
  549. }
  550. var newList = list.Except(dupes, StringComparer.OrdinalIgnoreCase).Select(_fileSystem.GetDirectoryInfo).ToList();
  551. newList.AddRange(originalList.Where(i => !i.IsDirectory));
  552. return newList;
  553. }
  554. /// <summary>
  555. /// Determines whether a path should be ignored based on its contents - called after the contents have been read.
  556. /// </summary>
  557. /// <param name="args">The args.</param>
  558. /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
  559. private static bool ShouldResolvePathContents(ItemResolveArgs args)
  560. {
  561. // Ignore any folders containing a file called .ignore
  562. return !args.ContainsFileSystemEntryByName(".ignore");
  563. }
  564. public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryService, Folder parent, LibraryOptions libraryOptions, string collectionType)
  565. {
  566. return ResolvePaths(files, directoryService, parent, libraryOptions, collectionType, EntityResolvers);
  567. }
  568. public IEnumerable<BaseItem> ResolvePaths(
  569. IEnumerable<FileSystemMetadata> files,
  570. IDirectoryService directoryService,
  571. Folder parent,
  572. LibraryOptions libraryOptions,
  573. string collectionType,
  574. IItemResolver[] resolvers)
  575. {
  576. var fileList = files.Where(i => !IgnoreFile(i, parent)).ToList();
  577. if (parent != null)
  578. {
  579. var multiItemResolvers = resolvers == null ? MultiItemResolvers : resolvers.OfType<IMultiItemResolver>().ToArray();
  580. foreach (var resolver in multiItemResolvers)
  581. {
  582. var result = resolver.ResolveMultiple(parent, fileList, collectionType, directoryService);
  583. if (result != null && result.Items.Count > 0)
  584. {
  585. var items = new List<BaseItem>();
  586. items.AddRange(result.Items);
  587. foreach (var item in items)
  588. {
  589. ResolverHelper.SetInitialItemValues(item, parent, this, directoryService);
  590. }
  591. items.AddRange(ResolveFileList(result.ExtraFiles, directoryService, parent, collectionType, resolvers, libraryOptions));
  592. return items;
  593. }
  594. }
  595. }
  596. return ResolveFileList(fileList, directoryService, parent, collectionType, resolvers, libraryOptions);
  597. }
  598. private IEnumerable<BaseItem> ResolveFileList(
  599. IReadOnlyList<FileSystemMetadata> fileList,
  600. IDirectoryService directoryService,
  601. Folder parent,
  602. string collectionType,
  603. IItemResolver[] resolvers,
  604. LibraryOptions libraryOptions)
  605. {
  606. // Given that fileList is a list we can save enumerator allocations by indexing
  607. for (var i = 0; i < fileList.Count; i++)
  608. {
  609. var file = fileList[i];
  610. BaseItem result = null;
  611. try
  612. {
  613. result = ResolvePath(file, directoryService, resolvers, parent, collectionType, libraryOptions);
  614. }
  615. catch (Exception ex)
  616. {
  617. _logger.LogError(ex, "Error resolving path {Path}", file.FullName);
  618. }
  619. if (result != null)
  620. {
  621. yield return result;
  622. }
  623. }
  624. }
  625. /// <summary>
  626. /// Creates the root media folder.
  627. /// </summary>
  628. /// <returns>AggregateFolder.</returns>
  629. /// <exception cref="InvalidOperationException">Cannot create the root folder until plugins have loaded.</exception>
  630. public AggregateFolder CreateRootFolder()
  631. {
  632. var rootFolderPath = _configurationManager.ApplicationPaths.RootFolderPath;
  633. Directory.CreateDirectory(rootFolderPath);
  634. var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ??
  635. ((Folder)ResolvePath(_fileSystem.GetDirectoryInfo(rootFolderPath)))
  636. .DeepCopy<Folder, AggregateFolder>();
  637. // In case program data folder was moved
  638. if (!string.Equals(rootFolder.Path, rootFolderPath, StringComparison.Ordinal))
  639. {
  640. _logger.LogInformation("Resetting root folder path to {0}", rootFolderPath);
  641. rootFolder.Path = rootFolderPath;
  642. }
  643. // Add in the plug-in folders
  644. var path = Path.Combine(_configurationManager.ApplicationPaths.DataPath, "playlists");
  645. Directory.CreateDirectory(path);
  646. Folder folder = new PlaylistsFolder
  647. {
  648. Path = path
  649. };
  650. if (folder.Id.Equals(Guid.Empty))
  651. {
  652. if (string.IsNullOrEmpty(folder.Path))
  653. {
  654. folder.Id = GetNewItemId(folder.GetType().Name, folder.GetType());
  655. }
  656. else
  657. {
  658. folder.Id = GetNewItemId(folder.Path, folder.GetType());
  659. }
  660. }
  661. var dbItem = GetItemById(folder.Id) as BasePluginFolder;
  662. if (dbItem != null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
  663. {
  664. folder = dbItem;
  665. }
  666. if (folder.ParentId != rootFolder.Id)
  667. {
  668. folder.ParentId = rootFolder.Id;
  669. folder.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetResult();
  670. }
  671. rootFolder.AddVirtualChild(folder);
  672. RegisterItem(folder);
  673. return rootFolder;
  674. }
  675. public Folder GetUserRootFolder()
  676. {
  677. if (_userRootFolder == null)
  678. {
  679. lock (_userRootFolderSyncLock)
  680. {
  681. if (_userRootFolder == null)
  682. {
  683. var userRootPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  684. _logger.LogDebug("Creating userRootPath at {path}", userRootPath);
  685. Directory.CreateDirectory(userRootPath);
  686. var newItemId = GetNewItemId(userRootPath, typeof(UserRootFolder));
  687. UserRootFolder tmpItem = null;
  688. try
  689. {
  690. tmpItem = GetItemById(newItemId) as UserRootFolder;
  691. }
  692. catch (Exception ex)
  693. {
  694. _logger.LogError(ex, "Error creating UserRootFolder {path}", newItemId);
  695. }
  696. if (tmpItem == null)
  697. {
  698. _logger.LogDebug("Creating new userRootFolder with DeepCopy");
  699. tmpItem = ((Folder)ResolvePath(_fileSystem.GetDirectoryInfo(userRootPath))).DeepCopy<Folder, UserRootFolder>();
  700. }
  701. // In case program data folder was moved
  702. if (!string.Equals(tmpItem.Path, userRootPath, StringComparison.Ordinal))
  703. {
  704. _logger.LogInformation("Resetting user root folder path to {0}", userRootPath);
  705. tmpItem.Path = userRootPath;
  706. }
  707. _userRootFolder = tmpItem;
  708. _logger.LogDebug("Setting userRootFolder: {folder}", _userRootFolder);
  709. }
  710. }
  711. }
  712. return _userRootFolder;
  713. }
  714. public BaseItem FindByPath(string path, bool? isFolder)
  715. {
  716. // If this returns multiple items it could be tricky figuring out which one is correct.
  717. // In most cases, the newest one will be and the others obsolete but not yet cleaned up
  718. if (string.IsNullOrEmpty(path))
  719. {
  720. throw new ArgumentNullException(nameof(path));
  721. }
  722. var query = new InternalItemsQuery
  723. {
  724. Path = path,
  725. IsFolder = isFolder,
  726. OrderBy = new[] { (ItemSortBy.DateCreated, SortOrder.Descending) },
  727. Limit = 1,
  728. DtoOptions = new DtoOptions(true)
  729. };
  730. return GetItemList(query)
  731. .FirstOrDefault();
  732. }
  733. /// <summary>
  734. /// Gets the person.
  735. /// </summary>
  736. /// <param name="name">The name.</param>
  737. /// <returns>Task{Person}.</returns>
  738. public Person GetPerson(string name)
  739. {
  740. var path = Person.GetPath(name);
  741. var id = GetItemByNameId<Person>(path);
  742. if (GetItemById(id) is not Person item)
  743. {
  744. item = new Person
  745. {
  746. Name = name,
  747. Id = id,
  748. DateCreated = DateTime.UtcNow,
  749. DateModified = DateTime.UtcNow,
  750. Path = path
  751. };
  752. }
  753. return item;
  754. }
  755. /// <summary>
  756. /// Gets the studio.
  757. /// </summary>
  758. /// <param name="name">The name.</param>
  759. /// <returns>Task{Studio}.</returns>
  760. public Studio GetStudio(string name)
  761. {
  762. return CreateItemByName<Studio>(Studio.GetPath, name, new DtoOptions(true));
  763. }
  764. public Guid GetStudioId(string name)
  765. {
  766. return GetItemByNameId<Studio>(Studio.GetPath(name));
  767. }
  768. public Guid GetGenreId(string name)
  769. {
  770. return GetItemByNameId<Genre>(Genre.GetPath(name));
  771. }
  772. public Guid GetMusicGenreId(string name)
  773. {
  774. return GetItemByNameId<MusicGenre>(MusicGenre.GetPath(name));
  775. }
  776. /// <summary>
  777. /// Gets the genre.
  778. /// </summary>
  779. /// <param name="name">The name.</param>
  780. /// <returns>Task{Genre}.</returns>
  781. public Genre GetGenre(string name)
  782. {
  783. return CreateItemByName<Genre>(Genre.GetPath, name, new DtoOptions(true));
  784. }
  785. /// <summary>
  786. /// Gets the music genre.
  787. /// </summary>
  788. /// <param name="name">The name.</param>
  789. /// <returns>Task{MusicGenre}.</returns>
  790. public MusicGenre GetMusicGenre(string name)
  791. {
  792. return CreateItemByName<MusicGenre>(MusicGenre.GetPath, name, new DtoOptions(true));
  793. }
  794. /// <summary>
  795. /// Gets the year.
  796. /// </summary>
  797. /// <param name="value">The value.</param>
  798. /// <returns>Task{Year}.</returns>
  799. public Year GetYear(int value)
  800. {
  801. if (value <= 0)
  802. {
  803. throw new ArgumentOutOfRangeException(nameof(value), "Years less than or equal to 0 are invalid.");
  804. }
  805. var name = value.ToString(CultureInfo.InvariantCulture);
  806. return CreateItemByName<Year>(Year.GetPath, name, new DtoOptions(true));
  807. }
  808. /// <summary>
  809. /// Gets a Genre.
  810. /// </summary>
  811. /// <param name="name">The name.</param>
  812. /// <returns>Task{Genre}.</returns>
  813. public MusicArtist GetArtist(string name)
  814. {
  815. return GetArtist(name, new DtoOptions(true));
  816. }
  817. public MusicArtist GetArtist(string name, DtoOptions options)
  818. {
  819. return CreateItemByName<MusicArtist>(MusicArtist.GetPath, name, options);
  820. }
  821. private T CreateItemByName<T>(Func<string, string> getPathFn, string name, DtoOptions options)
  822. where T : BaseItem, new()
  823. {
  824. if (typeof(T) == typeof(MusicArtist))
  825. {
  826. var existing = GetItemList(new InternalItemsQuery
  827. {
  828. IncludeItemTypes = new[] { nameof(MusicArtist) },
  829. Name = name,
  830. DtoOptions = options
  831. }).Cast<MusicArtist>()
  832. .OrderBy(i => i.IsAccessedByName ? 1 : 0)
  833. .Cast<T>()
  834. .FirstOrDefault();
  835. if (existing != null)
  836. {
  837. return existing;
  838. }
  839. }
  840. var path = getPathFn(name);
  841. var id = GetItemByNameId<T>(path);
  842. var item = GetItemById(id) as T;
  843. if (item == null)
  844. {
  845. item = new T
  846. {
  847. Name = name,
  848. Id = id,
  849. DateCreated = DateTime.UtcNow,
  850. DateModified = DateTime.UtcNow,
  851. Path = path
  852. };
  853. CreateItem(item, null);
  854. }
  855. return item;
  856. }
  857. private Guid GetItemByNameId<T>(string path)
  858. where T : BaseItem, new()
  859. {
  860. var forceCaseInsensitiveId = _configurationManager.Configuration.EnableNormalizedItemByNameIds;
  861. return GetNewItemIdInternal(path, typeof(T), forceCaseInsensitiveId);
  862. }
  863. /// <summary>
  864. /// Validate and refresh the People sub-set of the IBN.
  865. /// The items are stored in the db but not loaded into memory until actually requested by an operation.
  866. /// </summary>
  867. /// <param name="cancellationToken">The cancellation token.</param>
  868. /// <param name="progress">The progress.</param>
  869. /// <returns>Task.</returns>
  870. public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
  871. {
  872. // Ensure the location is available.
  873. Directory.CreateDirectory(_configurationManager.ApplicationPaths.PeoplePath);
  874. return new PeopleValidator(this, _logger, _fileSystem).ValidatePeople(cancellationToken, progress);
  875. }
  876. /// <summary>
  877. /// Reloads the root media folder.
  878. /// </summary>
  879. /// <param name="progress">The progress.</param>
  880. /// <param name="cancellationToken">The cancellation token.</param>
  881. /// <returns>Task.</returns>
  882. public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
  883. {
  884. // Just run the scheduled task so that the user can see it
  885. _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
  886. return Task.CompletedTask;
  887. }
  888. /// <summary>
  889. /// Queues the library scan.
  890. /// </summary>
  891. public void QueueLibraryScan()
  892. {
  893. // Just run the scheduled task so that the user can see it
  894. _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
  895. }
  896. /// <summary>
  897. /// Validates the media library internal.
  898. /// </summary>
  899. /// <param name="progress">The progress.</param>
  900. /// <param name="cancellationToken">The cancellation token.</param>
  901. /// <returns>Task.</returns>
  902. public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
  903. {
  904. IsScanRunning = true;
  905. LibraryMonitor.Stop();
  906. try
  907. {
  908. await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
  909. }
  910. finally
  911. {
  912. LibraryMonitor.Start();
  913. IsScanRunning = false;
  914. }
  915. }
  916. private async Task ValidateTopLibraryFolders(CancellationToken cancellationToken)
  917. {
  918. await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  919. // Start by just validating the children of the root, but go no further
  920. await RootFolder.ValidateChildren(
  921. new SimpleProgress<double>(),
  922. new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
  923. recursive: false,
  924. cancellationToken).ConfigureAwait(false);
  925. await GetUserRootFolder().RefreshMetadata(cancellationToken).ConfigureAwait(false);
  926. await GetUserRootFolder().ValidateChildren(
  927. new SimpleProgress<double>(),
  928. new MetadataRefreshOptions(new DirectoryService(_fileSystem)),
  929. recursive: false,
  930. cancellationToken).ConfigureAwait(false);
  931. // Quickly scan CollectionFolders for changes
  932. foreach (var folder in GetUserRootFolder().Children.OfType<Folder>())
  933. {
  934. await folder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  935. }
  936. }
  937. private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
  938. {
  939. _logger.LogInformation("Validating media library");
  940. await ValidateTopLibraryFolders(cancellationToken).ConfigureAwait(false);
  941. var innerProgress = new ActionableProgress<double>();
  942. innerProgress.RegisterAction(pct => progress.Report(pct * 0.96));
  943. // Validate the entire media library
  944. await RootFolder.ValidateChildren(innerProgress, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), recursive: true, cancellationToken).ConfigureAwait(false);
  945. progress.Report(96);
  946. innerProgress = new ActionableProgress<double>();
  947. innerProgress.RegisterAction(pct => progress.Report(96 + (pct * .04)));
  948. await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
  949. progress.Report(100);
  950. }
  951. /// <summary>
  952. /// Runs the post scan tasks.
  953. /// </summary>
  954. /// <param name="progress">The progress.</param>
  955. /// <param name="cancellationToken">The cancellation token.</param>
  956. /// <returns>Task.</returns>
  957. private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
  958. {
  959. var tasks = PostscanTasks.ToList();
  960. var numComplete = 0;
  961. var numTasks = tasks.Count;
  962. foreach (var task in tasks)
  963. {
  964. var innerProgress = new ActionableProgress<double>();
  965. // Prevent access to modified closure
  966. var currentNumComplete = numComplete;
  967. innerProgress.RegisterAction(pct =>
  968. {
  969. double innerPercent = pct;
  970. innerPercent /= 100;
  971. innerPercent += currentNumComplete;
  972. innerPercent /= numTasks;
  973. innerPercent *= 100;
  974. progress.Report(innerPercent);
  975. });
  976. _logger.LogDebug("Running post-scan task {0}", task.GetType().Name);
  977. try
  978. {
  979. await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
  980. }
  981. catch (OperationCanceledException)
  982. {
  983. _logger.LogInformation("Post-scan task cancelled: {0}", task.GetType().Name);
  984. throw;
  985. }
  986. catch (Exception ex)
  987. {
  988. _logger.LogError(ex, "Error running post-scan task");
  989. }
  990. numComplete++;
  991. double percent = numComplete;
  992. percent /= numTasks;
  993. progress.Report(percent * 100);
  994. }
  995. _itemRepository.UpdateInheritedValues();
  996. progress.Report(100);
  997. }
  998. /// <summary>
  999. /// Gets the default view.
  1000. /// </summary>
  1001. /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
  1002. public List<VirtualFolderInfo> GetVirtualFolders()
  1003. {
  1004. return GetVirtualFolders(false);
  1005. }
  1006. public List<VirtualFolderInfo> GetVirtualFolders(bool includeRefreshState)
  1007. {
  1008. _logger.LogDebug("Getting topLibraryFolders");
  1009. var topLibraryFolders = GetUserRootFolder().Children.ToList();
  1010. _logger.LogDebug("Getting refreshQueue");
  1011. var refreshQueue = includeRefreshState ? ProviderManager.GetRefreshQueue() : null;
  1012. return _fileSystem.GetDirectoryPaths(_configurationManager.ApplicationPaths.DefaultUserViewsPath)
  1013. .Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders, refreshQueue))
  1014. .ToList();
  1015. }
  1016. private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> allCollectionFolders, Dictionary<Guid, Guid> refreshQueue)
  1017. {
  1018. var info = new VirtualFolderInfo
  1019. {
  1020. Name = Path.GetFileName(dir),
  1021. Locations = _fileSystem.GetFilePaths(dir, false)
  1022. .Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
  1023. .Select(i =>
  1024. {
  1025. try
  1026. {
  1027. return _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(i));
  1028. }
  1029. catch (Exception ex)
  1030. {
  1031. _logger.LogError(ex, "Error resolving shortcut file {file}", i);
  1032. return null;
  1033. }
  1034. })
  1035. .Where(i => i != null)
  1036. .OrderBy(i => i)
  1037. .ToArray(),
  1038. CollectionType = GetCollectionType(dir)
  1039. };
  1040. var libraryFolder = allCollectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.OrdinalIgnoreCase));
  1041. if (libraryFolder != null && libraryFolder.HasImage(ImageType.Primary))
  1042. {
  1043. info.PrimaryImageItemId = libraryFolder.Id.ToString("N", CultureInfo.InvariantCulture);
  1044. }
  1045. if (libraryFolder != null)
  1046. {
  1047. info.ItemId = libraryFolder.Id.ToString("N", CultureInfo.InvariantCulture);
  1048. info.LibraryOptions = GetLibraryOptions(libraryFolder);
  1049. if (refreshQueue != null)
  1050. {
  1051. info.RefreshProgress = libraryFolder.GetRefreshProgress();
  1052. info.RefreshStatus = info.RefreshProgress.HasValue ? "Active" : refreshQueue.ContainsKey(libraryFolder.Id) ? "Queued" : "Idle";
  1053. }
  1054. }
  1055. return info;
  1056. }
  1057. private CollectionTypeOptions? GetCollectionType(string path)
  1058. {
  1059. var files = _fileSystem.GetFilePaths(path, new[] { ".collection" }, true, false);
  1060. foreach (ReadOnlySpan<char> file in files)
  1061. {
  1062. if (Enum.TryParse<CollectionTypeOptions>(Path.GetFileNameWithoutExtension(file), true, out var res))
  1063. {
  1064. return res;
  1065. }
  1066. }
  1067. return null;
  1068. }
  1069. /// <summary>
  1070. /// Gets the item by id.
  1071. /// </summary>
  1072. /// <param name="id">The id.</param>
  1073. /// <returns>BaseItem.</returns>
  1074. /// <exception cref="ArgumentNullException"><paramref name="id"/> is <c>null</c>.</exception>
  1075. public BaseItem GetItemById(Guid id)
  1076. {
  1077. if (id == Guid.Empty)
  1078. {
  1079. throw new ArgumentException("Guid can't be empty", nameof(id));
  1080. }
  1081. if (_memoryCache.TryGetValue(id, out BaseItem item))
  1082. {
  1083. return item;
  1084. }
  1085. item = RetrieveItem(id);
  1086. if (item != null)
  1087. {
  1088. RegisterItem(item);
  1089. }
  1090. return item;
  1091. }
  1092. public List<BaseItem> GetItemList(InternalItemsQuery query, bool allowExternalContent)
  1093. {
  1094. if (query.Recursive && query.ParentId != Guid.Empty)
  1095. {
  1096. var parent = GetItemById(query.ParentId);
  1097. if (parent != null)
  1098. {
  1099. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1100. }
  1101. }
  1102. if (query.User != null)
  1103. {
  1104. AddUserToQuery(query, query.User, allowExternalContent);
  1105. }
  1106. return _itemRepository.GetItemList(query);
  1107. }
  1108. public List<BaseItem> GetItemList(InternalItemsQuery query)
  1109. {
  1110. return GetItemList(query, true);
  1111. }
  1112. public int GetCount(InternalItemsQuery query)
  1113. {
  1114. if (query.Recursive && !query.ParentId.Equals(Guid.Empty))
  1115. {
  1116. var parent = GetItemById(query.ParentId);
  1117. if (parent != null)
  1118. {
  1119. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1120. }
  1121. }
  1122. if (query.User != null)
  1123. {
  1124. AddUserToQuery(query, query.User);
  1125. }
  1126. return _itemRepository.GetCount(query);
  1127. }
  1128. public List<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
  1129. {
  1130. SetTopParentIdsOrAncestors(query, parents);
  1131. if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
  1132. {
  1133. if (query.User != null)
  1134. {
  1135. AddUserToQuery(query, query.User);
  1136. }
  1137. }
  1138. return _itemRepository.GetItemList(query);
  1139. }
  1140. public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
  1141. {
  1142. if (query.User != null)
  1143. {
  1144. AddUserToQuery(query, query.User);
  1145. }
  1146. if (query.EnableTotalRecordCount)
  1147. {
  1148. return _itemRepository.GetItems(query);
  1149. }
  1150. return new QueryResult<BaseItem>
  1151. {
  1152. Items = _itemRepository.GetItemList(query)
  1153. };
  1154. }
  1155. public List<Guid> GetItemIds(InternalItemsQuery query)
  1156. {
  1157. if (query.User != null)
  1158. {
  1159. AddUserToQuery(query, query.User);
  1160. }
  1161. return _itemRepository.GetItemIdsList(query);
  1162. }
  1163. public QueryResult<(BaseItem, ItemCounts)> GetStudios(InternalItemsQuery query)
  1164. {
  1165. if (query.User != null)
  1166. {
  1167. AddUserToQuery(query, query.User);
  1168. }
  1169. SetTopParentOrAncestorIds(query);
  1170. return _itemRepository.GetStudios(query);
  1171. }
  1172. public QueryResult<(BaseItem, ItemCounts)> GetGenres(InternalItemsQuery query)
  1173. {
  1174. if (query.User != null)
  1175. {
  1176. AddUserToQuery(query, query.User);
  1177. }
  1178. SetTopParentOrAncestorIds(query);
  1179. return _itemRepository.GetGenres(query);
  1180. }
  1181. public QueryResult<(BaseItem, ItemCounts)> GetMusicGenres(InternalItemsQuery query)
  1182. {
  1183. if (query.User != null)
  1184. {
  1185. AddUserToQuery(query, query.User);
  1186. }
  1187. SetTopParentOrAncestorIds(query);
  1188. return _itemRepository.GetMusicGenres(query);
  1189. }
  1190. public QueryResult<(BaseItem, ItemCounts)> GetAllArtists(InternalItemsQuery query)
  1191. {
  1192. if (query.User != null)
  1193. {
  1194. AddUserToQuery(query, query.User);
  1195. }
  1196. SetTopParentOrAncestorIds(query);
  1197. return _itemRepository.GetAllArtists(query);
  1198. }
  1199. public QueryResult<(BaseItem, ItemCounts)> GetArtists(InternalItemsQuery query)
  1200. {
  1201. if (query.User != null)
  1202. {
  1203. AddUserToQuery(query, query.User);
  1204. }
  1205. SetTopParentOrAncestorIds(query);
  1206. return _itemRepository.GetArtists(query);
  1207. }
  1208. private void SetTopParentOrAncestorIds(InternalItemsQuery query)
  1209. {
  1210. var ancestorIds = query.AncestorIds;
  1211. int len = ancestorIds.Length;
  1212. if (len == 0)
  1213. {
  1214. return;
  1215. }
  1216. var parents = new BaseItem[len];
  1217. for (int i = 0; i < len; i++)
  1218. {
  1219. parents[i] = GetItemById(ancestorIds[i]);
  1220. if (!(parents[i] is ICollectionFolder || parents[i] is UserView))
  1221. {
  1222. return;
  1223. }
  1224. }
  1225. // Optimize by querying against top level views
  1226. query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
  1227. query.AncestorIds = Array.Empty<Guid>();
  1228. // Prevent searching in all libraries due to empty filter
  1229. if (query.TopParentIds.Length == 0)
  1230. {
  1231. query.TopParentIds = new[] { Guid.NewGuid() };
  1232. }
  1233. }
  1234. public QueryResult<(BaseItem, ItemCounts)> GetAlbumArtists(InternalItemsQuery query)
  1235. {
  1236. if (query.User != null)
  1237. {
  1238. AddUserToQuery(query, query.User);
  1239. }
  1240. SetTopParentOrAncestorIds(query);
  1241. return _itemRepository.GetAlbumArtists(query);
  1242. }
  1243. public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
  1244. {
  1245. if (query.Recursive && !query.ParentId.Equals(Guid.Empty))
  1246. {
  1247. var parent = GetItemById(query.ParentId);
  1248. if (parent != null)
  1249. {
  1250. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1251. }
  1252. }
  1253. if (query.User != null)
  1254. {
  1255. AddUserToQuery(query, query.User);
  1256. }
  1257. if (query.EnableTotalRecordCount)
  1258. {
  1259. return _itemRepository.GetItems(query);
  1260. }
  1261. return new QueryResult<BaseItem>
  1262. {
  1263. Items = _itemRepository.GetItemList(query)
  1264. };
  1265. }
  1266. private void SetTopParentIdsOrAncestors(InternalItemsQuery query, List<BaseItem> parents)
  1267. {
  1268. if (parents.All(i => i is ICollectionFolder || i is UserView))
  1269. {
  1270. // Optimize by querying against top level views
  1271. query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).ToArray();
  1272. // Prevent searching in all libraries due to empty filter
  1273. if (query.TopParentIds.Length == 0)
  1274. {
  1275. query.TopParentIds = new[] { Guid.NewGuid() };
  1276. }
  1277. }
  1278. else
  1279. {
  1280. // We need to be able to query from any arbitrary ancestor up the tree
  1281. query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).ToArray();
  1282. // Prevent searching in all libraries due to empty filter
  1283. if (query.AncestorIds.Length == 0)
  1284. {
  1285. query.AncestorIds = new[] { Guid.NewGuid() };
  1286. }
  1287. }
  1288. query.Parent = null;
  1289. }
  1290. private void AddUserToQuery(InternalItemsQuery query, User user, bool allowExternalContent = true)
  1291. {
  1292. if (query.AncestorIds.Length == 0 &&
  1293. query.ParentId.Equals(Guid.Empty) &&
  1294. query.ChannelIds.Count == 0 &&
  1295. query.TopParentIds.Length == 0 &&
  1296. string.IsNullOrEmpty(query.AncestorWithPresentationUniqueKey) &&
  1297. string.IsNullOrEmpty(query.SeriesPresentationUniqueKey) &&
  1298. query.ItemIds.Length == 0)
  1299. {
  1300. var userViews = UserViewManager.GetUserViews(new UserViewQuery
  1301. {
  1302. UserId = user.Id,
  1303. IncludeHidden = true,
  1304. IncludeExternalContent = allowExternalContent
  1305. });
  1306. query.TopParentIds = userViews.SelectMany(i => GetTopParentIdsForQuery(i, user)).ToArray();
  1307. }
  1308. }
  1309. private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User user)
  1310. {
  1311. if (item is UserView view)
  1312. {
  1313. if (string.Equals(view.ViewType, CollectionType.LiveTv, StringComparison.Ordinal))
  1314. {
  1315. return new[] { view.Id };
  1316. }
  1317. // Translate view into folders
  1318. if (!view.DisplayParentId.Equals(Guid.Empty))
  1319. {
  1320. var displayParent = GetItemById(view.DisplayParentId);
  1321. if (displayParent != null)
  1322. {
  1323. return GetTopParentIdsForQuery(displayParent, user);
  1324. }
  1325. return Array.Empty<Guid>();
  1326. }
  1327. if (!view.ParentId.Equals(Guid.Empty))
  1328. {
  1329. var displayParent = GetItemById(view.ParentId);
  1330. if (displayParent != null)
  1331. {
  1332. return GetTopParentIdsForQuery(displayParent, user);
  1333. }
  1334. return Array.Empty<Guid>();
  1335. }
  1336. // Handle grouping
  1337. if (user != null && !string.IsNullOrEmpty(view.ViewType) && UserView.IsEligibleForGrouping(view.ViewType)
  1338. && user.GetPreference(PreferenceKind.GroupedFolders).Length > 0)
  1339. {
  1340. return GetUserRootFolder()
  1341. .GetChildren(user, true)
  1342. .OfType<CollectionFolder>()
  1343. .Where(i => string.IsNullOrEmpty(i.CollectionType) || string.Equals(i.CollectionType, view.ViewType, StringComparison.OrdinalIgnoreCase))
  1344. .Where(i => user.IsFolderGrouped(i.Id))
  1345. .SelectMany(i => GetTopParentIdsForQuery(i, user));
  1346. }
  1347. return Array.Empty<Guid>();
  1348. }
  1349. if (item is CollectionFolder collectionFolder)
  1350. {
  1351. return collectionFolder.PhysicalFolderIds;
  1352. }
  1353. var topParent = item.GetTopParent();
  1354. if (topParent != null)
  1355. {
  1356. return new[] { topParent.Id };
  1357. }
  1358. return Array.Empty<Guid>();
  1359. }
  1360. /// <summary>
  1361. /// Gets the intros.
  1362. /// </summary>
  1363. /// <param name="item">The item.</param>
  1364. /// <param name="user">The user.</param>
  1365. /// <returns>IEnumerable{System.String}.</returns>
  1366. public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
  1367. {
  1368. var tasks = IntroProviders
  1369. .Take(1)
  1370. .Select(i => GetIntros(i, item, user));
  1371. var items = await Task.WhenAll(tasks).ConfigureAwait(false);
  1372. return items
  1373. .SelectMany(i => i.ToArray())
  1374. .Select(ResolveIntro)
  1375. .Where(i => i != null);
  1376. }
  1377. /// <summary>
  1378. /// Gets the intros.
  1379. /// </summary>
  1380. /// <param name="provider">The provider.</param>
  1381. /// <param name="item">The item.</param>
  1382. /// <param name="user">The user.</param>
  1383. /// <returns>Task&lt;IEnumerable&lt;IntroInfo&gt;&gt;.</returns>
  1384. private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
  1385. {
  1386. try
  1387. {
  1388. return await provider.GetIntros(item, user).ConfigureAwait(false);
  1389. }
  1390. catch (Exception ex)
  1391. {
  1392. _logger.LogError(ex, "Error getting intros");
  1393. return new List<IntroInfo>();
  1394. }
  1395. }
  1396. /// <summary>
  1397. /// Gets all intro files.
  1398. /// </summary>
  1399. /// <returns>IEnumerable{System.String}.</returns>
  1400. public IEnumerable<string> GetAllIntroFiles()
  1401. {
  1402. return IntroProviders.SelectMany(i =>
  1403. {
  1404. try
  1405. {
  1406. return i.GetAllIntroFiles().ToList();
  1407. }
  1408. catch (Exception ex)
  1409. {
  1410. _logger.LogError(ex, "Error getting intro files");
  1411. return new List<string>();
  1412. }
  1413. });
  1414. }
  1415. /// <summary>
  1416. /// Resolves the intro.
  1417. /// </summary>
  1418. /// <param name="info">The info.</param>
  1419. /// <returns>Video.</returns>
  1420. private Video ResolveIntro(IntroInfo info)
  1421. {
  1422. Video video = null;
  1423. if (info.ItemId.HasValue)
  1424. {
  1425. // Get an existing item by Id
  1426. video = GetItemById(info.ItemId.Value) as Video;
  1427. if (video == null)
  1428. {
  1429. _logger.LogError("Unable to locate item with Id {ID}.", info.ItemId.Value);
  1430. }
  1431. }
  1432. else if (!string.IsNullOrEmpty(info.Path))
  1433. {
  1434. try
  1435. {
  1436. // Try to resolve the path into a video
  1437. video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
  1438. if (video == null)
  1439. {
  1440. _logger.LogError("Intro resolver returned null for {path}.", info.Path);
  1441. }
  1442. else
  1443. {
  1444. // Pull the saved db item that will include metadata
  1445. var dbItem = GetItemById(video.Id) as Video;
  1446. if (dbItem != null)
  1447. {
  1448. video = dbItem;
  1449. }
  1450. else
  1451. {
  1452. return null;
  1453. }
  1454. }
  1455. }
  1456. catch (Exception ex)
  1457. {
  1458. _logger.LogError(ex, "Error resolving path {path}.", info.Path);
  1459. }
  1460. }
  1461. else
  1462. {
  1463. _logger.LogError("IntroProvider returned an IntroInfo with null Path and ItemId.");
  1464. }
  1465. return video;
  1466. }
  1467. /// <summary>
  1468. /// Sorts the specified sort by.
  1469. /// </summary>
  1470. /// <param name="items">The items.</param>
  1471. /// <param name="user">The user.</param>
  1472. /// <param name="sortBy">The sort by.</param>
  1473. /// <param name="sortOrder">The sort order.</param>
  1474. /// <returns>IEnumerable{BaseItem}.</returns>
  1475. public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<string> sortBy, SortOrder sortOrder)
  1476. {
  1477. var isFirst = true;
  1478. IOrderedEnumerable<BaseItem> orderedItems = null;
  1479. foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c != null))
  1480. {
  1481. if (isFirst)
  1482. {
  1483. orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, orderBy) : items.OrderBy(i => i, orderBy);
  1484. }
  1485. else
  1486. {
  1487. orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, orderBy) : orderedItems.ThenBy(i => i, orderBy);
  1488. }
  1489. isFirst = false;
  1490. }
  1491. return orderedItems ?? items;
  1492. }
  1493. public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<ValueTuple<string, SortOrder>> orderBy)
  1494. {
  1495. var isFirst = true;
  1496. IOrderedEnumerable<BaseItem> orderedItems = null;
  1497. foreach (var (name, sortOrder) in orderBy)
  1498. {
  1499. var comparer = GetComparer(name, user);
  1500. if (comparer == null)
  1501. {
  1502. continue;
  1503. }
  1504. if (isFirst)
  1505. {
  1506. orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, comparer) : items.OrderBy(i => i, comparer);
  1507. }
  1508. else
  1509. {
  1510. orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, comparer) : orderedItems.ThenBy(i => i, comparer);
  1511. }
  1512. isFirst = false;
  1513. }
  1514. return orderedItems ?? items;
  1515. }
  1516. /// <summary>
  1517. /// Gets the comparer.
  1518. /// </summary>
  1519. /// <param name="name">The name.</param>
  1520. /// <param name="user">The user.</param>
  1521. /// <returns>IBaseItemComparer.</returns>
  1522. private IBaseItemComparer GetComparer(string name, User user)
  1523. {
  1524. var comparer = Comparers.FirstOrDefault(c => string.Equals(name, c.Name, StringComparison.OrdinalIgnoreCase));
  1525. // If it requires a user, create a new one, and assign the user
  1526. if (comparer is IUserBaseItemComparer)
  1527. {
  1528. var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType());
  1529. userComparer.User = user;
  1530. userComparer.UserManager = _userManager;
  1531. userComparer.UserDataRepository = _userDataRepository;
  1532. return userComparer;
  1533. }
  1534. return comparer;
  1535. }
  1536. /// <summary>
  1537. /// Creates the item.
  1538. /// </summary>
  1539. /// <param name="item">The item.</param>
  1540. /// <param name="parent">The parent item.</param>
  1541. public void CreateItem(BaseItem item, BaseItem parent)
  1542. {
  1543. CreateItems(new[] { item }, parent, CancellationToken.None);
  1544. }
  1545. /// <summary>
  1546. /// Creates the items.
  1547. /// </summary>
  1548. /// <param name="items">The items.</param>
  1549. /// <param name="parent">The parent item.</param>
  1550. /// <param name="cancellationToken">The cancellation token.</param>
  1551. public void CreateItems(IReadOnlyList<BaseItem> items, BaseItem parent, CancellationToken cancellationToken)
  1552. {
  1553. _itemRepository.SaveItems(items, cancellationToken);
  1554. foreach (var item in items)
  1555. {
  1556. RegisterItem(item);
  1557. }
  1558. if (ItemAdded != null)
  1559. {
  1560. foreach (var item in items)
  1561. {
  1562. // With the live tv guide this just creates too much noise
  1563. if (item.SourceType != SourceType.Library)
  1564. {
  1565. continue;
  1566. }
  1567. try
  1568. {
  1569. ItemAdded(
  1570. this,
  1571. new ItemChangeEventArgs
  1572. {
  1573. Item = item,
  1574. Parent = parent ?? item.GetParent()
  1575. });
  1576. }
  1577. catch (Exception ex)
  1578. {
  1579. _logger.LogError(ex, "Error in ItemAdded event handler");
  1580. }
  1581. }
  1582. }
  1583. }
  1584. private bool ImageNeedsRefresh(ItemImageInfo image)
  1585. {
  1586. if (image.Path != null && image.IsLocalFile)
  1587. {
  1588. if (image.Width == 0 || image.Height == 0 || string.IsNullOrEmpty(image.BlurHash))
  1589. {
  1590. return true;
  1591. }
  1592. try
  1593. {
  1594. return _fileSystem.GetLastWriteTimeUtc(image.Path) != image.DateModified;
  1595. }
  1596. catch (Exception ex)
  1597. {
  1598. _logger.LogError(ex, "Cannot get file info for {0}", image.Path);
  1599. return false;
  1600. }
  1601. }
  1602. return image.Path != null && !image.IsLocalFile;
  1603. }
  1604. /// <inheritdoc />
  1605. public async Task UpdateImagesAsync(BaseItem item, bool forceUpdate = false)
  1606. {
  1607. if (item == null)
  1608. {
  1609. throw new ArgumentNullException(nameof(item));
  1610. }
  1611. var outdated = forceUpdate ? item.ImageInfos.Where(i => i.Path != null).ToArray() : item.ImageInfos.Where(ImageNeedsRefresh).ToArray();
  1612. // Skip image processing if current or live tv source
  1613. if (outdated.Length == 0 || item.SourceType != SourceType.Library)
  1614. {
  1615. RegisterItem(item);
  1616. return;
  1617. }
  1618. foreach (var img in outdated)
  1619. {
  1620. var image = img;
  1621. if (!img.IsLocalFile)
  1622. {
  1623. try
  1624. {
  1625. var index = item.GetImageIndex(img);
  1626. image = await ConvertImageToLocal(item, img, index).ConfigureAwait(false);
  1627. }
  1628. catch (ArgumentException)
  1629. {
  1630. _logger.LogWarning("Cannot get image index for {ImagePath}", img.Path);
  1631. continue;
  1632. }
  1633. catch (Exception ex) when (ex is InvalidOperationException || ex is IOException)
  1634. {
  1635. _logger.LogWarning(ex, "Cannot fetch image from {ImagePath}", img.Path);
  1636. continue;
  1637. }
  1638. catch (HttpRequestException ex)
  1639. {
  1640. _logger.LogWarning(ex, "Cannot fetch image from {ImagePath}. Http status code: {HttpStatus}", img.Path, ex.StatusCode);
  1641. continue;
  1642. }
  1643. }
  1644. try
  1645. {
  1646. ImageDimensions size = _imageProcessor.GetImageDimensions(item, image);
  1647. image.Width = size.Width;
  1648. image.Height = size.Height;
  1649. }
  1650. catch (Exception ex)
  1651. {
  1652. _logger.LogError(ex, "Cannot get image dimensions for {ImagePath}", image.Path);
  1653. image.Width = 0;
  1654. image.Height = 0;
  1655. continue;
  1656. }
  1657. try
  1658. {
  1659. image.BlurHash = _imageProcessor.GetImageBlurHash(image.Path);
  1660. }
  1661. catch (Exception ex)
  1662. {
  1663. _logger.LogError(ex, "Cannot compute blurhash for {ImagePath}", image.Path);
  1664. image.BlurHash = string.Empty;
  1665. }
  1666. try
  1667. {
  1668. image.DateModified = _fileSystem.GetLastWriteTimeUtc(image.Path);
  1669. }
  1670. catch (Exception ex)
  1671. {
  1672. _logger.LogError(ex, "Cannot update DateModified for {ImagePath}", image.Path);
  1673. }
  1674. }
  1675. _itemRepository.SaveImages(item);
  1676. RegisterItem(item);
  1677. }
  1678. /// <inheritdoc />
  1679. public async Task UpdateItemsAsync(IReadOnlyList<BaseItem> items, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken)
  1680. {
  1681. foreach (var item in items)
  1682. {
  1683. await RunMetadataSavers(item, updateReason).ConfigureAwait(false);
  1684. }
  1685. _itemRepository.SaveItems(items, cancellationToken);
  1686. if (ItemUpdated != null)
  1687. {
  1688. foreach (var item in items)
  1689. {
  1690. // With the live tv guide this just creates too much noise
  1691. if (item.SourceType != SourceType.Library)
  1692. {
  1693. continue;
  1694. }
  1695. try
  1696. {
  1697. ItemUpdated(
  1698. this,
  1699. new ItemChangeEventArgs
  1700. {
  1701. Item = item,
  1702. Parent = parent,
  1703. UpdateReason = updateReason
  1704. });
  1705. }
  1706. catch (Exception ex)
  1707. {
  1708. _logger.LogError(ex, "Error in ItemUpdated event handler");
  1709. }
  1710. }
  1711. }
  1712. }
  1713. /// <inheritdoc />
  1714. public Task UpdateItemAsync(BaseItem item, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken)
  1715. => UpdateItemsAsync(new[] { item }, parent, updateReason, cancellationToken);
  1716. public Task RunMetadataSavers(BaseItem item, ItemUpdateType updateReason)
  1717. {
  1718. if (item.IsFileProtocol)
  1719. {
  1720. ProviderManager.SaveMetadata(item, updateReason);
  1721. }
  1722. item.DateLastSaved = DateTime.UtcNow;
  1723. return UpdateImagesAsync(item, updateReason >= ItemUpdateType.ImageUpdate);
  1724. }
  1725. /// <summary>
  1726. /// Reports the item removed.
  1727. /// </summary>
  1728. /// <param name="item">The item.</param>
  1729. /// <param name="parent">The parent item.</param>
  1730. public void ReportItemRemoved(BaseItem item, BaseItem parent)
  1731. {
  1732. if (ItemRemoved != null)
  1733. {
  1734. try
  1735. {
  1736. ItemRemoved(
  1737. this,
  1738. new ItemChangeEventArgs
  1739. {
  1740. Item = item,
  1741. Parent = parent
  1742. });
  1743. }
  1744. catch (Exception ex)
  1745. {
  1746. _logger.LogError(ex, "Error in ItemRemoved event handler");
  1747. }
  1748. }
  1749. }
  1750. /// <summary>
  1751. /// Retrieves the item.
  1752. /// </summary>
  1753. /// <param name="id">The id.</param>
  1754. /// <returns>BaseItem.</returns>
  1755. public BaseItem RetrieveItem(Guid id)
  1756. {
  1757. return _itemRepository.RetrieveItem(id);
  1758. }
  1759. public List<Folder> GetCollectionFolders(BaseItem item)
  1760. {
  1761. while (item != null)
  1762. {
  1763. var parent = item.GetParent();
  1764. if (parent == null || parent is AggregateFolder)
  1765. {
  1766. break;
  1767. }
  1768. item = parent;
  1769. }
  1770. if (item == null)
  1771. {
  1772. return new List<Folder>();
  1773. }
  1774. return GetCollectionFoldersInternal(item, GetUserRootFolder().Children.OfType<Folder>());
  1775. }
  1776. public List<Folder> GetCollectionFolders(BaseItem item, List<Folder> allUserRootChildren)
  1777. {
  1778. while (item != null)
  1779. {
  1780. var parent = item.GetParent();
  1781. if (parent == null || parent is AggregateFolder)
  1782. {
  1783. break;
  1784. }
  1785. item = parent;
  1786. }
  1787. if (item == null)
  1788. {
  1789. return new List<Folder>();
  1790. }
  1791. return GetCollectionFoldersInternal(item, allUserRootChildren);
  1792. }
  1793. private static List<Folder> GetCollectionFoldersInternal(BaseItem item, IEnumerable<Folder> allUserRootChildren)
  1794. {
  1795. return allUserRootChildren
  1796. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path.AsSpan(), StringComparison.OrdinalIgnoreCase))
  1797. .ToList();
  1798. }
  1799. public LibraryOptions GetLibraryOptions(BaseItem item)
  1800. {
  1801. if (item is not CollectionFolder collectionFolder)
  1802. {
  1803. // List.Find is more performant than FirstOrDefault due to enumerator allocation
  1804. collectionFolder = GetCollectionFolders(item)
  1805. .Find(folder => folder is CollectionFolder) as CollectionFolder;
  1806. }
  1807. return collectionFolder == null ? new LibraryOptions() : collectionFolder.GetLibraryOptions();
  1808. }
  1809. public string GetContentType(BaseItem item)
  1810. {
  1811. string configuredContentType = GetConfiguredContentType(item, false);
  1812. if (!string.IsNullOrEmpty(configuredContentType))
  1813. {
  1814. return configuredContentType;
  1815. }
  1816. configuredContentType = GetConfiguredContentType(item, true);
  1817. if (!string.IsNullOrEmpty(configuredContentType))
  1818. {
  1819. return configuredContentType;
  1820. }
  1821. return GetInheritedContentType(item);
  1822. }
  1823. public string GetInheritedContentType(BaseItem item)
  1824. {
  1825. var type = GetTopFolderContentType(item);
  1826. if (!string.IsNullOrEmpty(type))
  1827. {
  1828. return type;
  1829. }
  1830. return item.GetParents()
  1831. .Select(GetConfiguredContentType)
  1832. .LastOrDefault(i => !string.IsNullOrEmpty(i));
  1833. }
  1834. public string GetConfiguredContentType(BaseItem item)
  1835. {
  1836. return GetConfiguredContentType(item, false);
  1837. }
  1838. public string GetConfiguredContentType(string path)
  1839. {
  1840. return GetContentTypeOverride(path, false);
  1841. }
  1842. public string GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
  1843. {
  1844. if (item is ICollectionFolder collectionFolder)
  1845. {
  1846. return collectionFolder.CollectionType;
  1847. }
  1848. return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
  1849. }
  1850. private string GetContentTypeOverride(string path, bool inherit)
  1851. {
  1852. var nameValuePair = _configurationManager.Configuration.ContentTypes
  1853. .FirstOrDefault(i => _fileSystem.AreEqual(i.Name, path)
  1854. || (inherit && !string.IsNullOrEmpty(i.Name)
  1855. && _fileSystem.ContainsSubPath(i.Name, path)));
  1856. return nameValuePair?.Value;
  1857. }
  1858. private string GetTopFolderContentType(BaseItem item)
  1859. {
  1860. if (item == null)
  1861. {
  1862. return null;
  1863. }
  1864. while (!item.ParentId.Equals(Guid.Empty))
  1865. {
  1866. var parent = item.GetParent();
  1867. if (parent == null || parent is AggregateFolder)
  1868. {
  1869. break;
  1870. }
  1871. item = parent;
  1872. }
  1873. return GetUserRootFolder().Children
  1874. .OfType<ICollectionFolder>()
  1875. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
  1876. .Select(i => i.CollectionType)
  1877. .FirstOrDefault(i => !string.IsNullOrEmpty(i));
  1878. }
  1879. public UserView GetNamedView(
  1880. User user,
  1881. string name,
  1882. string viewType,
  1883. string sortName)
  1884. {
  1885. return GetNamedView(user, name, Guid.Empty, viewType, sortName);
  1886. }
  1887. public UserView GetNamedView(
  1888. string name,
  1889. string viewType,
  1890. string sortName)
  1891. {
  1892. var path = Path.Combine(
  1893. _configurationManager.ApplicationPaths.InternalMetadataPath,
  1894. "views",
  1895. _fileSystem.GetValidFilename(viewType));
  1896. var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
  1897. var item = GetItemById(id) as UserView;
  1898. var refresh = false;
  1899. if (item == null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
  1900. {
  1901. Directory.CreateDirectory(path);
  1902. item = new UserView
  1903. {
  1904. Path = path,
  1905. Id = id,
  1906. DateCreated = DateTime.UtcNow,
  1907. Name = name,
  1908. ViewType = viewType,
  1909. ForcedSortName = sortName
  1910. };
  1911. CreateItem(item, null);
  1912. refresh = true;
  1913. }
  1914. if (refresh)
  1915. {
  1916. item.UpdateToRepositoryAsync(ItemUpdateType.MetadataImport, CancellationToken.None).GetAwaiter().GetResult();
  1917. ProviderManager.QueueRefresh(item.Id, new MetadataRefreshOptions(new DirectoryService(_fileSystem)), RefreshPriority.Normal);
  1918. }
  1919. return item;
  1920. }
  1921. public UserView GetNamedView(
  1922. User user,
  1923. string name,
  1924. Guid parentId,
  1925. string viewType,
  1926. string sortName)
  1927. {
  1928. var parentIdString = parentId.Equals(Guid.Empty) ? null : parentId.ToString("N", CultureInfo.InvariantCulture);
  1929. var idValues = "38_namedview_" + name + user.Id.ToString("N", CultureInfo.InvariantCulture) + (parentIdString ?? string.Empty) + (viewType ?? string.Empty);
  1930. var id = GetNewItemId(idValues, typeof(UserView));
  1931. var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N", CultureInfo.InvariantCulture));
  1932. var item = GetItemById(id) as UserView;
  1933. var isNew = false;
  1934. if (item == null)
  1935. {
  1936. Directory.CreateDirectory(path);
  1937. item = new UserView
  1938. {
  1939. Path = path,
  1940. Id = id,
  1941. DateCreated = DateTime.UtcNow,
  1942. Name = name,
  1943. ViewType = viewType,
  1944. ForcedSortName = sortName,
  1945. UserId = user.Id,
  1946. DisplayParentId = parentId
  1947. };
  1948. CreateItem(item, null);
  1949. isNew = true;
  1950. }
  1951. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1952. if (!refresh && !item.DisplayParentId.Equals(Guid.Empty))
  1953. {
  1954. var displayParent = GetItemById(item.DisplayParentId);
  1955. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1956. }
  1957. if (refresh)
  1958. {
  1959. ProviderManager.QueueRefresh(
  1960. item.Id,
  1961. new MetadataRefreshOptions(new DirectoryService(_fileSystem))
  1962. {
  1963. // Need to force save to increment DateLastSaved
  1964. ForceSave = true
  1965. },
  1966. RefreshPriority.Normal);
  1967. }
  1968. return item;
  1969. }
  1970. public UserView GetShadowView(
  1971. BaseItem parent,
  1972. string viewType,
  1973. string sortName)
  1974. {
  1975. if (parent == null)
  1976. {
  1977. throw new ArgumentNullException(nameof(parent));
  1978. }
  1979. var name = parent.Name;
  1980. var parentId = parent.Id;
  1981. var idValues = "38_namedview_" + name + parentId + (viewType ?? string.Empty);
  1982. var id = GetNewItemId(idValues, typeof(UserView));
  1983. var path = parent.Path;
  1984. var item = GetItemById(id) as UserView;
  1985. var isNew = false;
  1986. if (item == null)
  1987. {
  1988. Directory.CreateDirectory(path);
  1989. item = new UserView
  1990. {
  1991. Path = path,
  1992. Id = id,
  1993. DateCreated = DateTime.UtcNow,
  1994. Name = name,
  1995. ViewType = viewType,
  1996. ForcedSortName = sortName
  1997. };
  1998. item.DisplayParentId = parentId;
  1999. CreateItem(item, null);
  2000. isNew = true;
  2001. }
  2002. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  2003. if (!refresh && !item.DisplayParentId.Equals(Guid.Empty))
  2004. {
  2005. var displayParent = GetItemById(item.DisplayParentId);
  2006. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  2007. }
  2008. if (refresh)
  2009. {
  2010. ProviderManager.QueueRefresh(
  2011. item.Id,
  2012. new MetadataRefreshOptions(new DirectoryService(_fileSystem))
  2013. {
  2014. // Need to force save to increment DateLastSaved
  2015. ForceSave = true
  2016. },
  2017. RefreshPriority.Normal);
  2018. }
  2019. return item;
  2020. }
  2021. public UserView GetNamedView(
  2022. string name,
  2023. Guid parentId,
  2024. string viewType,
  2025. string sortName,
  2026. string uniqueId)
  2027. {
  2028. if (string.IsNullOrEmpty(name))
  2029. {
  2030. throw new ArgumentNullException(nameof(name));
  2031. }
  2032. var parentIdString = parentId.Equals(Guid.Empty) ? null : parentId.ToString("N", CultureInfo.InvariantCulture);
  2033. var idValues = "37_namedview_" + name + (parentIdString ?? string.Empty) + (viewType ?? string.Empty);
  2034. if (!string.IsNullOrEmpty(uniqueId))
  2035. {
  2036. idValues += uniqueId;
  2037. }
  2038. var id = GetNewItemId(idValues, typeof(UserView));
  2039. var path = Path.Combine(_configurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N", CultureInfo.InvariantCulture));
  2040. var item = GetItemById(id) as UserView;
  2041. var isNew = false;
  2042. if (item == null)
  2043. {
  2044. Directory.CreateDirectory(path);
  2045. item = new UserView
  2046. {
  2047. Path = path,
  2048. Id = id,
  2049. DateCreated = DateTime.UtcNow,
  2050. Name = name,
  2051. ViewType = viewType,
  2052. ForcedSortName = sortName
  2053. };
  2054. item.DisplayParentId = parentId;
  2055. CreateItem(item, null);
  2056. isNew = true;
  2057. }
  2058. if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
  2059. {
  2060. item.ViewType = viewType;
  2061. item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
  2062. }
  2063. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  2064. if (!refresh && !item.DisplayParentId.Equals(Guid.Empty))
  2065. {
  2066. var displayParent = GetItemById(item.DisplayParentId);
  2067. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  2068. }
  2069. if (refresh)
  2070. {
  2071. ProviderManager.QueueRefresh(
  2072. item.Id,
  2073. new MetadataRefreshOptions(new DirectoryService(_fileSystem))
  2074. {
  2075. // Need to force save to increment DateLastSaved
  2076. ForceSave = true
  2077. },
  2078. RefreshPriority.Normal);
  2079. }
  2080. return item;
  2081. }
  2082. public void AddExternalSubtitleStreams(
  2083. List<MediaStream> streams,
  2084. string videoPath,
  2085. string[] files)
  2086. {
  2087. new SubtitleResolver(BaseItem.LocalizationManager).AddExternalSubtitleStreams(streams, videoPath, streams.Count, files);
  2088. }
  2089. public BaseItem GetParentItem(string parentId, Guid? userId)
  2090. {
  2091. if (string.IsNullOrEmpty(parentId))
  2092. {
  2093. return GetParentItem((Guid?)null, userId);
  2094. }
  2095. return GetParentItem(new Guid(parentId), userId);
  2096. }
  2097. public BaseItem GetParentItem(Guid? parentId, Guid? userId)
  2098. {
  2099. if (parentId.HasValue)
  2100. {
  2101. return GetItemById(parentId.Value);
  2102. }
  2103. if (userId.HasValue && userId != Guid.Empty)
  2104. {
  2105. return GetUserRootFolder();
  2106. }
  2107. return RootFolder;
  2108. }
  2109. /// <inheritdoc />
  2110. public bool IsVideoFile(string path)
  2111. {
  2112. return VideoResolver.IsVideoFile(path, GetNamingOptions());
  2113. }
  2114. /// <inheritdoc />
  2115. public bool IsAudioFile(string path)
  2116. => AudioFileParser.IsAudioFile(path, GetNamingOptions());
  2117. /// <inheritdoc />
  2118. public int? GetSeasonNumberFromPath(string path)
  2119. => SeasonPathParser.Parse(path, true, true).SeasonNumber;
  2120. /// <inheritdoc />
  2121. public bool FillMissingEpisodeNumbersFromPath(Episode episode, bool forceRefresh)
  2122. {
  2123. var series = episode.Series;
  2124. bool? isAbsoluteNaming = series != null && string.Equals(series.DisplayOrder, "absolute", StringComparison.OrdinalIgnoreCase);
  2125. if (!isAbsoluteNaming.Value)
  2126. {
  2127. // In other words, no filter applied
  2128. isAbsoluteNaming = null;
  2129. }
  2130. var resolver = new EpisodeResolver(GetNamingOptions());
  2131. var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd;
  2132. // TODO nullable - what are we trying to do there with empty episodeInfo?
  2133. EpisodeInfo episodeInfo = null;
  2134. if (episode.IsFileProtocol)
  2135. {
  2136. episodeInfo = resolver.Resolve(episode.Path, isFolder, null, null, isAbsoluteNaming);
  2137. // Resolve from parent folder if it's not the Season folder
  2138. var parent = episode.GetParent();
  2139. if (episodeInfo == null && parent.GetType() == typeof(Folder))
  2140. {
  2141. episodeInfo = resolver.Resolve(parent.Path, true, null, null, isAbsoluteNaming);
  2142. if (episodeInfo != null)
  2143. {
  2144. // add the container
  2145. episodeInfo.Container = Path.GetExtension(episode.Path)?.TrimStart('.');
  2146. }
  2147. }
  2148. }
  2149. episodeInfo ??= new EpisodeInfo(episode.Path);
  2150. try
  2151. {
  2152. var libraryOptions = GetLibraryOptions(episode);
  2153. if (libraryOptions.EnableEmbeddedEpisodeInfos && string.Equals(episodeInfo.Container, "mp4", StringComparison.OrdinalIgnoreCase))
  2154. {
  2155. // Read from metadata
  2156. var mediaInfo = _mediaEncoder.GetMediaInfo(
  2157. new MediaInfoRequest
  2158. {
  2159. MediaSource = episode.GetMediaSources(false)[0],
  2160. MediaType = DlnaProfileType.Video
  2161. },
  2162. CancellationToken.None).GetAwaiter().GetResult();
  2163. if (mediaInfo.ParentIndexNumber > 0)
  2164. {
  2165. episodeInfo.SeasonNumber = mediaInfo.ParentIndexNumber;
  2166. }
  2167. if (mediaInfo.IndexNumber > 0)
  2168. {
  2169. episodeInfo.EpisodeNumber = mediaInfo.IndexNumber;
  2170. }
  2171. if (!string.IsNullOrEmpty(mediaInfo.ShowName))
  2172. {
  2173. episodeInfo.SeriesName = mediaInfo.ShowName;
  2174. }
  2175. }
  2176. }
  2177. catch (Exception ex)
  2178. {
  2179. _logger.LogError(ex, "Error reading the episode informations with ffprobe. Episode: {EpisodeInfo}", episodeInfo.Path);
  2180. }
  2181. var changed = false;
  2182. if (episodeInfo.IsByDate)
  2183. {
  2184. if (episode.IndexNumber.HasValue)
  2185. {
  2186. episode.IndexNumber = null;
  2187. changed = true;
  2188. }
  2189. if (episode.IndexNumberEnd.HasValue)
  2190. {
  2191. episode.IndexNumberEnd = null;
  2192. changed = true;
  2193. }
  2194. if (!episode.PremiereDate.HasValue)
  2195. {
  2196. if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
  2197. {
  2198. episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value).ToUniversalTime();
  2199. }
  2200. if (episode.PremiereDate.HasValue)
  2201. {
  2202. changed = true;
  2203. }
  2204. }
  2205. if (!episode.ProductionYear.HasValue)
  2206. {
  2207. episode.ProductionYear = episodeInfo.Year;
  2208. if (episode.ProductionYear.HasValue)
  2209. {
  2210. changed = true;
  2211. }
  2212. }
  2213. }
  2214. else
  2215. {
  2216. if (!episode.IndexNumber.HasValue || forceRefresh)
  2217. {
  2218. if (episode.IndexNumber != episodeInfo.EpisodeNumber)
  2219. {
  2220. changed = true;
  2221. }
  2222. episode.IndexNumber = episodeInfo.EpisodeNumber;
  2223. }
  2224. if (!episode.IndexNumberEnd.HasValue || forceRefresh)
  2225. {
  2226. if (episode.IndexNumberEnd != episodeInfo.EndingEpisodeNumber)
  2227. {
  2228. changed = true;
  2229. }
  2230. episode.IndexNumberEnd = episodeInfo.EndingEpisodeNumber;
  2231. }
  2232. if (!episode.ParentIndexNumber.HasValue || forceRefresh)
  2233. {
  2234. if (episode.ParentIndexNumber != episodeInfo.SeasonNumber)
  2235. {
  2236. changed = true;
  2237. }
  2238. episode.ParentIndexNumber = episodeInfo.SeasonNumber;
  2239. }
  2240. }
  2241. if (!episode.ParentIndexNumber.HasValue)
  2242. {
  2243. var season = episode.Season;
  2244. if (season != null)
  2245. {
  2246. episode.ParentIndexNumber = season.IndexNumber;
  2247. }
  2248. else
  2249. {
  2250. /*
  2251. Anime series don't generally have a season in their file name, however,
  2252. tvdb needs a season to correctly get the metadata.
  2253. Hence, a null season needs to be filled with something. */
  2254. // FIXME perhaps this would be better for tvdb parser to ask for season 1 if no season is specified
  2255. episode.ParentIndexNumber = 1;
  2256. }
  2257. if (episode.ParentIndexNumber.HasValue)
  2258. {
  2259. changed = true;
  2260. }
  2261. }
  2262. return changed;
  2263. }
  2264. /// <inheritdoc />
  2265. public NamingOptions GetNamingOptions()
  2266. {
  2267. if (_namingOptions == null)
  2268. {
  2269. _namingOptions = new NamingOptions();
  2270. _videoFileExtensions = _namingOptions.VideoFileExtensions;
  2271. }
  2272. return _namingOptions;
  2273. }
  2274. public ItemLookupInfo ParseName(string name)
  2275. {
  2276. var namingOptions = GetNamingOptions();
  2277. var result = VideoResolver.CleanDateTime(name, namingOptions);
  2278. return new ItemLookupInfo
  2279. {
  2280. Name = VideoResolver.TryCleanString(result.Name, namingOptions, out var newName) ? newName.ToString() : result.Name,
  2281. Year = result.Year
  2282. };
  2283. }
  2284. public IEnumerable<Video> FindTrailers(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  2285. {
  2286. var namingOptions = GetNamingOptions();
  2287. var files = owner.IsInMixedFolder ? new List<FileSystemMetadata>() : fileSystemChildren.Where(i => i.IsDirectory)
  2288. .Where(i => string.Equals(i.Name, BaseItem.TrailersFolderName, StringComparison.OrdinalIgnoreCase))
  2289. .SelectMany(i => _fileSystem.GetFiles(i.FullName, _videoFileExtensions, false, false))
  2290. .ToList();
  2291. var videos = VideoListResolver.Resolve(fileSystemChildren, namingOptions);
  2292. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files[0].Path, StringComparison.OrdinalIgnoreCase));
  2293. if (currentVideo != null)
  2294. {
  2295. files.AddRange(currentVideo.Extras.Where(i => i.ExtraType == ExtraType.Trailer).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2296. }
  2297. var resolvers = new IItemResolver[]
  2298. {
  2299. new GenericVideoResolver<Trailer>(this)
  2300. };
  2301. return ResolvePaths(files, directoryService, null, new LibraryOptions(), null, resolvers)
  2302. .OfType<Trailer>()
  2303. .Select(video =>
  2304. {
  2305. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2306. if (GetItemById(video.Id) is Trailer dbItem)
  2307. {
  2308. video = dbItem;
  2309. }
  2310. video.ParentId = Guid.Empty;
  2311. video.OwnerId = owner.Id;
  2312. video.ExtraType = ExtraType.Trailer;
  2313. video.TrailerTypes = new[] { TrailerType.LocalTrailer };
  2314. return video;
  2315. // Sort them so that the list can be easily compared for changes
  2316. }).OrderBy(i => i.Path);
  2317. }
  2318. public IEnumerable<Video> FindExtras(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  2319. {
  2320. var namingOptions = GetNamingOptions();
  2321. var files = owner.IsInMixedFolder ? new List<FileSystemMetadata>() : fileSystemChildren.Where(i => i.IsDirectory)
  2322. .Where(i => BaseItem.AllExtrasTypesFolderNames.ContainsKey(i.Name ?? string.Empty))
  2323. .SelectMany(i => _fileSystem.GetFiles(i.FullName, _videoFileExtensions, false, false))
  2324. .ToList();
  2325. var videos = VideoListResolver.Resolve(fileSystemChildren, namingOptions);
  2326. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files[0].Path, StringComparison.OrdinalIgnoreCase));
  2327. if (currentVideo != null)
  2328. {
  2329. files.AddRange(currentVideo.Extras.Where(i => i.ExtraType != ExtraType.Trailer).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2330. }
  2331. return ResolvePaths(files, directoryService, null, new LibraryOptions(), null)
  2332. .OfType<Video>()
  2333. .Select(video =>
  2334. {
  2335. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2336. var dbItem = GetItemById(video.Id) as Video;
  2337. if (dbItem != null)
  2338. {
  2339. video = dbItem;
  2340. }
  2341. video.ParentId = Guid.Empty;
  2342. video.OwnerId = owner.Id;
  2343. SetExtraTypeFromFilename(video);
  2344. return video;
  2345. // Sort them so that the list can be easily compared for changes
  2346. }).OrderBy(i => i.Path);
  2347. }
  2348. public string GetPathAfterNetworkSubstitution(string path, BaseItem ownerItem)
  2349. {
  2350. string newPath;
  2351. if (ownerItem != null)
  2352. {
  2353. var libraryOptions = GetLibraryOptions(ownerItem);
  2354. if (libraryOptions != null)
  2355. {
  2356. foreach (var pathInfo in libraryOptions.PathInfos)
  2357. {
  2358. if (path.TryReplaceSubPath(pathInfo.Path, pathInfo.NetworkPath, out newPath))
  2359. {
  2360. return newPath;
  2361. }
  2362. }
  2363. }
  2364. }
  2365. var metadataPath = _configurationManager.Configuration.MetadataPath;
  2366. var metadataNetworkPath = _configurationManager.Configuration.MetadataNetworkPath;
  2367. if (path.TryReplaceSubPath(metadataPath, metadataNetworkPath, out newPath))
  2368. {
  2369. return newPath;
  2370. }
  2371. foreach (var map in _configurationManager.Configuration.PathSubstitutions)
  2372. {
  2373. if (path.TryReplaceSubPath(map.From, map.To, out newPath))
  2374. {
  2375. return newPath;
  2376. }
  2377. }
  2378. return path;
  2379. }
  2380. public string SubstitutePath(string path, string from, string to)
  2381. {
  2382. if (path.TryReplaceSubPath(from, to, out var newPath))
  2383. {
  2384. return newPath;
  2385. }
  2386. return path;
  2387. }
  2388. private void SetExtraTypeFromFilename(Video item)
  2389. {
  2390. var resolver = new ExtraResolver(GetNamingOptions());
  2391. var result = resolver.GetExtraInfo(item.Path);
  2392. item.ExtraType = result.ExtraType;
  2393. }
  2394. public List<PersonInfo> GetPeople(InternalPeopleQuery query)
  2395. {
  2396. return _itemRepository.GetPeople(query);
  2397. }
  2398. public List<PersonInfo> GetPeople(BaseItem item)
  2399. {
  2400. if (item.SupportsPeople)
  2401. {
  2402. var people = GetPeople(new InternalPeopleQuery
  2403. {
  2404. ItemId = item.Id
  2405. });
  2406. if (people.Count > 0)
  2407. {
  2408. return people;
  2409. }
  2410. }
  2411. return new List<PersonInfo>();
  2412. }
  2413. public List<Person> GetPeopleItems(InternalPeopleQuery query)
  2414. {
  2415. return _itemRepository.GetPeopleNames(query).Select(i =>
  2416. {
  2417. try
  2418. {
  2419. return GetPerson(i);
  2420. }
  2421. catch (Exception ex)
  2422. {
  2423. _logger.LogError(ex, "Error getting person");
  2424. return null;
  2425. }
  2426. }).Where(i => i != null).ToList();
  2427. }
  2428. public List<string> GetPeopleNames(InternalPeopleQuery query)
  2429. {
  2430. return _itemRepository.GetPeopleNames(query);
  2431. }
  2432. public void UpdatePeople(BaseItem item, List<PersonInfo> people)
  2433. {
  2434. UpdatePeopleAsync(item, people, CancellationToken.None).GetAwaiter().GetResult();
  2435. }
  2436. /// <inheritdoc />
  2437. public async Task UpdatePeopleAsync(BaseItem item, List<PersonInfo> people, CancellationToken cancellationToken)
  2438. {
  2439. if (!item.SupportsPeople)
  2440. {
  2441. return;
  2442. }
  2443. _itemRepository.UpdatePeople(item.Id, people);
  2444. await SavePeopleMetadataAsync(people, cancellationToken).ConfigureAwait(false);
  2445. }
  2446. public async Task<ItemImageInfo> ConvertImageToLocal(BaseItem item, ItemImageInfo image, int imageIndex)
  2447. {
  2448. foreach (var url in image.Path.Split('|'))
  2449. {
  2450. try
  2451. {
  2452. _logger.LogDebug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
  2453. await ProviderManager.SaveImage(item, url, image.Type, imageIndex, CancellationToken.None).ConfigureAwait(false);
  2454. await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2455. return item.GetImageInfo(image.Type, imageIndex);
  2456. }
  2457. catch (HttpRequestException ex)
  2458. {
  2459. if (ex.StatusCode.HasValue
  2460. && (ex.StatusCode.Value == HttpStatusCode.NotFound || ex.StatusCode.Value == HttpStatusCode.Forbidden))
  2461. {
  2462. continue;
  2463. }
  2464. throw;
  2465. }
  2466. }
  2467. // Remove this image to prevent it from retrying over and over
  2468. item.RemoveImage(image);
  2469. await item.UpdateToRepositoryAsync(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2470. throw new InvalidOperationException();
  2471. }
  2472. public async Task AddVirtualFolder(string name, CollectionTypeOptions? collectionType, LibraryOptions options, bool refreshLibrary)
  2473. {
  2474. if (string.IsNullOrWhiteSpace(name))
  2475. {
  2476. throw new ArgumentNullException(nameof(name));
  2477. }
  2478. name = _fileSystem.GetValidFilename(name);
  2479. var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  2480. var virtualFolderPath = Path.Combine(rootFolderPath, name);
  2481. while (Directory.Exists(virtualFolderPath))
  2482. {
  2483. name += "1";
  2484. virtualFolderPath = Path.Combine(rootFolderPath, name);
  2485. }
  2486. var mediaPathInfos = options.PathInfos;
  2487. if (mediaPathInfos != null)
  2488. {
  2489. var invalidpath = mediaPathInfos.FirstOrDefault(i => !Directory.Exists(i.Path));
  2490. if (invalidpath != null)
  2491. {
  2492. throw new ArgumentException("The specified path does not exist: " + invalidpath.Path + ".");
  2493. }
  2494. }
  2495. LibraryMonitor.Stop();
  2496. try
  2497. {
  2498. Directory.CreateDirectory(virtualFolderPath);
  2499. if (collectionType != null)
  2500. {
  2501. var path = Path.Combine(virtualFolderPath, collectionType.ToString().ToLowerInvariant() + ".collection");
  2502. File.WriteAllBytes(path, Array.Empty<byte>());
  2503. }
  2504. CollectionFolder.SaveLibraryOptions(virtualFolderPath, options);
  2505. if (mediaPathInfos != null)
  2506. {
  2507. foreach (var path in mediaPathInfos)
  2508. {
  2509. AddMediaPathInternal(name, path, false);
  2510. }
  2511. }
  2512. }
  2513. finally
  2514. {
  2515. if (refreshLibrary)
  2516. {
  2517. await ValidateTopLibraryFolders(CancellationToken.None).ConfigureAwait(false);
  2518. StartScanInBackground();
  2519. }
  2520. else
  2521. {
  2522. // Need to add a delay here or directory watchers may still pick up the changes
  2523. await Task.Delay(1000).ConfigureAwait(false);
  2524. LibraryMonitor.Start();
  2525. }
  2526. }
  2527. }
  2528. private async Task SavePeopleMetadataAsync(IEnumerable<PersonInfo> people, CancellationToken cancellationToken)
  2529. {
  2530. var personsToSave = new List<BaseItem>();
  2531. foreach (var person in people)
  2532. {
  2533. cancellationToken.ThrowIfCancellationRequested();
  2534. var itemUpdateType = ItemUpdateType.MetadataDownload;
  2535. var saveEntity = false;
  2536. var personEntity = GetPerson(person.Name);
  2537. // if PresentationUniqueKey is empty it's likely a new item.
  2538. if (string.IsNullOrEmpty(personEntity.PresentationUniqueKey))
  2539. {
  2540. personEntity.PresentationUniqueKey = personEntity.CreatePresentationUniqueKey();
  2541. saveEntity = true;
  2542. }
  2543. foreach (var id in person.ProviderIds)
  2544. {
  2545. if (!string.Equals(personEntity.GetProviderId(id.Key), id.Value, StringComparison.OrdinalIgnoreCase))
  2546. {
  2547. personEntity.SetProviderId(id.Key, id.Value);
  2548. saveEntity = true;
  2549. }
  2550. }
  2551. if (!string.IsNullOrWhiteSpace(person.ImageUrl) && !personEntity.HasImage(ImageType.Primary))
  2552. {
  2553. personEntity.SetImage(
  2554. new ItemImageInfo
  2555. {
  2556. Path = person.ImageUrl,
  2557. Type = ImageType.Primary
  2558. },
  2559. 0);
  2560. saveEntity = true;
  2561. itemUpdateType = ItemUpdateType.ImageUpdate;
  2562. }
  2563. if (saveEntity)
  2564. {
  2565. personsToSave.Add(personEntity);
  2566. await RunMetadataSavers(personEntity, itemUpdateType).ConfigureAwait(false);
  2567. }
  2568. }
  2569. CreateItems(personsToSave, null, CancellationToken.None);
  2570. }
  2571. private void StartScanInBackground()
  2572. {
  2573. Task.Run(() =>
  2574. {
  2575. // No need to start if scanning the library because it will handle it
  2576. ValidateMediaLibrary(new SimpleProgress<double>(), CancellationToken.None);
  2577. });
  2578. }
  2579. public void AddMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
  2580. {
  2581. AddMediaPathInternal(virtualFolderName, mediaPath, true);
  2582. }
  2583. private void AddMediaPathInternal(string virtualFolderName, MediaPathInfo pathInfo, bool saveLibraryOptions)
  2584. {
  2585. if (pathInfo == null)
  2586. {
  2587. throw new ArgumentNullException(nameof(pathInfo));
  2588. }
  2589. var path = pathInfo.Path;
  2590. if (string.IsNullOrWhiteSpace(path))
  2591. {
  2592. throw new ArgumentException(nameof(path));
  2593. }
  2594. if (!Directory.Exists(path))
  2595. {
  2596. throw new FileNotFoundException("The path does not exist.");
  2597. }
  2598. var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  2599. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2600. var shortcutFilename = Path.GetFileNameWithoutExtension(path);
  2601. var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2602. while (File.Exists(lnk))
  2603. {
  2604. shortcutFilename += "1";
  2605. lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2606. }
  2607. _fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
  2608. RemoveContentTypeOverrides(path);
  2609. if (saveLibraryOptions)
  2610. {
  2611. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2612. var list = libraryOptions.PathInfos.ToList();
  2613. list.Add(pathInfo);
  2614. libraryOptions.PathInfos = list.ToArray();
  2615. SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
  2616. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2617. }
  2618. }
  2619. public void UpdateMediaPath(string virtualFolderName, MediaPathInfo mediaPath)
  2620. {
  2621. if (mediaPath == null)
  2622. {
  2623. throw new ArgumentNullException(nameof(mediaPath));
  2624. }
  2625. var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  2626. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2627. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2628. SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
  2629. var list = libraryOptions.PathInfos.ToList();
  2630. foreach (var originalPathInfo in list)
  2631. {
  2632. if (string.Equals(mediaPath.Path, originalPathInfo.Path, StringComparison.Ordinal))
  2633. {
  2634. originalPathInfo.NetworkPath = mediaPath.NetworkPath;
  2635. break;
  2636. }
  2637. }
  2638. libraryOptions.PathInfos = list.ToArray();
  2639. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2640. }
  2641. private void SyncLibraryOptionsToLocations(string virtualFolderPath, LibraryOptions options)
  2642. {
  2643. var topLibraryFolders = GetUserRootFolder().Children.ToList();
  2644. var info = GetVirtualFolderInfo(virtualFolderPath, topLibraryFolders, null);
  2645. if (info.Locations.Length > 0 && info.Locations.Length != options.PathInfos.Length)
  2646. {
  2647. var list = options.PathInfos.ToList();
  2648. foreach (var location in info.Locations)
  2649. {
  2650. if (!list.Any(i => string.Equals(i.Path, location, StringComparison.Ordinal)))
  2651. {
  2652. list.Add(new MediaPathInfo(location));
  2653. }
  2654. }
  2655. options.PathInfos = list.ToArray();
  2656. }
  2657. }
  2658. public async Task RemoveVirtualFolder(string name, bool refreshLibrary)
  2659. {
  2660. if (string.IsNullOrWhiteSpace(name))
  2661. {
  2662. throw new ArgumentNullException(nameof(name));
  2663. }
  2664. var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  2665. var path = Path.Combine(rootFolderPath, name);
  2666. if (!Directory.Exists(path))
  2667. {
  2668. throw new FileNotFoundException("The media folder does not exist");
  2669. }
  2670. LibraryMonitor.Stop();
  2671. try
  2672. {
  2673. Directory.Delete(path, true);
  2674. }
  2675. finally
  2676. {
  2677. CollectionFolder.OnCollectionFolderChange();
  2678. if (refreshLibrary)
  2679. {
  2680. await ValidateTopLibraryFolders(CancellationToken.None).ConfigureAwait(false);
  2681. StartScanInBackground();
  2682. }
  2683. else
  2684. {
  2685. // Need to add a delay here or directory watchers may still pick up the changes
  2686. await Task.Delay(1000).ConfigureAwait(false);
  2687. LibraryMonitor.Start();
  2688. }
  2689. }
  2690. }
  2691. private void RemoveContentTypeOverrides(string path)
  2692. {
  2693. if (string.IsNullOrWhiteSpace(path))
  2694. {
  2695. throw new ArgumentNullException(nameof(path));
  2696. }
  2697. var removeList = new List<NameValuePair>();
  2698. foreach (var contentType in _configurationManager.Configuration.ContentTypes)
  2699. {
  2700. if (string.IsNullOrWhiteSpace(contentType.Name))
  2701. {
  2702. removeList.Add(contentType);
  2703. }
  2704. else if (_fileSystem.AreEqual(path, contentType.Name)
  2705. || _fileSystem.ContainsSubPath(path, contentType.Name))
  2706. {
  2707. removeList.Add(contentType);
  2708. }
  2709. }
  2710. if (removeList.Count > 0)
  2711. {
  2712. _configurationManager.Configuration.ContentTypes = _configurationManager.Configuration.ContentTypes
  2713. .Except(removeList)
  2714. .ToArray();
  2715. _configurationManager.SaveConfiguration();
  2716. }
  2717. }
  2718. public void RemoveMediaPath(string virtualFolderName, string mediaPath)
  2719. {
  2720. if (string.IsNullOrEmpty(mediaPath))
  2721. {
  2722. throw new ArgumentNullException(nameof(mediaPath));
  2723. }
  2724. var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
  2725. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2726. if (!Directory.Exists(virtualFolderPath))
  2727. {
  2728. throw new FileNotFoundException(
  2729. string.Format(CultureInfo.InvariantCulture, "The media collection {0} does not exist", virtualFolderName));
  2730. }
  2731. var shortcut = _fileSystem.GetFilePaths(virtualFolderPath, true)
  2732. .Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
  2733. .FirstOrDefault(f => _appHost.ExpandVirtualPath(_fileSystem.ResolveShortcut(f)).Equals(mediaPath, StringComparison.OrdinalIgnoreCase));
  2734. if (!string.IsNullOrEmpty(shortcut))
  2735. {
  2736. _fileSystem.DeleteFile(shortcut);
  2737. }
  2738. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2739. libraryOptions.PathInfos = libraryOptions
  2740. .PathInfos
  2741. .Where(i => !string.Equals(i.Path, mediaPath, StringComparison.Ordinal))
  2742. .ToArray();
  2743. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2744. }
  2745. }
  2746. }