LibraryManager.cs 110 KB

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