LibraryManager.cs 98 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844
  1. using Interfaces.IO;
  2. using MediaBrowser.Common.Extensions;
  3. using MediaBrowser.Common.Progress;
  4. using MediaBrowser.Common.ScheduledTasks;
  5. using MediaBrowser.Controller.Configuration;
  6. using MediaBrowser.Controller.Entities;
  7. using MediaBrowser.Controller.Entities.Audio;
  8. using MediaBrowser.Controller.Entities.TV;
  9. using MediaBrowser.Controller.IO;
  10. using MediaBrowser.Controller.Library;
  11. using MediaBrowser.Controller.Persistence;
  12. using MediaBrowser.Controller.Providers;
  13. using MediaBrowser.Controller.Resolvers;
  14. using MediaBrowser.Controller.Sorting;
  15. using MediaBrowser.Model.Configuration;
  16. using MediaBrowser.Model.Entities;
  17. using MediaBrowser.Model.Logging;
  18. using MediaBrowser.Model.Querying;
  19. using MediaBrowser.Naming.Audio;
  20. using MediaBrowser.Naming.Common;
  21. using MediaBrowser.Naming.TV;
  22. using MediaBrowser.Naming.Video;
  23. using MediaBrowser.Server.Implementations.Library.Validators;
  24. using MediaBrowser.Server.Implementations.Logging;
  25. using MediaBrowser.Server.Implementations.ScheduledTasks;
  26. using System;
  27. using System.Collections.Concurrent;
  28. using System.Collections.Generic;
  29. using System.Globalization;
  30. using System.IO;
  31. using System.Linq;
  32. using System.Net;
  33. using System.Threading;
  34. using System.Threading.Tasks;
  35. using CommonIO;
  36. using MediaBrowser.Model.Dto;
  37. using MediaBrowser.Model.Extensions;
  38. using MediaBrowser.Model.Library;
  39. using MediaBrowser.Model.Net;
  40. using MediaBrowser.Server.Implementations.Library.Resolvers;
  41. using MoreLinq;
  42. using SortOrder = MediaBrowser.Model.Entities.SortOrder;
  43. using VideoResolver = MediaBrowser.Naming.Video.VideoResolver;
  44. namespace MediaBrowser.Server.Implementations.Library
  45. {
  46. /// <summary>
  47. /// Class LibraryManager
  48. /// </summary>
  49. public class LibraryManager : ILibraryManager
  50. {
  51. /// <summary>
  52. /// Gets or sets the postscan tasks.
  53. /// </summary>
  54. /// <value>The postscan tasks.</value>
  55. private ILibraryPostScanTask[] PostscanTasks { get; set; }
  56. /// <summary>
  57. /// Gets the intro providers.
  58. /// </summary>
  59. /// <value>The intro providers.</value>
  60. private IIntroProvider[] IntroProviders { get; set; }
  61. /// <summary>
  62. /// Gets the list of entity resolution ignore rules
  63. /// </summary>
  64. /// <value>The entity resolution ignore rules.</value>
  65. private IResolverIgnoreRule[] EntityResolutionIgnoreRules { get; set; }
  66. /// <summary>
  67. /// Gets the list of BasePluginFolders added by plugins
  68. /// </summary>
  69. /// <value>The plugin folders.</value>
  70. private IVirtualFolderCreator[] PluginFolderCreators { get; set; }
  71. /// <summary>
  72. /// Gets the list of currently registered entity resolvers
  73. /// </summary>
  74. /// <value>The entity resolvers enumerable.</value>
  75. private IItemResolver[] EntityResolvers { get; set; }
  76. private IMultiItemResolver[] MultiItemResolvers { get; set; }
  77. /// <summary>
  78. /// Gets or sets the comparers.
  79. /// </summary>
  80. /// <value>The comparers.</value>
  81. private IBaseItemComparer[] Comparers { get; set; }
  82. /// <summary>
  83. /// Gets the active item repository
  84. /// </summary>
  85. /// <value>The item repository.</value>
  86. public IItemRepository ItemRepository { get; set; }
  87. /// <summary>
  88. /// Occurs when [item added].
  89. /// </summary>
  90. public event EventHandler<ItemChangeEventArgs> ItemAdded;
  91. /// <summary>
  92. /// Occurs when [item updated].
  93. /// </summary>
  94. public event EventHandler<ItemChangeEventArgs> ItemUpdated;
  95. /// <summary>
  96. /// Occurs when [item removed].
  97. /// </summary>
  98. public event EventHandler<ItemChangeEventArgs> ItemRemoved;
  99. /// <summary>
  100. /// The _logger
  101. /// </summary>
  102. private readonly ILogger _logger;
  103. /// <summary>
  104. /// The _task manager
  105. /// </summary>
  106. private readonly ITaskManager _taskManager;
  107. /// <summary>
  108. /// The _user manager
  109. /// </summary>
  110. private readonly IUserManager _userManager;
  111. /// <summary>
  112. /// The _user data repository
  113. /// </summary>
  114. private readonly IUserDataManager _userDataRepository;
  115. /// <summary>
  116. /// Gets or sets the configuration manager.
  117. /// </summary>
  118. /// <value>The configuration manager.</value>
  119. private IServerConfigurationManager ConfigurationManager { get; set; }
  120. /// <summary>
  121. /// A collection of items that may be referenced from multiple physical places in the library
  122. /// (typically, multiple user roots). We store them here and be sure they all reference a
  123. /// single instance.
  124. /// </summary>
  125. /// <value>The by reference items.</value>
  126. private ConcurrentDictionary<Guid, BaseItem> ByReferenceItems { get; set; }
  127. private readonly Func<ILibraryMonitor> _libraryMonitorFactory;
  128. private readonly Func<IProviderManager> _providerManagerFactory;
  129. private readonly Func<IUserViewManager> _userviewManager;
  130. public bool IsScanRunning { get; private set; }
  131. /// <summary>
  132. /// The _library items cache
  133. /// </summary>
  134. private readonly ConcurrentDictionary<Guid, BaseItem> _libraryItemsCache;
  135. /// <summary>
  136. /// Gets the library items cache.
  137. /// </summary>
  138. /// <value>The library items cache.</value>
  139. private ConcurrentDictionary<Guid, BaseItem> LibraryItemsCache
  140. {
  141. get
  142. {
  143. return _libraryItemsCache;
  144. }
  145. }
  146. private readonly IFileSystem _fileSystem;
  147. /// <summary>
  148. /// Initializes a new instance of the <see cref="LibraryManager" /> class.
  149. /// </summary>
  150. /// <param name="logger">The logger.</param>
  151. /// <param name="taskManager">The task manager.</param>
  152. /// <param name="userManager">The user manager.</param>
  153. /// <param name="configurationManager">The configuration manager.</param>
  154. /// <param name="userDataRepository">The user data repository.</param>
  155. public LibraryManager(ILogger logger, ITaskManager taskManager, IUserManager userManager, IServerConfigurationManager configurationManager, IUserDataManager userDataRepository, Func<ILibraryMonitor> libraryMonitorFactory, IFileSystem fileSystem, Func<IProviderManager> providerManagerFactory, Func<IUserViewManager> userviewManager)
  156. {
  157. _logger = logger;
  158. _taskManager = taskManager;
  159. _userManager = userManager;
  160. ConfigurationManager = configurationManager;
  161. _userDataRepository = userDataRepository;
  162. _libraryMonitorFactory = libraryMonitorFactory;
  163. _fileSystem = fileSystem;
  164. _providerManagerFactory = providerManagerFactory;
  165. _userviewManager = userviewManager;
  166. ByReferenceItems = new ConcurrentDictionary<Guid, BaseItem>();
  167. _libraryItemsCache = new ConcurrentDictionary<Guid, BaseItem>();
  168. ConfigurationManager.ConfigurationUpdated += ConfigurationUpdated;
  169. RecordConfigurationValues(configurationManager.Configuration);
  170. }
  171. /// <summary>
  172. /// Adds the parts.
  173. /// </summary>
  174. /// <param name="rules">The rules.</param>
  175. /// <param name="pluginFolders">The plugin folders.</param>
  176. /// <param name="resolvers">The resolvers.</param>
  177. /// <param name="introProviders">The intro providers.</param>
  178. /// <param name="itemComparers">The item comparers.</param>
  179. /// <param name="postscanTasks">The postscan tasks.</param>
  180. public void AddParts(IEnumerable<IResolverIgnoreRule> rules,
  181. IEnumerable<IVirtualFolderCreator> pluginFolders,
  182. IEnumerable<IItemResolver> resolvers,
  183. IEnumerable<IIntroProvider> introProviders,
  184. IEnumerable<IBaseItemComparer> itemComparers,
  185. IEnumerable<ILibraryPostScanTask> postscanTasks)
  186. {
  187. EntityResolutionIgnoreRules = rules.ToArray();
  188. PluginFolderCreators = pluginFolders.ToArray();
  189. EntityResolvers = resolvers.OrderBy(i => i.Priority).ToArray();
  190. MultiItemResolvers = EntityResolvers.OfType<IMultiItemResolver>().ToArray();
  191. IntroProviders = introProviders.ToArray();
  192. Comparers = itemComparers.ToArray();
  193. PostscanTasks = postscanTasks.OrderBy(i =>
  194. {
  195. var hasOrder = i as IHasOrder;
  196. return hasOrder == null ? 0 : hasOrder.Order;
  197. }).ToArray();
  198. }
  199. /// <summary>
  200. /// The _root folder
  201. /// </summary>
  202. private volatile AggregateFolder _rootFolder;
  203. /// <summary>
  204. /// The _root folder sync lock
  205. /// </summary>
  206. private readonly object _rootFolderSyncLock = new object();
  207. /// <summary>
  208. /// Gets the root folder.
  209. /// </summary>
  210. /// <value>The root folder.</value>
  211. public AggregateFolder RootFolder
  212. {
  213. get
  214. {
  215. if (_rootFolder == null)
  216. {
  217. lock (_rootFolderSyncLock)
  218. {
  219. if (_rootFolder == null)
  220. {
  221. _rootFolder = CreateRootFolder();
  222. }
  223. }
  224. }
  225. return _rootFolder;
  226. }
  227. }
  228. /// <summary>
  229. /// The _season zero display name
  230. /// </summary>
  231. private string _seasonZeroDisplayName;
  232. private bool _wizardCompleted;
  233. /// <summary>
  234. /// Records the configuration values.
  235. /// </summary>
  236. /// <param name="configuration">The configuration.</param>
  237. private void RecordConfigurationValues(ServerConfiguration configuration)
  238. {
  239. _seasonZeroDisplayName = configuration.SeasonZeroDisplayName;
  240. _wizardCompleted = configuration.IsStartupWizardCompleted;
  241. }
  242. /// <summary>
  243. /// Configurations the updated.
  244. /// </summary>
  245. /// <param name="sender">The sender.</param>
  246. /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
  247. void ConfigurationUpdated(object sender, EventArgs e)
  248. {
  249. var config = ConfigurationManager.Configuration;
  250. var newSeasonZeroName = ConfigurationManager.Configuration.SeasonZeroDisplayName;
  251. var seasonZeroNameChanged = !string.Equals(_seasonZeroDisplayName, newSeasonZeroName, StringComparison.Ordinal);
  252. var wizardChanged = config.IsStartupWizardCompleted != _wizardCompleted;
  253. RecordConfigurationValues(config);
  254. if (seasonZeroNameChanged || wizardChanged)
  255. {
  256. _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
  257. }
  258. if (seasonZeroNameChanged)
  259. {
  260. Task.Run(async () =>
  261. {
  262. await UpdateSeasonZeroNames(newSeasonZeroName, CancellationToken.None).ConfigureAwait(false);
  263. });
  264. }
  265. }
  266. /// <summary>
  267. /// Updates the season zero names.
  268. /// </summary>
  269. /// <param name="newName">The new name.</param>
  270. /// <param name="cancellationToken">The cancellation token.</param>
  271. /// <returns>Task.</returns>
  272. private async Task UpdateSeasonZeroNames(string newName, CancellationToken cancellationToken)
  273. {
  274. var seasons = GetItemList(new InternalItemsQuery
  275. {
  276. IncludeItemTypes = new[] { typeof(Season).Name },
  277. Recursive = true,
  278. IndexNumber = 0
  279. }).Cast<Season>()
  280. .Where(i => !string.Equals(i.Name, newName, StringComparison.Ordinal))
  281. .ToList();
  282. foreach (var season in seasons)
  283. {
  284. season.Name = newName;
  285. try
  286. {
  287. await UpdateItem(season, ItemUpdateType.MetadataDownload, cancellationToken).ConfigureAwait(false);
  288. }
  289. catch (Exception ex)
  290. {
  291. _logger.ErrorException("Error saving {0}", ex, season.Path);
  292. }
  293. }
  294. }
  295. /// <summary>
  296. /// Updates the item in library cache.
  297. /// </summary>
  298. /// <param name="item">The item.</param>
  299. private void UpdateItemInLibraryCache(BaseItem item)
  300. {
  301. RegisterItem(item);
  302. }
  303. public void RegisterItem(BaseItem item)
  304. {
  305. if (item == null)
  306. {
  307. throw new ArgumentNullException("item");
  308. }
  309. RegisterItem(item.Id, item);
  310. }
  311. private void RegisterItem(Guid id, BaseItem item)
  312. {
  313. if (item.SourceType != SourceType.Library)
  314. {
  315. return;
  316. }
  317. if (item is IItemByName)
  318. {
  319. if (!(item is MusicArtist))
  320. {
  321. return;
  322. }
  323. }
  324. if (item is Photo)
  325. {
  326. return;
  327. }
  328. //if (!(item is Folder))
  329. //{
  330. // return;
  331. //}
  332. LibraryItemsCache.AddOrUpdate(id, item, delegate { return item; });
  333. }
  334. public async Task DeleteItem(BaseItem item, DeleteOptions options)
  335. {
  336. if (item == null)
  337. {
  338. throw new ArgumentNullException("item");
  339. }
  340. _logger.Debug("Deleting item, Type: {0}, Name: {1}, Path: {2}, Id: {3}",
  341. item.GetType().Name,
  342. item.Name ?? "Unknown name",
  343. item.Path ?? string.Empty,
  344. item.Id);
  345. var parent = item.Parent;
  346. var locationType = item.LocationType;
  347. var children = item.IsFolder
  348. ? ((Folder)item).GetRecursiveChildren().ToList()
  349. : new List<BaseItem>();
  350. foreach (var metadataPath in GetMetadataPaths(item, children))
  351. {
  352. _logger.Debug("Deleting path {0}", metadataPath);
  353. try
  354. {
  355. _fileSystem.DeleteDirectory(metadataPath, true);
  356. }
  357. catch (DirectoryNotFoundException)
  358. {
  359. }
  360. catch (Exception ex)
  361. {
  362. _logger.ErrorException("Error deleting {0}", ex, metadataPath);
  363. }
  364. }
  365. if (options.DeleteFileLocation && locationType != LocationType.Remote && locationType != LocationType.Virtual)
  366. {
  367. foreach (var path in item.GetDeletePaths().ToList())
  368. {
  369. if (_fileSystem.DirectoryExists(path))
  370. {
  371. _logger.Debug("Deleting path {0}", path);
  372. _fileSystem.DeleteDirectory(path, true);
  373. }
  374. else if (_fileSystem.FileExists(path))
  375. {
  376. _logger.Debug("Deleting path {0}", path);
  377. _fileSystem.DeleteFile(path);
  378. }
  379. }
  380. if (parent != null)
  381. {
  382. await parent.ValidateChildren(new Progress<double>(), CancellationToken.None)
  383. .ConfigureAwait(false);
  384. }
  385. }
  386. else if (parent != null)
  387. {
  388. parent.RemoveChild(item);
  389. }
  390. await ItemRepository.DeleteItem(item.Id, CancellationToken.None).ConfigureAwait(false);
  391. foreach (var child in children)
  392. {
  393. await ItemRepository.DeleteItem(child.Id, CancellationToken.None).ConfigureAwait(false);
  394. }
  395. BaseItem removed;
  396. _libraryItemsCache.TryRemove(item.Id, out removed);
  397. ReportItemRemoved(item);
  398. }
  399. private 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.ErrorException("Error in {0} resolving {1}", ex, resolver.GetType().Name, args.Path);
  433. return null;
  434. }
  435. }
  436. public Guid GetNewItemId(string key, Type type)
  437. {
  438. if (string.IsNullOrWhiteSpace(key))
  439. {
  440. throw new ArgumentNullException("key");
  441. }
  442. if (type == null)
  443. {
  444. throw new ArgumentNullException("type");
  445. }
  446. if (ConfigurationManager.Configuration.EnableLocalizedGuids && key.StartsWith(ConfigurationManager.ApplicationPaths.ProgramDataPath))
  447. {
  448. // Try to normalize paths located underneath program-data in an attempt to make them more portable
  449. key = key.Substring(ConfigurationManager.ApplicationPaths.ProgramDataPath.Length)
  450. .TrimStart(new[] { '/', '\\' })
  451. .Replace("/", "\\");
  452. }
  453. if (!ConfigurationManager.Configuration.EnableCaseSensitiveItemIds)
  454. {
  455. key = key.ToLower();
  456. }
  457. key = type.FullName + key;
  458. return key.GetMD5();
  459. }
  460. public IEnumerable<BaseItem> ReplaceVideosWithPrimaryVersions(IEnumerable<BaseItem> items)
  461. {
  462. if (items == null)
  463. {
  464. throw new ArgumentNullException("items");
  465. }
  466. return items.DistinctBy(i => i.PresentationUniqueKey, StringComparer.OrdinalIgnoreCase);
  467. }
  468. /// <summary>
  469. /// Ensure supplied item has only one instance throughout
  470. /// </summary>
  471. /// <param name="item">The item.</param>
  472. /// <returns>The proper instance to the item</returns>
  473. public BaseItem GetOrAddByReferenceItem(BaseItem item)
  474. {
  475. // Add this item to our list if not there already
  476. if (!ByReferenceItems.TryAdd(item.Id, item))
  477. {
  478. // Already there - return the existing reference
  479. item = ByReferenceItems[item.Id];
  480. }
  481. return item;
  482. }
  483. public BaseItem ResolvePath(FileSystemMetadata fileInfo,
  484. Folder parent = null)
  485. {
  486. return ResolvePath(fileInfo, new DirectoryService(_logger, _fileSystem), null, parent);
  487. }
  488. private BaseItem ResolvePath(FileSystemMetadata fileInfo, IDirectoryService directoryService, IItemResolver[] resolvers, Folder parent = null, string collectionType = null)
  489. {
  490. if (fileInfo == null)
  491. {
  492. throw new ArgumentNullException("fileInfo");
  493. }
  494. var fullPath = fileInfo.FullName;
  495. if (string.IsNullOrWhiteSpace(collectionType) && parent != null)
  496. {
  497. collectionType = GetContentTypeOverride(fullPath, true);
  498. }
  499. var args = new ItemResolveArgs(ConfigurationManager.ApplicationPaths, directoryService)
  500. {
  501. Parent = parent,
  502. Path = fullPath,
  503. FileInfo = fileInfo,
  504. CollectionType = collectionType
  505. };
  506. // Return null if ignore rules deem that we should do so
  507. if (IgnoreFile(args.FileInfo, args.Parent))
  508. {
  509. return null;
  510. }
  511. // Gather child folder and files
  512. if (args.IsDirectory)
  513. {
  514. var isPhysicalRoot = args.IsPhysicalRoot;
  515. // When resolving the root, we need it's grandchildren (children of user views)
  516. var flattenFolderDepth = isPhysicalRoot ? 2 : 0;
  517. var fileSystemDictionary = FileData.GetFilteredFileSystemEntries(directoryService, args.Path, _fileSystem, _logger, args, flattenFolderDepth: flattenFolderDepth, resolveShortcuts: isPhysicalRoot || args.IsVf);
  518. // Need to remove subpaths that may have been resolved from shortcuts
  519. // Example: if \\server\movies exists, then strip out \\server\movies\action
  520. if (isPhysicalRoot)
  521. {
  522. var paths = NormalizeRootPathList(fileSystemDictionary.Values);
  523. fileSystemDictionary = paths.ToDictionary(i => i.FullName);
  524. }
  525. args.FileSystemDictionary = fileSystemDictionary;
  526. }
  527. // Check to see if we should resolve based on our contents
  528. if (args.IsDirectory && !ShouldResolvePathContents(args))
  529. {
  530. return null;
  531. }
  532. return ResolveItem(args, resolvers);
  533. }
  534. public bool IgnoreFile(FileSystemMetadata file, BaseItem parent)
  535. {
  536. return EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(file, parent));
  537. }
  538. public IEnumerable<FileSystemMetadata> NormalizeRootPathList(IEnumerable<FileSystemMetadata> paths)
  539. {
  540. var originalList = paths.ToList();
  541. var list = originalList.Where(i => i.IsDirectory)
  542. .Select(i => _fileSystem.NormalizePath(i.FullName))
  543. .Distinct(StringComparer.OrdinalIgnoreCase)
  544. .ToList();
  545. var dupes = list.Where(subPath => !subPath.EndsWith(":\\", StringComparison.OrdinalIgnoreCase) && list.Any(i => _fileSystem.ContainsSubPath(i, subPath)))
  546. .ToList();
  547. foreach (var dupe in dupes)
  548. {
  549. _logger.Info("Found duplicate path: {0}", dupe);
  550. }
  551. var newList = list.Except(dupes, StringComparer.OrdinalIgnoreCase).Select(_fileSystem.GetDirectoryInfo).ToList();
  552. newList.AddRange(originalList.Where(i => !i.IsDirectory));
  553. return newList;
  554. }
  555. /// <summary>
  556. /// Determines whether a path should be ignored based on its contents - called after the contents have been read
  557. /// </summary>
  558. /// <param name="args">The args.</param>
  559. /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
  560. private static bool ShouldResolvePathContents(ItemResolveArgs args)
  561. {
  562. // Ignore any folders containing a file called .ignore
  563. return !args.ContainsFileSystemEntryByName(".ignore");
  564. }
  565. public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryService, Folder parent, string collectionType)
  566. {
  567. return ResolvePaths(files, directoryService, parent, collectionType, EntityResolvers);
  568. }
  569. public IEnumerable<BaseItem> ResolvePaths(IEnumerable<FileSystemMetadata> files, IDirectoryService directoryService, Folder parent, string collectionType, IItemResolver[] resolvers)
  570. {
  571. var fileList = files.Where(i => !IgnoreFile(i, parent)).ToList();
  572. if (parent != null)
  573. {
  574. var multiItemResolvers = resolvers == null ? MultiItemResolvers : resolvers.OfType<IMultiItemResolver>().ToArray();
  575. foreach (var resolver in multiItemResolvers)
  576. {
  577. var result = resolver.ResolveMultiple(parent, fileList, collectionType, directoryService);
  578. if (result != null && result.Items.Count > 0)
  579. {
  580. var items = new List<BaseItem>();
  581. items.AddRange(result.Items);
  582. foreach (var item in items)
  583. {
  584. ResolverHelper.SetInitialItemValues(item, parent, _fileSystem, this, directoryService);
  585. }
  586. items.AddRange(ResolveFileList(result.ExtraFiles, directoryService, parent, collectionType, resolvers));
  587. return items;
  588. }
  589. }
  590. }
  591. return ResolveFileList(fileList, directoryService, parent, collectionType, resolvers);
  592. }
  593. private IEnumerable<BaseItem> ResolveFileList(IEnumerable<FileSystemMetadata> fileList, IDirectoryService directoryService, Folder parent, string collectionType, IItemResolver[] resolvers)
  594. {
  595. return fileList.Select(f =>
  596. {
  597. try
  598. {
  599. return ResolvePath(f, directoryService, resolvers, parent, collectionType);
  600. }
  601. catch (Exception ex)
  602. {
  603. _logger.ErrorException("Error resolving path {0}", ex, f.FullName);
  604. return null;
  605. }
  606. }).Where(i => i != null);
  607. }
  608. /// <summary>
  609. /// Creates the root media folder
  610. /// </summary>
  611. /// <returns>AggregateFolder.</returns>
  612. /// <exception cref="System.InvalidOperationException">Cannot create the root folder until plugins have loaded</exception>
  613. public AggregateFolder CreateRootFolder()
  614. {
  615. var rootFolderPath = ConfigurationManager.ApplicationPaths.RootFolderPath;
  616. _fileSystem.CreateDirectory(rootFolderPath);
  617. var rootFolder = GetItemById(GetNewItemId(rootFolderPath, typeof(AggregateFolder))) as AggregateFolder ?? (AggregateFolder)ResolvePath(_fileSystem.GetDirectoryInfo(rootFolderPath));
  618. // Add in the plug-in folders
  619. foreach (var child in PluginFolderCreators)
  620. {
  621. var folder = child.GetFolder();
  622. if (folder != null)
  623. {
  624. if (folder.Id == Guid.Empty)
  625. {
  626. if (string.IsNullOrWhiteSpace(folder.Path))
  627. {
  628. folder.Id = GetNewItemId(folder.GetType().Name, folder.GetType());
  629. }
  630. else
  631. {
  632. folder.Id = GetNewItemId(folder.Path, folder.GetType());
  633. }
  634. }
  635. var dbItem = GetItemById(folder.Id) as BasePluginFolder;
  636. if (dbItem != null && string.Equals(dbItem.Path, folder.Path, StringComparison.OrdinalIgnoreCase))
  637. {
  638. folder = dbItem;
  639. }
  640. if (folder.ParentId != rootFolder.Id)
  641. {
  642. folder.ParentId = rootFolder.Id;
  643. var task = folder.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None);
  644. Task.WaitAll(task);
  645. }
  646. rootFolder.AddVirtualChild(folder);
  647. RegisterItem(folder);
  648. }
  649. }
  650. return rootFolder;
  651. }
  652. private volatile UserRootFolder _userRootFolder;
  653. private readonly object _syncLock = new object();
  654. public Folder GetUserRootFolder()
  655. {
  656. if (_userRootFolder == null)
  657. {
  658. lock (_syncLock)
  659. {
  660. if (_userRootFolder == null)
  661. {
  662. var userRootPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  663. _fileSystem.CreateDirectory(userRootPath);
  664. var tmpItem = GetItemById(GetNewItemId(userRootPath, typeof(UserRootFolder))) as UserRootFolder;
  665. if (tmpItem == null)
  666. {
  667. tmpItem = (UserRootFolder)ResolvePath(_fileSystem.GetDirectoryInfo(userRootPath));
  668. }
  669. _userRootFolder = tmpItem;
  670. }
  671. }
  672. }
  673. return _userRootFolder;
  674. }
  675. public BaseItem FindByPath(string path, bool? isFolder)
  676. {
  677. var query = new InternalItemsQuery
  678. {
  679. Path = path,
  680. IsFolder = isFolder
  681. };
  682. // If this returns multiple items it could be tricky figuring out which one is correct.
  683. // In most cases, the newest one will be and the others obsolete but not yet cleaned up
  684. return GetItemIds(query)
  685. .Select(GetItemById)
  686. .Where(i => i != null)
  687. .OrderByDescending(i => i.DateCreated)
  688. .FirstOrDefault();
  689. }
  690. /// <summary>
  691. /// Gets a Person
  692. /// </summary>
  693. /// <param name="name">The name.</param>
  694. /// <returns>Task{Person}.</returns>
  695. public Person GetPerson(string name)
  696. {
  697. return GetItemByName<Person>(ConfigurationManager.ApplicationPaths.PeoplePath, name);
  698. }
  699. /// <summary>
  700. /// Gets a Studio
  701. /// </summary>
  702. /// <param name="name">The name.</param>
  703. /// <returns>Task{Studio}.</returns>
  704. public Studio GetStudio(string name)
  705. {
  706. return GetItemByName<Studio>(ConfigurationManager.ApplicationPaths.StudioPath, name);
  707. }
  708. /// <summary>
  709. /// Gets a Genre
  710. /// </summary>
  711. /// <param name="name">The name.</param>
  712. /// <returns>Task{Genre}.</returns>
  713. public Genre GetGenre(string name)
  714. {
  715. return GetItemByName<Genre>(ConfigurationManager.ApplicationPaths.GenrePath, name);
  716. }
  717. /// <summary>
  718. /// Gets the genre.
  719. /// </summary>
  720. /// <param name="name">The name.</param>
  721. /// <returns>Task{MusicGenre}.</returns>
  722. public MusicGenre GetMusicGenre(string name)
  723. {
  724. return GetItemByName<MusicGenre>(ConfigurationManager.ApplicationPaths.MusicGenrePath, name);
  725. }
  726. /// <summary>
  727. /// Gets the game genre.
  728. /// </summary>
  729. /// <param name="name">The name.</param>
  730. /// <returns>Task{GameGenre}.</returns>
  731. public GameGenre GetGameGenre(string name)
  732. {
  733. return GetItemByName<GameGenre>(ConfigurationManager.ApplicationPaths.GameGenrePath, name);
  734. }
  735. /// <summary>
  736. /// The us culture
  737. /// </summary>
  738. private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
  739. /// <summary>
  740. /// Gets a Year
  741. /// </summary>
  742. /// <param name="value">The value.</param>
  743. /// <returns>Task{Year}.</returns>
  744. /// <exception cref="System.ArgumentOutOfRangeException"></exception>
  745. public Year GetYear(int value)
  746. {
  747. if (value <= 0)
  748. {
  749. throw new ArgumentOutOfRangeException("Years less than or equal to 0 are invalid.");
  750. }
  751. return GetItemByName<Year>(ConfigurationManager.ApplicationPaths.YearPath, value.ToString(UsCulture));
  752. }
  753. /// <summary>
  754. /// Gets the artists path.
  755. /// </summary>
  756. /// <value>The artists path.</value>
  757. public string ArtistsPath
  758. {
  759. get
  760. {
  761. return Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "artists");
  762. }
  763. }
  764. /// <summary>
  765. /// Gets a Genre
  766. /// </summary>
  767. /// <param name="name">The name.</param>
  768. /// <returns>Task{Genre}.</returns>
  769. public MusicArtist GetArtist(string name)
  770. {
  771. return GetItemByName<MusicArtist>(ArtistsPath, name);
  772. }
  773. private T GetItemByName<T>(string path, string name)
  774. where T : BaseItem, new()
  775. {
  776. if (string.IsNullOrWhiteSpace(path))
  777. {
  778. throw new ArgumentNullException("path");
  779. }
  780. if (string.IsNullOrWhiteSpace(name))
  781. {
  782. throw new ArgumentNullException("name");
  783. }
  784. // Trim the period at the end because windows will have a hard time with that
  785. var validFilename = _fileSystem.GetValidFilename(name)
  786. .Trim()
  787. .TrimEnd('.');
  788. string subFolderPrefix = null;
  789. var type = typeof(T);
  790. if (type == typeof(Person))
  791. {
  792. var subFolderIndex = 0;
  793. while (!char.IsLetterOrDigit(validFilename[subFolderIndex]))
  794. {
  795. subFolderIndex++;
  796. }
  797. subFolderPrefix = validFilename.Substring(subFolderIndex, 1);
  798. }
  799. var fullPath = string.IsNullOrEmpty(subFolderPrefix) ?
  800. Path.Combine(path, validFilename) :
  801. Path.Combine(path, subFolderPrefix, validFilename);
  802. return CreateItemByName<T>(fullPath, name);
  803. }
  804. private T CreateItemByName<T>(string path, string name)
  805. where T : BaseItem, new()
  806. {
  807. if (typeof(T) == typeof(MusicArtist))
  808. {
  809. var existing = GetItemList(new InternalItemsQuery
  810. {
  811. IncludeItemTypes = new[] { typeof(T).Name },
  812. Name = name
  813. }).Cast<MusicArtist>()
  814. .OrderBy(i => i.IsAccessedByName ? 1 : 0)
  815. .Cast<T>()
  816. .FirstOrDefault();
  817. if (existing != null)
  818. {
  819. return existing;
  820. }
  821. }
  822. var id = GetNewItemId(path, typeof(T));
  823. var item = GetItemById(id) as T;
  824. if (item == null)
  825. {
  826. item = new T
  827. {
  828. Name = name,
  829. Id = id,
  830. DateCreated = DateTime.UtcNow,
  831. DateModified = DateTime.UtcNow,
  832. Path = path
  833. };
  834. var task = CreateItem(item, CancellationToken.None);
  835. Task.WaitAll(task);
  836. }
  837. return item;
  838. }
  839. public IEnumerable<MusicArtist> GetAlbumArtists(IEnumerable<IHasAlbumArtist> items)
  840. {
  841. var names = items
  842. .SelectMany(i => i.AlbumArtists)
  843. .DistinctNames()
  844. .Select(i =>
  845. {
  846. try
  847. {
  848. var artist = GetArtist(i);
  849. return artist;
  850. }
  851. catch
  852. {
  853. // Already logged at lower levels
  854. return null;
  855. }
  856. })
  857. .Where(i => i != null);
  858. return names;
  859. }
  860. public IEnumerable<MusicArtist> GetArtists(IEnumerable<IHasArtist> items)
  861. {
  862. var names = items
  863. .SelectMany(i => i.AllArtists)
  864. .DistinctNames()
  865. .Select(i =>
  866. {
  867. try
  868. {
  869. var artist = GetArtist(i);
  870. return artist;
  871. }
  872. catch
  873. {
  874. // Already logged at lower levels
  875. return null;
  876. }
  877. })
  878. .Where(i => i != null);
  879. return names;
  880. }
  881. /// <summary>
  882. /// Validate and refresh the People sub-set of the IBN.
  883. /// The items are stored in the db but not loaded into memory until actually requested by an operation.
  884. /// </summary>
  885. /// <param name="cancellationToken">The cancellation token.</param>
  886. /// <param name="progress">The progress.</param>
  887. /// <returns>Task.</returns>
  888. public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
  889. {
  890. // Ensure the location is available.
  891. _fileSystem.CreateDirectory(ConfigurationManager.ApplicationPaths.PeoplePath);
  892. return new PeopleValidator(this, _logger, ConfigurationManager, _fileSystem).ValidatePeople(cancellationToken, progress);
  893. }
  894. /// <summary>
  895. /// Reloads the root media folder
  896. /// </summary>
  897. /// <param name="progress">The progress.</param>
  898. /// <param name="cancellationToken">The cancellation token.</param>
  899. /// <returns>Task.</returns>
  900. public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
  901. {
  902. // Just run the scheduled task so that the user can see it
  903. _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
  904. return Task.FromResult(true);
  905. }
  906. /// <summary>
  907. /// Queues the library scan.
  908. /// </summary>
  909. public void QueueLibraryScan()
  910. {
  911. // Just run the scheduled task so that the user can see it
  912. _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
  913. }
  914. /// <summary>
  915. /// Validates the media library internal.
  916. /// </summary>
  917. /// <param name="progress">The progress.</param>
  918. /// <param name="cancellationToken">The cancellation token.</param>
  919. /// <returns>Task.</returns>
  920. public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
  921. {
  922. IsScanRunning = true;
  923. _libraryMonitorFactory().Stop();
  924. try
  925. {
  926. await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
  927. }
  928. finally
  929. {
  930. _libraryMonitorFactory().Start();
  931. IsScanRunning = false;
  932. }
  933. }
  934. private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
  935. {
  936. _logger.Info("Validating media library");
  937. await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  938. progress.Report(.5);
  939. // Start by just validating the children of the root, but go no further
  940. await RootFolder.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false);
  941. progress.Report(1);
  942. var userRoot = GetUserRootFolder();
  943. await userRoot.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  944. await userRoot.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false).ConfigureAwait(false);
  945. progress.Report(2);
  946. var innerProgress = new ActionableProgress<double>();
  947. innerProgress.RegisterAction(pct => progress.Report(2 + pct * .73));
  948. // Now validate the entire media library
  949. await RootFolder.ValidateChildren(innerProgress, cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: true).ConfigureAwait(false);
  950. progress.Report(75);
  951. innerProgress = new ActionableProgress<double>();
  952. innerProgress.RegisterAction(pct => progress.Report(75 + pct * .25));
  953. // Run post-scan tasks
  954. await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
  955. progress.Report(100);
  956. // Bad practice, i know. But we keep a lot in memory, unfortunately.
  957. GC.Collect(2, GCCollectionMode.Forced, true);
  958. GC.Collect(2, GCCollectionMode.Forced, true);
  959. }
  960. /// <summary>
  961. /// Runs the post scan tasks.
  962. /// </summary>
  963. /// <param name="progress">The progress.</param>
  964. /// <param name="cancellationToken">The cancellation token.</param>
  965. /// <returns>Task.</returns>
  966. private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
  967. {
  968. var tasks = PostscanTasks.ToList();
  969. var numComplete = 0;
  970. var numTasks = tasks.Count;
  971. foreach (var task in tasks)
  972. {
  973. var innerProgress = new ActionableProgress<double>();
  974. // Prevent access to modified closure
  975. var currentNumComplete = numComplete;
  976. innerProgress.RegisterAction(pct =>
  977. {
  978. double innerPercent = currentNumComplete * 100 + pct;
  979. innerPercent /= numTasks;
  980. progress.Report(innerPercent);
  981. });
  982. _logger.Debug("Running post-scan task {0}", task.GetType().Name);
  983. try
  984. {
  985. await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
  986. }
  987. catch (OperationCanceledException)
  988. {
  989. _logger.Info("Post-scan task cancelled: {0}", task.GetType().Name);
  990. }
  991. catch (Exception ex)
  992. {
  993. _logger.ErrorException("Error running postscan task", ex);
  994. }
  995. numComplete++;
  996. double percent = numComplete;
  997. percent /= numTasks;
  998. progress.Report(percent * 100);
  999. }
  1000. progress.Report(100);
  1001. }
  1002. /// <summary>
  1003. /// Gets the default view.
  1004. /// </summary>
  1005. /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
  1006. public IEnumerable<VirtualFolderInfo> GetVirtualFolders()
  1007. {
  1008. return GetView(ConfigurationManager.ApplicationPaths.DefaultUserViewsPath);
  1009. }
  1010. /// <summary>
  1011. /// Gets the view.
  1012. /// </summary>
  1013. /// <param name="path">The path.</param>
  1014. /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
  1015. private IEnumerable<VirtualFolderInfo> GetView(string path)
  1016. {
  1017. var topLibraryFolders = GetUserRootFolder().Children.ToList();
  1018. return _fileSystem.GetDirectoryPaths(path)
  1019. .Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders));
  1020. }
  1021. private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> collectionFolders)
  1022. {
  1023. var info = new VirtualFolderInfo
  1024. {
  1025. Name = Path.GetFileName(dir),
  1026. Locations = Directory.EnumerateFiles(dir, "*.mblink", SearchOption.TopDirectoryOnly)
  1027. .Select(_fileSystem.ResolveShortcut)
  1028. .OrderBy(i => i)
  1029. .ToList(),
  1030. CollectionType = GetCollectionType(dir)
  1031. };
  1032. var libraryFolder = collectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.OrdinalIgnoreCase));
  1033. if (libraryFolder != null && libraryFolder.HasImage(ImageType.Primary))
  1034. {
  1035. info.PrimaryImageItemId = libraryFolder.Id.ToString("N");
  1036. }
  1037. if (libraryFolder != null)
  1038. {
  1039. info.ItemId = libraryFolder.Id.ToString("N");
  1040. }
  1041. return info;
  1042. }
  1043. private string GetCollectionType(string path)
  1044. {
  1045. return _fileSystem.GetFiles(path, false)
  1046. .Where(i => string.Equals(i.Extension, ".collection", StringComparison.OrdinalIgnoreCase))
  1047. .Select(i => _fileSystem.GetFileNameWithoutExtension(i))
  1048. .FirstOrDefault();
  1049. }
  1050. /// <summary>
  1051. /// Gets the item by id.
  1052. /// </summary>
  1053. /// <param name="id">The id.</param>
  1054. /// <returns>BaseItem.</returns>
  1055. /// <exception cref="System.ArgumentNullException">id</exception>
  1056. public BaseItem GetItemById(Guid id)
  1057. {
  1058. if (id == Guid.Empty)
  1059. {
  1060. throw new ArgumentNullException("id");
  1061. }
  1062. BaseItem item;
  1063. if (LibraryItemsCache.TryGetValue(id, out item))
  1064. {
  1065. return item;
  1066. }
  1067. item = RetrieveItem(id);
  1068. if (item != null)
  1069. {
  1070. RegisterItem(item);
  1071. }
  1072. return item;
  1073. }
  1074. public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query)
  1075. {
  1076. if (query.User != null)
  1077. {
  1078. AddUserToQuery(query, query.User);
  1079. }
  1080. return ItemRepository.GetItemList(query);
  1081. }
  1082. public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
  1083. {
  1084. if (query.User != null)
  1085. {
  1086. AddUserToQuery(query, query.User);
  1087. }
  1088. if (query.EnableTotalRecordCount)
  1089. {
  1090. return ItemRepository.GetItems(query);
  1091. }
  1092. return new QueryResult<BaseItem>
  1093. {
  1094. Items = ItemRepository.GetItemList(query).ToArray()
  1095. };
  1096. }
  1097. public List<Guid> GetItemIds(InternalItemsQuery query)
  1098. {
  1099. if (query.User != null)
  1100. {
  1101. AddUserToQuery(query, query.User);
  1102. }
  1103. return ItemRepository.GetItemIdsList(query);
  1104. }
  1105. public QueryResult<Tuple<BaseItem, ItemCounts>> GetStudios(InternalItemsQuery query)
  1106. {
  1107. if (query.User != null)
  1108. {
  1109. AddUserToQuery(query, query.User);
  1110. }
  1111. SetTopParentOrAncestorIds(query);
  1112. return ItemRepository.GetStudios(query);
  1113. }
  1114. public QueryResult<Tuple<BaseItem, ItemCounts>> GetGenres(InternalItemsQuery query)
  1115. {
  1116. if (query.User != null)
  1117. {
  1118. AddUserToQuery(query, query.User);
  1119. }
  1120. SetTopParentOrAncestorIds(query);
  1121. return ItemRepository.GetGenres(query);
  1122. }
  1123. public QueryResult<Tuple<BaseItem, ItemCounts>> GetGameGenres(InternalItemsQuery query)
  1124. {
  1125. if (query.User != null)
  1126. {
  1127. AddUserToQuery(query, query.User);
  1128. }
  1129. SetTopParentOrAncestorIds(query);
  1130. return ItemRepository.GetGameGenres(query);
  1131. }
  1132. public QueryResult<Tuple<BaseItem, ItemCounts>> GetMusicGenres(InternalItemsQuery query)
  1133. {
  1134. if (query.User != null)
  1135. {
  1136. AddUserToQuery(query, query.User);
  1137. }
  1138. SetTopParentOrAncestorIds(query);
  1139. return ItemRepository.GetMusicGenres(query);
  1140. }
  1141. public QueryResult<Tuple<BaseItem, ItemCounts>> GetArtists(InternalItemsQuery query)
  1142. {
  1143. if (query.User != null)
  1144. {
  1145. AddUserToQuery(query, query.User);
  1146. }
  1147. SetTopParentOrAncestorIds(query);
  1148. return ItemRepository.GetArtists(query);
  1149. }
  1150. private void SetTopParentOrAncestorIds(InternalItemsQuery query)
  1151. {
  1152. if (query.AncestorIds.Length == 0)
  1153. {
  1154. return;
  1155. }
  1156. var parents = query.AncestorIds.Select(i => GetItemById(new Guid(i))).ToList();
  1157. if (parents.All(i =>
  1158. {
  1159. if (i is ICollectionFolder || i is UserView)
  1160. {
  1161. return true;
  1162. }
  1163. //_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
  1164. return false;
  1165. }))
  1166. {
  1167. // Optimize by querying against top level views
  1168. query.TopParentIds = parents.SelectMany(i => GetTopParentsForQuery(i, query.User)).Select(i => i.Id.ToString("N")).ToArray();
  1169. query.AncestorIds = new string[] { };
  1170. }
  1171. }
  1172. public QueryResult<Tuple<BaseItem, ItemCounts>> GetAlbumArtists(InternalItemsQuery query)
  1173. {
  1174. if (query.User != null)
  1175. {
  1176. AddUserToQuery(query, query.User);
  1177. }
  1178. SetTopParentOrAncestorIds(query);
  1179. return ItemRepository.GetAlbumArtists(query);
  1180. }
  1181. public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query, IEnumerable<string> parentIds)
  1182. {
  1183. var parents = parentIds.Select(i => GetItemById(new Guid(i))).Where(i => i != null).ToList();
  1184. SetTopParentIdsOrAncestors(query, parents);
  1185. return ItemRepository.GetItemList(query);
  1186. }
  1187. public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
  1188. {
  1189. if (query.Recursive && query.ParentId.HasValue)
  1190. {
  1191. var parent = GetItemById(query.ParentId.Value);
  1192. if (parent != null)
  1193. {
  1194. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1195. query.ParentId = null;
  1196. }
  1197. }
  1198. if (query.User != null)
  1199. {
  1200. AddUserToQuery(query, query.User);
  1201. }
  1202. if (query.EnableTotalRecordCount)
  1203. {
  1204. return ItemRepository.GetItems(query);
  1205. }
  1206. return new QueryResult<BaseItem>
  1207. {
  1208. Items = ItemRepository.GetItemList(query).ToArray()
  1209. };
  1210. }
  1211. public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query, IEnumerable<string> parentIds)
  1212. {
  1213. var parents = parentIds.Select(i => GetItemById(new Guid(i))).Where(i => i != null).ToList();
  1214. SetTopParentIdsOrAncestors(query, parents);
  1215. return GetItemsResult(query);
  1216. }
  1217. private void SetTopParentIdsOrAncestors(InternalItemsQuery query, List<BaseItem> parents)
  1218. {
  1219. if (parents.All(i =>
  1220. {
  1221. if (i is ICollectionFolder || i is UserView)
  1222. {
  1223. return true;
  1224. }
  1225. //_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
  1226. return false;
  1227. }))
  1228. {
  1229. // Optimize by querying against top level views
  1230. query.TopParentIds = parents.SelectMany(i => GetTopParentsForQuery(i, query.User)).Select(i => i.Id.ToString("N")).ToArray();
  1231. }
  1232. else
  1233. {
  1234. // We need to be able to query from any arbitrary ancestor up the tree
  1235. query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).Select(i => i.ToString("N")).ToArray();
  1236. }
  1237. }
  1238. private void AddUserToQuery(InternalItemsQuery query, User user)
  1239. {
  1240. if (query.AncestorIds.Length == 0 && !query.ParentId.HasValue && query.ChannelIds.Length == 0 && query.TopParentIds.Length == 0 && string.IsNullOrWhiteSpace(query.AncestorWithPresentationUniqueKey))
  1241. {
  1242. var userViews = _userviewManager().GetUserViews(new UserViewQuery
  1243. {
  1244. UserId = user.Id.ToString("N"),
  1245. IncludeHidden = true
  1246. }, CancellationToken.None).Result.ToList();
  1247. query.TopParentIds = userViews.SelectMany(i => GetTopParentsForQuery(i, user)).Select(i => i.Id.ToString("N")).ToArray();
  1248. }
  1249. }
  1250. private IEnumerable<BaseItem> GetTopParentsForQuery(BaseItem item, User user)
  1251. {
  1252. var view = item as UserView;
  1253. if (view != null)
  1254. {
  1255. if (string.Equals(view.ViewType, CollectionType.LiveTv))
  1256. {
  1257. return new[] { view };
  1258. }
  1259. if (string.Equals(view.ViewType, CollectionType.Channels))
  1260. {
  1261. // TODO: Return channels
  1262. return new[] { view };
  1263. }
  1264. // Translate view into folders
  1265. if (view.DisplayParentId != Guid.Empty)
  1266. {
  1267. var displayParent = GetItemById(view.DisplayParentId);
  1268. if (displayParent != null)
  1269. {
  1270. return GetTopParentsForQuery(displayParent, user);
  1271. }
  1272. return new BaseItem[] { };
  1273. }
  1274. if (view.ParentId != Guid.Empty)
  1275. {
  1276. var displayParent = GetItemById(view.ParentId);
  1277. if (displayParent != null)
  1278. {
  1279. return GetTopParentsForQuery(displayParent, user);
  1280. }
  1281. return new BaseItem[] { };
  1282. }
  1283. // Handle grouping
  1284. if (user != null && !string.IsNullOrWhiteSpace(view.ViewType) && UserView.IsEligibleForGrouping(view.ViewType))
  1285. {
  1286. return user.RootFolder
  1287. .GetChildren(user, true)
  1288. .OfType<CollectionFolder>()
  1289. .Where(i => string.IsNullOrWhiteSpace(i.CollectionType) || string.Equals(i.CollectionType, view.ViewType, StringComparison.OrdinalIgnoreCase))
  1290. .Where(i => user.IsFolderGrouped(i.Id))
  1291. .SelectMany(i => GetTopParentsForQuery(i, user));
  1292. }
  1293. return new BaseItem[] { };
  1294. }
  1295. var collectionFolder = item as CollectionFolder;
  1296. if (collectionFolder != null)
  1297. {
  1298. return collectionFolder.GetPhysicalParents();
  1299. }
  1300. var topParent = item.GetTopParent();
  1301. if (topParent != null)
  1302. {
  1303. return new[] { topParent };
  1304. }
  1305. return new BaseItem[] { };
  1306. }
  1307. /// <summary>
  1308. /// Gets the intros.
  1309. /// </summary>
  1310. /// <param name="item">The item.</param>
  1311. /// <param name="user">The user.</param>
  1312. /// <returns>IEnumerable{System.String}.</returns>
  1313. public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
  1314. {
  1315. var tasks = IntroProviders
  1316. .OrderBy(i => i.GetType().Name.IndexOf("Default", StringComparison.OrdinalIgnoreCase) == -1 ? 0 : 1)
  1317. .Take(1)
  1318. .Select(i => GetIntros(i, item, user));
  1319. var items = await Task.WhenAll(tasks).ConfigureAwait(false);
  1320. return items
  1321. .SelectMany(i => i.ToArray())
  1322. .Select(ResolveIntro)
  1323. .Where(i => i != null);
  1324. }
  1325. /// <summary>
  1326. /// Gets the intros.
  1327. /// </summary>
  1328. /// <param name="provider">The provider.</param>
  1329. /// <param name="item">The item.</param>
  1330. /// <param name="user">The user.</param>
  1331. /// <returns>Task&lt;IEnumerable&lt;IntroInfo&gt;&gt;.</returns>
  1332. private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
  1333. {
  1334. try
  1335. {
  1336. return await provider.GetIntros(item, user).ConfigureAwait(false);
  1337. }
  1338. catch (Exception ex)
  1339. {
  1340. _logger.ErrorException("Error getting intros", ex);
  1341. return new List<IntroInfo>();
  1342. }
  1343. }
  1344. /// <summary>
  1345. /// Gets all intro files.
  1346. /// </summary>
  1347. /// <returns>IEnumerable{System.String}.</returns>
  1348. public IEnumerable<string> GetAllIntroFiles()
  1349. {
  1350. return IntroProviders.SelectMany(i =>
  1351. {
  1352. try
  1353. {
  1354. return i.GetAllIntroFiles().ToList();
  1355. }
  1356. catch (Exception ex)
  1357. {
  1358. _logger.ErrorException("Error getting intro files", ex);
  1359. return new List<string>();
  1360. }
  1361. });
  1362. }
  1363. /// <summary>
  1364. /// Resolves the intro.
  1365. /// </summary>
  1366. /// <param name="info">The info.</param>
  1367. /// <returns>Video.</returns>
  1368. private Video ResolveIntro(IntroInfo info)
  1369. {
  1370. Video video = null;
  1371. if (info.ItemId.HasValue)
  1372. {
  1373. // Get an existing item by Id
  1374. video = GetItemById(info.ItemId.Value) as Video;
  1375. if (video == null)
  1376. {
  1377. _logger.Error("Unable to locate item with Id {0}.", info.ItemId.Value);
  1378. }
  1379. }
  1380. else if (!string.IsNullOrEmpty(info.Path))
  1381. {
  1382. try
  1383. {
  1384. // Try to resolve the path into a video
  1385. video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
  1386. if (video == null)
  1387. {
  1388. _logger.Error("Intro resolver returned null for {0}.", info.Path);
  1389. }
  1390. else
  1391. {
  1392. // Pull the saved db item that will include metadata
  1393. var dbItem = GetItemById(video.Id) as Video;
  1394. if (dbItem != null)
  1395. {
  1396. video = dbItem;
  1397. }
  1398. else
  1399. {
  1400. return null;
  1401. }
  1402. }
  1403. }
  1404. catch (Exception ex)
  1405. {
  1406. _logger.ErrorException("Error resolving path {0}.", ex, info.Path);
  1407. }
  1408. }
  1409. else
  1410. {
  1411. _logger.Error("IntroProvider returned an IntroInfo with null Path and ItemId.");
  1412. }
  1413. return video;
  1414. }
  1415. /// <summary>
  1416. /// Sorts the specified sort by.
  1417. /// </summary>
  1418. /// <param name="items">The items.</param>
  1419. /// <param name="user">The user.</param>
  1420. /// <param name="sortBy">The sort by.</param>
  1421. /// <param name="sortOrder">The sort order.</param>
  1422. /// <returns>IEnumerable{BaseItem}.</returns>
  1423. public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<string> sortBy, SortOrder sortOrder)
  1424. {
  1425. var isFirst = true;
  1426. IOrderedEnumerable<BaseItem> orderedItems = null;
  1427. foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c != null))
  1428. {
  1429. if (isFirst)
  1430. {
  1431. orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, orderBy) : items.OrderBy(i => i, orderBy);
  1432. }
  1433. else
  1434. {
  1435. orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, orderBy) : orderedItems.ThenBy(i => i, orderBy);
  1436. }
  1437. isFirst = false;
  1438. }
  1439. return orderedItems ?? items;
  1440. }
  1441. /// <summary>
  1442. /// Gets the comparer.
  1443. /// </summary>
  1444. /// <param name="name">The name.</param>
  1445. /// <param name="user">The user.</param>
  1446. /// <returns>IBaseItemComparer.</returns>
  1447. private IBaseItemComparer GetComparer(string name, User user)
  1448. {
  1449. var comparer = Comparers.FirstOrDefault(c => string.Equals(name, c.Name, StringComparison.OrdinalIgnoreCase));
  1450. if (comparer != null)
  1451. {
  1452. // If it requires a user, create a new one, and assign the user
  1453. if (comparer is IUserBaseItemComparer)
  1454. {
  1455. var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType());
  1456. userComparer.User = user;
  1457. userComparer.UserManager = _userManager;
  1458. userComparer.UserDataRepository = _userDataRepository;
  1459. return userComparer;
  1460. }
  1461. }
  1462. return comparer;
  1463. }
  1464. /// <summary>
  1465. /// Creates the item.
  1466. /// </summary>
  1467. /// <param name="item">The item.</param>
  1468. /// <param name="cancellationToken">The cancellation token.</param>
  1469. /// <returns>Task.</returns>
  1470. public Task CreateItem(BaseItem item, CancellationToken cancellationToken)
  1471. {
  1472. return CreateItems(new[] { item }, cancellationToken);
  1473. }
  1474. /// <summary>
  1475. /// Creates the items.
  1476. /// </summary>
  1477. /// <param name="items">The items.</param>
  1478. /// <param name="cancellationToken">The cancellation token.</param>
  1479. /// <returns>Task.</returns>
  1480. public async Task CreateItems(IEnumerable<BaseItem> items, CancellationToken cancellationToken)
  1481. {
  1482. var list = items.ToList();
  1483. await ItemRepository.SaveItems(list, cancellationToken).ConfigureAwait(false);
  1484. foreach (var item in list)
  1485. {
  1486. UpdateItemInLibraryCache(item);
  1487. }
  1488. if (ItemAdded != null)
  1489. {
  1490. foreach (var item in list)
  1491. {
  1492. try
  1493. {
  1494. ItemAdded(this, new ItemChangeEventArgs { Item = item });
  1495. }
  1496. catch (Exception ex)
  1497. {
  1498. _logger.ErrorException("Error in ItemAdded event handler", ex);
  1499. }
  1500. }
  1501. }
  1502. }
  1503. /// <summary>
  1504. /// Updates the item.
  1505. /// </summary>
  1506. /// <param name="item">The item.</param>
  1507. /// <param name="updateReason">The update reason.</param>
  1508. /// <param name="cancellationToken">The cancellation token.</param>
  1509. /// <returns>Task.</returns>
  1510. public async Task UpdateItem(BaseItem item, ItemUpdateType updateReason, CancellationToken cancellationToken)
  1511. {
  1512. var locationType = item.LocationType;
  1513. if (locationType != LocationType.Remote && locationType != LocationType.Virtual)
  1514. {
  1515. await _providerManagerFactory().SaveMetadata(item, updateReason).ConfigureAwait(false);
  1516. }
  1517. item.DateLastSaved = DateTime.UtcNow;
  1518. var logName = item.LocationType == LocationType.Remote ? item.Name ?? item.Path : item.Path ?? item.Name;
  1519. _logger.Debug("Saving {0} to database.", logName);
  1520. await ItemRepository.SaveItem(item, cancellationToken).ConfigureAwait(false);
  1521. UpdateItemInLibraryCache(item);
  1522. if (ItemUpdated != null)
  1523. {
  1524. try
  1525. {
  1526. ItemUpdated(this, new ItemChangeEventArgs
  1527. {
  1528. Item = item,
  1529. UpdateReason = updateReason
  1530. });
  1531. }
  1532. catch (Exception ex)
  1533. {
  1534. _logger.ErrorException("Error in ItemUpdated event handler", ex);
  1535. }
  1536. }
  1537. }
  1538. /// <summary>
  1539. /// Reports the item removed.
  1540. /// </summary>
  1541. /// <param name="item">The item.</param>
  1542. public void ReportItemRemoved(BaseItem item)
  1543. {
  1544. if (ItemRemoved != null)
  1545. {
  1546. try
  1547. {
  1548. ItemRemoved(this, new ItemChangeEventArgs { Item = item });
  1549. }
  1550. catch (Exception ex)
  1551. {
  1552. _logger.ErrorException("Error in ItemRemoved event handler", ex);
  1553. }
  1554. }
  1555. }
  1556. /// <summary>
  1557. /// Retrieves the item.
  1558. /// </summary>
  1559. /// <param name="id">The id.</param>
  1560. /// <returns>BaseItem.</returns>
  1561. public BaseItem RetrieveItem(Guid id)
  1562. {
  1563. return ItemRepository.RetrieveItem(id);
  1564. }
  1565. public IEnumerable<Folder> GetCollectionFolders(BaseItem item)
  1566. {
  1567. while (!(item.GetParent() is AggregateFolder) && item.GetParent() != null)
  1568. {
  1569. item = item.GetParent();
  1570. }
  1571. if (item == null)
  1572. {
  1573. return new List<Folder>();
  1574. }
  1575. return GetUserRootFolder().Children
  1576. .OfType<Folder>()
  1577. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path, StringComparer.OrdinalIgnoreCase));
  1578. }
  1579. public string GetContentType(BaseItem item)
  1580. {
  1581. string configuredContentType = GetConfiguredContentType(item, false);
  1582. if (!string.IsNullOrWhiteSpace(configuredContentType))
  1583. {
  1584. return configuredContentType;
  1585. }
  1586. configuredContentType = GetConfiguredContentType(item, true);
  1587. if (!string.IsNullOrWhiteSpace(configuredContentType))
  1588. {
  1589. return configuredContentType;
  1590. }
  1591. return GetInheritedContentType(item);
  1592. }
  1593. public string GetInheritedContentType(BaseItem item)
  1594. {
  1595. var type = GetTopFolderContentType(item);
  1596. if (!string.IsNullOrWhiteSpace(type))
  1597. {
  1598. return type;
  1599. }
  1600. return item.GetParents()
  1601. .Select(GetConfiguredContentType)
  1602. .LastOrDefault(i => !string.IsNullOrWhiteSpace(i));
  1603. }
  1604. public string GetConfiguredContentType(BaseItem item)
  1605. {
  1606. return GetConfiguredContentType(item, false);
  1607. }
  1608. public string GetConfiguredContentType(string path)
  1609. {
  1610. return GetContentTypeOverride(path, false);
  1611. }
  1612. public string GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
  1613. {
  1614. ICollectionFolder collectionFolder = item as ICollectionFolder;
  1615. if (collectionFolder != null)
  1616. {
  1617. return collectionFolder.CollectionType;
  1618. }
  1619. return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
  1620. }
  1621. private string GetContentTypeOverride(string path, bool inherit)
  1622. {
  1623. var nameValuePair = ConfigurationManager.Configuration.ContentTypes.FirstOrDefault(i => string.Equals(i.Name, path, StringComparison.OrdinalIgnoreCase) || (inherit && _fileSystem.ContainsSubPath(i.Name, path)));
  1624. if (nameValuePair != null)
  1625. {
  1626. return nameValuePair.Value;
  1627. }
  1628. return null;
  1629. }
  1630. private string GetTopFolderContentType(BaseItem item)
  1631. {
  1632. if (item == null)
  1633. {
  1634. return null;
  1635. }
  1636. while (!(item.GetParent() is AggregateFolder) && item.GetParent() != null)
  1637. {
  1638. item = item.GetParent();
  1639. }
  1640. return GetUserRootFolder().Children
  1641. .OfType<ICollectionFolder>()
  1642. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
  1643. .Select(i => i.CollectionType)
  1644. .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
  1645. }
  1646. private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
  1647. //private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromMinutes(1);
  1648. public Task<UserView> GetNamedView(User user,
  1649. string name,
  1650. string viewType,
  1651. string sortName,
  1652. CancellationToken cancellationToken)
  1653. {
  1654. return GetNamedView(user, name, null, viewType, sortName, cancellationToken);
  1655. }
  1656. public async Task<UserView> GetNamedView(string name,
  1657. string viewType,
  1658. string sortName,
  1659. CancellationToken cancellationToken)
  1660. {
  1661. var path = Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "views");
  1662. path = Path.Combine(path, _fileSystem.GetValidFilename(viewType));
  1663. var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
  1664. var item = GetItemById(id) as UserView;
  1665. var refresh = false;
  1666. if (item == null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
  1667. {
  1668. _fileSystem.CreateDirectory(path);
  1669. item = new UserView
  1670. {
  1671. Path = path,
  1672. Id = id,
  1673. DateCreated = DateTime.UtcNow,
  1674. Name = name,
  1675. ViewType = viewType,
  1676. ForcedSortName = sortName
  1677. };
  1678. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1679. refresh = true;
  1680. }
  1681. if (!refresh)
  1682. {
  1683. refresh = DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1684. }
  1685. if (!refresh && item.DisplayParentId != Guid.Empty)
  1686. {
  1687. var displayParent = GetItemById(item.DisplayParentId);
  1688. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1689. }
  1690. if (refresh)
  1691. {
  1692. await item.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None).ConfigureAwait(false);
  1693. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1694. {
  1695. // Not sure why this is necessary but need to figure it out
  1696. // View images are not getting utilized without this
  1697. ForceSave = true
  1698. });
  1699. }
  1700. return item;
  1701. }
  1702. public async Task<UserView> GetNamedView(User user,
  1703. string name,
  1704. string parentId,
  1705. string viewType,
  1706. string sortName,
  1707. CancellationToken cancellationToken)
  1708. {
  1709. var idValues = "38_namedview_" + name + user.Id.ToString("N") + (parentId ?? string.Empty) + (viewType ?? string.Empty);
  1710. var id = GetNewItemId(idValues, typeof(UserView));
  1711. var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
  1712. var item = GetItemById(id) as UserView;
  1713. var isNew = false;
  1714. if (item == null)
  1715. {
  1716. _fileSystem.CreateDirectory(path);
  1717. item = new UserView
  1718. {
  1719. Path = path,
  1720. Id = id,
  1721. DateCreated = DateTime.UtcNow,
  1722. Name = name,
  1723. ViewType = viewType,
  1724. ForcedSortName = sortName,
  1725. UserId = user.Id
  1726. };
  1727. if (!string.IsNullOrWhiteSpace(parentId))
  1728. {
  1729. item.DisplayParentId = new Guid(parentId);
  1730. }
  1731. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1732. isNew = true;
  1733. }
  1734. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1735. if (!refresh && item.DisplayParentId != Guid.Empty)
  1736. {
  1737. var displayParent = GetItemById(item.DisplayParentId);
  1738. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1739. }
  1740. if (refresh)
  1741. {
  1742. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1743. {
  1744. // Need to force save to increment DateLastSaved
  1745. ForceSave = true
  1746. });
  1747. }
  1748. return item;
  1749. }
  1750. public async Task<UserView> GetShadowView(BaseItem parent,
  1751. string viewType,
  1752. string sortName,
  1753. CancellationToken cancellationToken)
  1754. {
  1755. if (parent == null)
  1756. {
  1757. throw new ArgumentNullException("parent");
  1758. }
  1759. var name = parent.Name;
  1760. var parentId = parent.Id;
  1761. var idValues = "38_namedview_" + name + parentId + (viewType ?? string.Empty);
  1762. var id = GetNewItemId(idValues, typeof(UserView));
  1763. var path = parent.Path;
  1764. var item = GetItemById(id) as UserView;
  1765. var isNew = false;
  1766. if (item == null)
  1767. {
  1768. _fileSystem.CreateDirectory(path);
  1769. item = new UserView
  1770. {
  1771. Path = path,
  1772. Id = id,
  1773. DateCreated = DateTime.UtcNow,
  1774. Name = name,
  1775. ViewType = viewType,
  1776. ForcedSortName = sortName
  1777. };
  1778. item.DisplayParentId = parentId;
  1779. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1780. isNew = true;
  1781. }
  1782. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1783. if (!refresh && item.DisplayParentId != Guid.Empty)
  1784. {
  1785. var displayParent = GetItemById(item.DisplayParentId);
  1786. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1787. }
  1788. if (refresh)
  1789. {
  1790. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1791. {
  1792. // Need to force save to increment DateLastSaved
  1793. ForceSave = true
  1794. });
  1795. }
  1796. return item;
  1797. }
  1798. public async Task<UserView> GetNamedView(string name,
  1799. string parentId,
  1800. string viewType,
  1801. string sortName,
  1802. string uniqueId,
  1803. CancellationToken cancellationToken)
  1804. {
  1805. if (string.IsNullOrWhiteSpace(name))
  1806. {
  1807. throw new ArgumentNullException("name");
  1808. }
  1809. var idValues = "37_namedview_" + name + (parentId ?? string.Empty) + (viewType ?? string.Empty);
  1810. if (!string.IsNullOrWhiteSpace(uniqueId))
  1811. {
  1812. idValues += uniqueId;
  1813. }
  1814. var id = GetNewItemId(idValues, typeof(UserView));
  1815. var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
  1816. var item = GetItemById(id) as UserView;
  1817. var isNew = false;
  1818. if (item == null)
  1819. {
  1820. _fileSystem.CreateDirectory(path);
  1821. item = new UserView
  1822. {
  1823. Path = path,
  1824. Id = id,
  1825. DateCreated = DateTime.UtcNow,
  1826. Name = name,
  1827. ViewType = viewType,
  1828. ForcedSortName = sortName
  1829. };
  1830. if (!string.IsNullOrWhiteSpace(parentId))
  1831. {
  1832. item.DisplayParentId = new Guid(parentId);
  1833. }
  1834. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1835. isNew = true;
  1836. }
  1837. if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
  1838. {
  1839. item.ViewType = viewType;
  1840. await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
  1841. }
  1842. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1843. if (!refresh && item.DisplayParentId != Guid.Empty)
  1844. {
  1845. var displayParent = GetItemById(item.DisplayParentId);
  1846. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1847. }
  1848. if (refresh)
  1849. {
  1850. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1851. {
  1852. // Need to force save to increment DateLastSaved
  1853. ForceSave = true
  1854. });
  1855. }
  1856. return item;
  1857. }
  1858. public bool IsVideoFile(string path)
  1859. {
  1860. var resolver = new VideoResolver(GetNamingOptions(), new PatternsLogger());
  1861. return resolver.IsVideoFile(path);
  1862. }
  1863. public bool IsAudioFile(string path)
  1864. {
  1865. var parser = new AudioFileParser(GetNamingOptions());
  1866. return parser.IsAudioFile(path);
  1867. }
  1868. public int? GetSeasonNumberFromPath(string path)
  1869. {
  1870. return new SeasonPathParser(GetNamingOptions(), new RegexProvider()).Parse(path, true, true).SeasonNumber;
  1871. }
  1872. public bool FillMissingEpisodeNumbersFromPath(Episode episode)
  1873. {
  1874. var resolver = new EpisodeResolver(GetNamingOptions(),
  1875. new PatternsLogger());
  1876. var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd ||
  1877. episode.VideoType == VideoType.HdDvd;
  1878. var locationType = episode.LocationType;
  1879. var episodeInfo = locationType == LocationType.FileSystem || locationType == LocationType.Offline ?
  1880. resolver.Resolve(episode.Path, isFolder) :
  1881. new Naming.TV.EpisodeInfo();
  1882. if (episodeInfo == null)
  1883. {
  1884. episodeInfo = new Naming.TV.EpisodeInfo();
  1885. }
  1886. var changed = false;
  1887. if (episodeInfo.IsByDate)
  1888. {
  1889. if (episode.IndexNumber.HasValue)
  1890. {
  1891. episode.IndexNumber = null;
  1892. changed = true;
  1893. }
  1894. if (episode.IndexNumberEnd.HasValue)
  1895. {
  1896. episode.IndexNumberEnd = null;
  1897. changed = true;
  1898. }
  1899. if (!episode.PremiereDate.HasValue)
  1900. {
  1901. if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
  1902. {
  1903. episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value).ToUniversalTime();
  1904. }
  1905. if (episode.PremiereDate.HasValue)
  1906. {
  1907. changed = true;
  1908. }
  1909. }
  1910. if (!episode.ProductionYear.HasValue)
  1911. {
  1912. episode.ProductionYear = episodeInfo.Year;
  1913. if (episode.ProductionYear.HasValue)
  1914. {
  1915. changed = true;
  1916. }
  1917. }
  1918. if (!episode.ParentIndexNumber.HasValue)
  1919. {
  1920. var season = episode.Season;
  1921. if (season != null)
  1922. {
  1923. episode.ParentIndexNumber = season.IndexNumber;
  1924. }
  1925. if (episode.ParentIndexNumber.HasValue)
  1926. {
  1927. changed = true;
  1928. }
  1929. }
  1930. }
  1931. else
  1932. {
  1933. if (!episode.IndexNumber.HasValue)
  1934. {
  1935. episode.IndexNumber = episodeInfo.EpisodeNumber;
  1936. if (episode.IndexNumber.HasValue)
  1937. {
  1938. changed = true;
  1939. }
  1940. }
  1941. if (!episode.IndexNumberEnd.HasValue)
  1942. {
  1943. episode.IndexNumberEnd = episodeInfo.EndingEpsiodeNumber;
  1944. if (episode.IndexNumberEnd.HasValue)
  1945. {
  1946. changed = true;
  1947. }
  1948. }
  1949. if (!episode.ParentIndexNumber.HasValue)
  1950. {
  1951. episode.ParentIndexNumber = episodeInfo.SeasonNumber;
  1952. if (!episode.ParentIndexNumber.HasValue)
  1953. {
  1954. var season = episode.Season;
  1955. if (season != null)
  1956. {
  1957. episode.ParentIndexNumber = season.IndexNumber;
  1958. }
  1959. }
  1960. if (episode.ParentIndexNumber.HasValue)
  1961. {
  1962. changed = true;
  1963. }
  1964. }
  1965. }
  1966. return changed;
  1967. }
  1968. public NamingOptions GetNamingOptions()
  1969. {
  1970. var options = new ExtendedNamingOptions();
  1971. // These cause apps to have problems
  1972. options.AudioFileExtensions.Remove(".m3u");
  1973. options.AudioFileExtensions.Remove(".wpl");
  1974. if (!ConfigurationManager.Configuration.EnableAudioArchiveFiles)
  1975. {
  1976. options.AudioFileExtensions.Remove(".rar");
  1977. options.AudioFileExtensions.Remove(".zip");
  1978. }
  1979. if (!ConfigurationManager.Configuration.EnableVideoArchiveFiles)
  1980. {
  1981. options.VideoFileExtensions.Remove(".rar");
  1982. options.VideoFileExtensions.Remove(".zip");
  1983. }
  1984. return options;
  1985. }
  1986. public ItemLookupInfo ParseName(string name)
  1987. {
  1988. var resolver = new VideoResolver(GetNamingOptions(), new PatternsLogger());
  1989. var result = resolver.CleanDateTime(name);
  1990. var cleanName = resolver.CleanString(result.Name);
  1991. return new ItemLookupInfo
  1992. {
  1993. Name = cleanName.Name,
  1994. Year = result.Year
  1995. };
  1996. }
  1997. public IEnumerable<Video> FindTrailers(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  1998. {
  1999. var files = owner.IsInMixedFolder ? new List<FileSystemMetadata>() : fileSystemChildren.Where(i => i.IsDirectory)
  2000. .Where(i => string.Equals(i.Name, BaseItem.TrailerFolderName, StringComparison.OrdinalIgnoreCase))
  2001. .SelectMany(i => _fileSystem.GetFiles(i.FullName, false))
  2002. .ToList();
  2003. var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
  2004. var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
  2005. {
  2006. Id = i.FullName,
  2007. IsFolder = (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory
  2008. }).ToList());
  2009. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
  2010. if (currentVideo != null)
  2011. {
  2012. files.AddRange(currentVideo.Extras.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2013. }
  2014. var resolvers = new IItemResolver[]
  2015. {
  2016. new GenericVideoResolver<Trailer>(this)
  2017. };
  2018. return ResolvePaths(files, directoryService, null, null, resolvers)
  2019. .OfType<Trailer>()
  2020. .Select(video =>
  2021. {
  2022. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2023. var dbItem = GetItemById(video.Id) as Trailer;
  2024. if (dbItem != null)
  2025. {
  2026. video = dbItem;
  2027. }
  2028. video.ExtraType = ExtraType.Trailer;
  2029. video.TrailerTypes = new List<TrailerType> { TrailerType.LocalTrailer };
  2030. return video;
  2031. // Sort them so that the list can be easily compared for changes
  2032. }).OrderBy(i => i.Path).ToList();
  2033. }
  2034. public IEnumerable<Video> FindExtras(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  2035. {
  2036. var files = fileSystemChildren.Where(i => i.IsDirectory)
  2037. .Where(i => string.Equals(i.Name, "extras", StringComparison.OrdinalIgnoreCase) || string.Equals(i.Name, "specials", StringComparison.OrdinalIgnoreCase))
  2038. .SelectMany(i => _fileSystem.GetFiles(i.FullName, false))
  2039. .ToList();
  2040. var videoListResolver = new VideoListResolver(GetNamingOptions(), new PatternsLogger());
  2041. var videos = videoListResolver.Resolve(fileSystemChildren.Select(i => new FileMetadata
  2042. {
  2043. Id = i.FullName,
  2044. IsFolder = (i.Attributes & FileAttributes.Directory) == FileAttributes.Directory
  2045. }).ToList());
  2046. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
  2047. if (currentVideo != null)
  2048. {
  2049. files.AddRange(currentVideo.Extras.Where(i => !string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2050. }
  2051. return ResolvePaths(files, directoryService, null, null)
  2052. .OfType<Video>()
  2053. .Select(video =>
  2054. {
  2055. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2056. var dbItem = GetItemById(video.Id) as Video;
  2057. if (dbItem != null)
  2058. {
  2059. video = dbItem;
  2060. }
  2061. SetExtraTypeFromFilename(video);
  2062. return video;
  2063. // Sort them so that the list can be easily compared for changes
  2064. }).OrderBy(i => i.Path).ToList();
  2065. }
  2066. public string SubstitutePath(string path, string from, string to)
  2067. {
  2068. if (string.IsNullOrWhiteSpace(path))
  2069. {
  2070. throw new ArgumentNullException("path");
  2071. }
  2072. if (string.IsNullOrWhiteSpace(from))
  2073. {
  2074. throw new ArgumentNullException("from");
  2075. }
  2076. if (string.IsNullOrWhiteSpace(to))
  2077. {
  2078. throw new ArgumentNullException("to");
  2079. }
  2080. var newPath = path.Replace(from, to, StringComparison.OrdinalIgnoreCase);
  2081. if (!string.Equals(newPath, path))
  2082. {
  2083. if (to.IndexOf('/') != -1)
  2084. {
  2085. newPath = newPath.Replace('\\', '/');
  2086. }
  2087. else
  2088. {
  2089. newPath = newPath.Replace('/', '\\');
  2090. }
  2091. }
  2092. return newPath;
  2093. }
  2094. private void SetExtraTypeFromFilename(Video item)
  2095. {
  2096. var resolver = new ExtraResolver(GetNamingOptions(), new PatternsLogger(), new RegexProvider());
  2097. var result = resolver.GetExtraInfo(item.Path);
  2098. if (string.Equals(result.ExtraType, "deletedscene", StringComparison.OrdinalIgnoreCase))
  2099. {
  2100. item.ExtraType = ExtraType.DeletedScene;
  2101. }
  2102. else if (string.Equals(result.ExtraType, "behindthescenes", StringComparison.OrdinalIgnoreCase))
  2103. {
  2104. item.ExtraType = ExtraType.BehindTheScenes;
  2105. }
  2106. else if (string.Equals(result.ExtraType, "interview", StringComparison.OrdinalIgnoreCase))
  2107. {
  2108. item.ExtraType = ExtraType.Interview;
  2109. }
  2110. else if (string.Equals(result.ExtraType, "scene", StringComparison.OrdinalIgnoreCase))
  2111. {
  2112. item.ExtraType = ExtraType.Scene;
  2113. }
  2114. else if (string.Equals(result.ExtraType, "sample", StringComparison.OrdinalIgnoreCase))
  2115. {
  2116. item.ExtraType = ExtraType.Sample;
  2117. }
  2118. else
  2119. {
  2120. item.ExtraType = ExtraType.Clip;
  2121. }
  2122. }
  2123. public List<PersonInfo> GetPeople(InternalPeopleQuery query)
  2124. {
  2125. return ItemRepository.GetPeople(query);
  2126. }
  2127. public List<PersonInfo> GetPeople(BaseItem item)
  2128. {
  2129. if (item.SupportsPeople)
  2130. {
  2131. var people = GetPeople(new InternalPeopleQuery
  2132. {
  2133. ItemId = item.Id
  2134. });
  2135. if (people.Count > 0)
  2136. {
  2137. return people;
  2138. }
  2139. }
  2140. return new List<PersonInfo>();
  2141. }
  2142. public List<Person> GetPeopleItems(InternalPeopleQuery query)
  2143. {
  2144. return ItemRepository.GetPeopleNames(query).Select(i =>
  2145. {
  2146. try
  2147. {
  2148. return GetPerson(i);
  2149. }
  2150. catch (Exception ex)
  2151. {
  2152. _logger.ErrorException("Error getting person", ex);
  2153. return null;
  2154. }
  2155. }).Where(i => i != null).ToList();
  2156. }
  2157. public List<string> GetPeopleNames(InternalPeopleQuery query)
  2158. {
  2159. return ItemRepository.GetPeopleNames(query);
  2160. }
  2161. public List<PersonInfo> GetAllPeople()
  2162. {
  2163. return GetPeople(new InternalPeopleQuery())
  2164. .DistinctBy(i => i.Name, StringComparer.OrdinalIgnoreCase)
  2165. .ToList();
  2166. }
  2167. public Task UpdatePeople(BaseItem item, List<PersonInfo> people)
  2168. {
  2169. if (!item.SupportsPeople)
  2170. {
  2171. return Task.FromResult(true);
  2172. }
  2173. return ItemRepository.UpdatePeople(item.Id, people);
  2174. }
  2175. private readonly SemaphoreSlim _dynamicImageResourcePool = new SemaphoreSlim(1, 1);
  2176. public async Task<ItemImageInfo> ConvertImageToLocal(IHasImages item, ItemImageInfo image, int imageIndex)
  2177. {
  2178. foreach (var url in image.Path.Split('|'))
  2179. {
  2180. try
  2181. {
  2182. _logger.Debug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
  2183. await _providerManagerFactory().SaveImage(item, url, _dynamicImageResourcePool, image.Type, imageIndex, CancellationToken.None).ConfigureAwait(false);
  2184. var newImage = item.GetImageInfo(image.Type, imageIndex);
  2185. if (newImage != null)
  2186. {
  2187. newImage.IsPlaceholder = image.IsPlaceholder;
  2188. }
  2189. await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2190. return item.GetImageInfo(image.Type, imageIndex);
  2191. }
  2192. catch (HttpException ex)
  2193. {
  2194. if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
  2195. {
  2196. continue;
  2197. }
  2198. throw;
  2199. }
  2200. }
  2201. // Remove this image to prevent it from retrying over and over
  2202. item.RemoveImage(image);
  2203. await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2204. throw new InvalidOperationException();
  2205. }
  2206. public void AddVirtualFolder(string name, string collectionType, string[] mediaPaths, bool refreshLibrary)
  2207. {
  2208. if (string.IsNullOrWhiteSpace(name))
  2209. {
  2210. throw new ArgumentNullException("name");
  2211. }
  2212. name = _fileSystem.GetValidFilename(name);
  2213. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2214. var virtualFolderPath = Path.Combine(rootFolderPath, name);
  2215. while (_fileSystem.DirectoryExists(virtualFolderPath))
  2216. {
  2217. name += "1";
  2218. virtualFolderPath = Path.Combine(rootFolderPath, name);
  2219. }
  2220. if (mediaPaths != null)
  2221. {
  2222. var invalidpath = mediaPaths.FirstOrDefault(i => !_fileSystem.DirectoryExists(i));
  2223. if (invalidpath != null)
  2224. {
  2225. throw new ArgumentException("The specified path does not exist: " + invalidpath + ".");
  2226. }
  2227. }
  2228. _libraryMonitorFactory().Stop();
  2229. try
  2230. {
  2231. _fileSystem.CreateDirectory(virtualFolderPath);
  2232. if (!string.IsNullOrEmpty(collectionType))
  2233. {
  2234. var path = Path.Combine(virtualFolderPath, collectionType + ".collection");
  2235. using (File.Create(path))
  2236. {
  2237. }
  2238. }
  2239. if (mediaPaths != null)
  2240. {
  2241. foreach (var path in mediaPaths)
  2242. {
  2243. AddMediaPath(name, path);
  2244. }
  2245. }
  2246. }
  2247. finally
  2248. {
  2249. Task.Run(() =>
  2250. {
  2251. // No need to start if scanning the library because it will handle it
  2252. if (refreshLibrary)
  2253. {
  2254. ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
  2255. }
  2256. else
  2257. {
  2258. // Need to add a delay here or directory watchers may still pick up the changes
  2259. var task = Task.Delay(1000);
  2260. // Have to block here to allow exceptions to bubble
  2261. Task.WaitAll(task);
  2262. _libraryMonitorFactory().Start();
  2263. }
  2264. });
  2265. }
  2266. }
  2267. public void RemoveVirtualFolder(string name, bool refreshLibrary)
  2268. {
  2269. if (string.IsNullOrWhiteSpace(name))
  2270. {
  2271. throw new ArgumentNullException("name");
  2272. }
  2273. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2274. var path = Path.Combine(rootFolderPath, name);
  2275. if (!_fileSystem.DirectoryExists(path))
  2276. {
  2277. throw new DirectoryNotFoundException("The media folder does not exist");
  2278. }
  2279. _libraryMonitorFactory().Stop();
  2280. try
  2281. {
  2282. _fileSystem.DeleteDirectory(path, true);
  2283. }
  2284. finally
  2285. {
  2286. Task.Run(() =>
  2287. {
  2288. // No need to start if scanning the library because it will handle it
  2289. if (refreshLibrary)
  2290. {
  2291. ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
  2292. }
  2293. else
  2294. {
  2295. // Need to add a delay here or directory watchers may still pick up the changes
  2296. var task = Task.Delay(1000);
  2297. // Have to block here to allow exceptions to bubble
  2298. Task.WaitAll(task);
  2299. _libraryMonitorFactory().Start();
  2300. }
  2301. });
  2302. }
  2303. }
  2304. private const string ShortcutFileExtension = ".mblink";
  2305. private const string ShortcutFileSearch = "*" + ShortcutFileExtension;
  2306. public void AddMediaPath(string virtualFolderName, string path)
  2307. {
  2308. if (string.IsNullOrWhiteSpace(path))
  2309. {
  2310. throw new ArgumentNullException("path");
  2311. }
  2312. if (!_fileSystem.DirectoryExists(path))
  2313. {
  2314. throw new DirectoryNotFoundException("The path does not exist.");
  2315. }
  2316. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2317. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2318. var shortcutFilename = _fileSystem.GetFileNameWithoutExtension(path);
  2319. var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2320. while (_fileSystem.FileExists(lnk))
  2321. {
  2322. shortcutFilename += "1";
  2323. lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2324. }
  2325. _fileSystem.CreateShortcut(lnk, path);
  2326. RemoveContentTypeOverrides(path);
  2327. }
  2328. private void RemoveContentTypeOverrides(string path)
  2329. {
  2330. var removeList = new List<NameValuePair>();
  2331. foreach (var contentType in ConfigurationManager.Configuration.ContentTypes)
  2332. {
  2333. if (string.Equals(path, contentType.Name, StringComparison.OrdinalIgnoreCase)
  2334. || _fileSystem.ContainsSubPath(path, contentType.Name))
  2335. {
  2336. removeList.Add(contentType);
  2337. }
  2338. }
  2339. if (removeList.Count > 0)
  2340. {
  2341. ConfigurationManager.Configuration.ContentTypes = ConfigurationManager.Configuration.ContentTypes
  2342. .Except(removeList)
  2343. .ToArray();
  2344. ConfigurationManager.SaveConfiguration();
  2345. }
  2346. }
  2347. public void RemoveMediaPath(string virtualFolderName, string mediaPath)
  2348. {
  2349. if (string.IsNullOrWhiteSpace(mediaPath))
  2350. {
  2351. throw new ArgumentNullException("mediaPath");
  2352. }
  2353. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2354. var path = Path.Combine(rootFolderPath, virtualFolderName);
  2355. if (!_fileSystem.DirectoryExists(path))
  2356. {
  2357. throw new DirectoryNotFoundException(string.Format("The media collection {0} does not exist", virtualFolderName));
  2358. }
  2359. var shortcut = Directory.EnumerateFiles(path, ShortcutFileSearch, SearchOption.AllDirectories).FirstOrDefault(f => _fileSystem.ResolveShortcut(f).Equals(mediaPath, StringComparison.OrdinalIgnoreCase));
  2360. if (!string.IsNullOrEmpty(shortcut))
  2361. {
  2362. _fileSystem.DeleteFile(shortcut);
  2363. }
  2364. }
  2365. }
  2366. }