LibraryManager.cs 111 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214
  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. public Guid GetStudioId(string name)
  773. {
  774. return GetItemByNameId<Studio>(Studio.GetPath, name);
  775. }
  776. public Guid GetGenreId(string name)
  777. {
  778. return GetItemByNameId<Genre>(Genre.GetPath, name);
  779. }
  780. public Guid GetMusicGenreId(string name)
  781. {
  782. return GetItemByNameId<MusicGenre>(MusicGenre.GetPath, name);
  783. }
  784. public Guid GetGameGenreId(string name)
  785. {
  786. return GetItemByNameId<GameGenre>(GameGenre.GetPath, name);
  787. }
  788. /// <summary>
  789. /// Gets a Genre
  790. /// </summary>
  791. /// <param name="name">The name.</param>
  792. /// <returns>Task{Genre}.</returns>
  793. public Genre GetGenre(string name)
  794. {
  795. return CreateItemByName<Genre>(Genre.GetPath, name);
  796. }
  797. /// <summary>
  798. /// Gets the genre.
  799. /// </summary>
  800. /// <param name="name">The name.</param>
  801. /// <returns>Task{MusicGenre}.</returns>
  802. public MusicGenre GetMusicGenre(string name)
  803. {
  804. return CreateItemByName<MusicGenre>(MusicGenre.GetPath, name);
  805. }
  806. /// <summary>
  807. /// Gets the game genre.
  808. /// </summary>
  809. /// <param name="name">The name.</param>
  810. /// <returns>Task{GameGenre}.</returns>
  811. public GameGenre GetGameGenre(string name)
  812. {
  813. return CreateItemByName<GameGenre>(GameGenre.GetPath, name);
  814. }
  815. /// <summary>
  816. /// Gets a Year
  817. /// </summary>
  818. /// <param name="value">The value.</param>
  819. /// <returns>Task{Year}.</returns>
  820. /// <exception cref="System.ArgumentOutOfRangeException"></exception>
  821. public Year GetYear(int value)
  822. {
  823. if (value <= 0)
  824. {
  825. throw new ArgumentOutOfRangeException("Years less than or equal to 0 are invalid.");
  826. }
  827. var name = value.ToString(CultureInfo.InvariantCulture);
  828. return CreateItemByName<Year>(Year.GetPath, name);
  829. }
  830. /// <summary>
  831. /// Gets a Genre
  832. /// </summary>
  833. /// <param name="name">The name.</param>
  834. /// <returns>Task{Genre}.</returns>
  835. public MusicArtist GetArtist(string name)
  836. {
  837. return CreateItemByName<MusicArtist>(MusicArtist.GetPath, name);
  838. }
  839. private T CreateItemByName<T>(Func<string, string> getPathFn, string name)
  840. where T : BaseItem, new()
  841. {
  842. if (typeof(T) == typeof(MusicArtist))
  843. {
  844. var existing = GetItemList(new InternalItemsQuery
  845. {
  846. IncludeItemTypes = new[] { typeof(T).Name },
  847. Name = name
  848. }).Cast<MusicArtist>()
  849. .OrderBy(i => i.IsAccessedByName ? 1 : 0)
  850. .Cast<T>()
  851. .FirstOrDefault();
  852. if (existing != null)
  853. {
  854. return existing;
  855. }
  856. }
  857. var id = GetItemByNameId<T>(getPathFn, name);
  858. var item = GetItemById(id) as T;
  859. if (item == null)
  860. {
  861. var path = getPathFn(name);
  862. item = new T
  863. {
  864. Name = name,
  865. Id = id,
  866. DateCreated = DateTime.UtcNow,
  867. DateModified = DateTime.UtcNow,
  868. Path = path
  869. };
  870. var task = CreateItem(item, CancellationToken.None);
  871. Task.WaitAll(task);
  872. }
  873. return item;
  874. }
  875. private Guid GetItemByNameId<T>(Func<string, string> getPathFn, string name)
  876. where T : BaseItem, new()
  877. {
  878. var path = getPathFn(name);
  879. var forceCaseInsensitiveId = ConfigurationManager.Configuration.EnableNormalizedItemByNameIds;
  880. return GetNewItemIdInternal(path, typeof(T), forceCaseInsensitiveId);
  881. }
  882. public IEnumerable<MusicArtist> GetAlbumArtists(IEnumerable<IHasAlbumArtist> items)
  883. {
  884. var names = items
  885. .SelectMany(i => i.AlbumArtists)
  886. .DistinctNames()
  887. .Select(i =>
  888. {
  889. try
  890. {
  891. var artist = GetArtist(i);
  892. return artist;
  893. }
  894. catch
  895. {
  896. // Already logged at lower levels
  897. return null;
  898. }
  899. })
  900. .Where(i => i != null);
  901. return names;
  902. }
  903. public IEnumerable<MusicArtist> GetArtists(IEnumerable<IHasArtist> items)
  904. {
  905. var names = items
  906. .SelectMany(i => i.AllArtists)
  907. .DistinctNames()
  908. .Select(i =>
  909. {
  910. try
  911. {
  912. var artist = GetArtist(i);
  913. return artist;
  914. }
  915. catch
  916. {
  917. // Already logged at lower levels
  918. return null;
  919. }
  920. })
  921. .Where(i => i != null);
  922. return names;
  923. }
  924. /// <summary>
  925. /// Validate and refresh the People sub-set of the IBN.
  926. /// The items are stored in the db but not loaded into memory until actually requested by an operation.
  927. /// </summary>
  928. /// <param name="cancellationToken">The cancellation token.</param>
  929. /// <param name="progress">The progress.</param>
  930. /// <returns>Task.</returns>
  931. public Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
  932. {
  933. // Ensure the location is available.
  934. _fileSystem.CreateDirectory(ConfigurationManager.ApplicationPaths.PeoplePath);
  935. return new PeopleValidator(this, _logger, ConfigurationManager, _fileSystem).ValidatePeople(cancellationToken, progress);
  936. }
  937. /// <summary>
  938. /// Reloads the root media folder
  939. /// </summary>
  940. /// <param name="progress">The progress.</param>
  941. /// <param name="cancellationToken">The cancellation token.</param>
  942. /// <returns>Task.</returns>
  943. public Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
  944. {
  945. // Just run the scheduled task so that the user can see it
  946. _taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
  947. return Task.FromResult(true);
  948. }
  949. /// <summary>
  950. /// Queues the library scan.
  951. /// </summary>
  952. public void QueueLibraryScan()
  953. {
  954. // Just run the scheduled task so that the user can see it
  955. _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
  956. }
  957. /// <summary>
  958. /// Validates the media library internal.
  959. /// </summary>
  960. /// <param name="progress">The progress.</param>
  961. /// <param name="cancellationToken">The cancellation token.</param>
  962. /// <returns>Task.</returns>
  963. public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
  964. {
  965. IsScanRunning = true;
  966. _libraryMonitorFactory().Stop();
  967. try
  968. {
  969. await PerformLibraryValidation(progress, cancellationToken).ConfigureAwait(false);
  970. if (!ConfigurationManager.Configuration.EnableSeriesPresentationUniqueKey)
  971. {
  972. ConfigurationManager.Configuration.EnableSeriesPresentationUniqueKey = true;
  973. ConfigurationManager.SaveConfiguration();
  974. }
  975. }
  976. finally
  977. {
  978. _libraryMonitorFactory().Start();
  979. IsScanRunning = false;
  980. }
  981. }
  982. private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
  983. {
  984. _logger.Info("Validating media library");
  985. // Ensure these objects are lazy loaded.
  986. // Without this there is a deadlock that will need to be investigated
  987. var rootChildren = RootFolder.Children.ToList();
  988. rootChildren = GetUserRootFolder().Children.ToList();
  989. await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  990. progress.Report(.5);
  991. // Start by just validating the children of the root, but go no further
  992. await RootFolder.ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false);
  993. progress.Report(1);
  994. await GetUserRootFolder().RefreshMetadata(cancellationToken).ConfigureAwait(false);
  995. await GetUserRootFolder().ValidateChildren(new Progress<double>(), cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: false).ConfigureAwait(false);
  996. progress.Report(2);
  997. // Quickly scan CollectionFolders for changes
  998. foreach (var folder in GetUserRootFolder().Children.OfType<Folder>().ToList())
  999. {
  1000. await folder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
  1001. }
  1002. progress.Report(3);
  1003. var innerProgress = new ActionableProgress<double>();
  1004. innerProgress.RegisterAction(pct => progress.Report(3 + pct * .72));
  1005. // Now validate the entire media library
  1006. await RootFolder.ValidateChildren(innerProgress, cancellationToken, new MetadataRefreshOptions(_fileSystem), recursive: true).ConfigureAwait(false);
  1007. progress.Report(75);
  1008. innerProgress = new ActionableProgress<double>();
  1009. innerProgress.RegisterAction(pct => progress.Report(75 + pct * .25));
  1010. // Run post-scan tasks
  1011. await RunPostScanTasks(innerProgress, cancellationToken).ConfigureAwait(false);
  1012. progress.Report(100);
  1013. }
  1014. /// <summary>
  1015. /// Runs the post scan tasks.
  1016. /// </summary>
  1017. /// <param name="progress">The progress.</param>
  1018. /// <param name="cancellationToken">The cancellation token.</param>
  1019. /// <returns>Task.</returns>
  1020. private async Task RunPostScanTasks(IProgress<double> progress, CancellationToken cancellationToken)
  1021. {
  1022. var tasks = PostscanTasks.ToList();
  1023. var numComplete = 0;
  1024. var numTasks = tasks.Count;
  1025. foreach (var task in tasks)
  1026. {
  1027. var innerProgress = new ActionableProgress<double>();
  1028. // Prevent access to modified closure
  1029. var currentNumComplete = numComplete;
  1030. innerProgress.RegisterAction(pct =>
  1031. {
  1032. double innerPercent = currentNumComplete * 100 + pct;
  1033. innerPercent /= numTasks;
  1034. progress.Report(innerPercent);
  1035. });
  1036. _logger.Debug("Running post-scan task {0}", task.GetType().Name);
  1037. try
  1038. {
  1039. await task.Run(innerProgress, cancellationToken).ConfigureAwait(false);
  1040. }
  1041. catch (OperationCanceledException)
  1042. {
  1043. _logger.Info("Post-scan task cancelled: {0}", task.GetType().Name);
  1044. throw;
  1045. }
  1046. catch (Exception ex)
  1047. {
  1048. _logger.ErrorException("Error running postscan task", ex);
  1049. }
  1050. numComplete++;
  1051. double percent = numComplete;
  1052. percent /= numTasks;
  1053. progress.Report(percent * 100);
  1054. }
  1055. progress.Report(100);
  1056. }
  1057. /// <summary>
  1058. /// Gets the default view.
  1059. /// </summary>
  1060. /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
  1061. public IEnumerable<VirtualFolderInfo> GetVirtualFolders()
  1062. {
  1063. return GetView(ConfigurationManager.ApplicationPaths.DefaultUserViewsPath);
  1064. }
  1065. /// <summary>
  1066. /// Gets the view.
  1067. /// </summary>
  1068. /// <param name="path">The path.</param>
  1069. /// <returns>IEnumerable{VirtualFolderInfo}.</returns>
  1070. private IEnumerable<VirtualFolderInfo> GetView(string path)
  1071. {
  1072. var topLibraryFolders = GetUserRootFolder().Children.ToList();
  1073. return _fileSystem.GetDirectoryPaths(path)
  1074. .Select(dir => GetVirtualFolderInfo(dir, topLibraryFolders));
  1075. }
  1076. private VirtualFolderInfo GetVirtualFolderInfo(string dir, List<BaseItem> allCollectionFolders)
  1077. {
  1078. var info = new VirtualFolderInfo
  1079. {
  1080. Name = Path.GetFileName(dir),
  1081. Locations = _fileSystem.GetFilePaths(dir, false)
  1082. .Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
  1083. .Select(_fileSystem.ResolveShortcut)
  1084. .OrderBy(i => i)
  1085. .ToList(),
  1086. CollectionType = GetCollectionType(dir)
  1087. };
  1088. var libraryFolder = allCollectionFolders.FirstOrDefault(i => string.Equals(i.Path, dir, StringComparison.OrdinalIgnoreCase));
  1089. if (libraryFolder != null && libraryFolder.HasImage(ImageType.Primary))
  1090. {
  1091. info.PrimaryImageItemId = libraryFolder.Id.ToString("N");
  1092. }
  1093. if (libraryFolder != null)
  1094. {
  1095. info.ItemId = libraryFolder.Id.ToString("N");
  1096. info.LibraryOptions = GetLibraryOptions(libraryFolder);
  1097. }
  1098. return info;
  1099. }
  1100. private string GetCollectionType(string path)
  1101. {
  1102. return _fileSystem.GetFilePaths(path, new[] { ".collection" }, true, false)
  1103. .Select(i => _fileSystem.GetFileNameWithoutExtension(i))
  1104. .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
  1105. }
  1106. /// <summary>
  1107. /// Gets the item by id.
  1108. /// </summary>
  1109. /// <param name="id">The id.</param>
  1110. /// <returns>BaseItem.</returns>
  1111. /// <exception cref="System.ArgumentNullException">id</exception>
  1112. public BaseItem GetItemById(Guid id)
  1113. {
  1114. if (id == Guid.Empty)
  1115. {
  1116. throw new ArgumentNullException("id");
  1117. }
  1118. BaseItem item;
  1119. if (LibraryItemsCache.TryGetValue(id, out item))
  1120. {
  1121. return item;
  1122. }
  1123. item = RetrieveItem(id);
  1124. //_logger.Debug("GetitemById {0}", id);
  1125. if (item != null)
  1126. {
  1127. RegisterItem(item);
  1128. }
  1129. return item;
  1130. }
  1131. public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query)
  1132. {
  1133. if (query.Recursive && query.ParentId.HasValue)
  1134. {
  1135. var parent = GetItemById(query.ParentId.Value);
  1136. if (parent != null)
  1137. {
  1138. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1139. }
  1140. }
  1141. if (query.User != null)
  1142. {
  1143. AddUserToQuery(query, query.User);
  1144. }
  1145. return ItemRepository.GetItemList(query);
  1146. }
  1147. public int GetCount(InternalItemsQuery query)
  1148. {
  1149. if (query.Recursive && query.ParentId.HasValue)
  1150. {
  1151. var parent = GetItemById(query.ParentId.Value);
  1152. if (parent != null)
  1153. {
  1154. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1155. }
  1156. }
  1157. if (query.User != null)
  1158. {
  1159. AddUserToQuery(query, query.User);
  1160. }
  1161. return ItemRepository.GetCount(query);
  1162. }
  1163. public IEnumerable<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
  1164. {
  1165. SetTopParentIdsOrAncestors(query, parents);
  1166. if (query.AncestorIds.Length == 0 && query.TopParentIds.Length == 0)
  1167. {
  1168. if (query.User != null)
  1169. {
  1170. AddUserToQuery(query, query.User);
  1171. }
  1172. }
  1173. return ItemRepository.GetItemList(query);
  1174. }
  1175. public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
  1176. {
  1177. if (query.User != null)
  1178. {
  1179. AddUserToQuery(query, query.User);
  1180. }
  1181. if (query.EnableTotalRecordCount)
  1182. {
  1183. return ItemRepository.GetItems(query);
  1184. }
  1185. return new QueryResult<BaseItem>
  1186. {
  1187. Items = ItemRepository.GetItemList(query).ToArray()
  1188. };
  1189. }
  1190. public List<Guid> GetItemIds(InternalItemsQuery query)
  1191. {
  1192. if (query.User != null)
  1193. {
  1194. AddUserToQuery(query, query.User);
  1195. }
  1196. return ItemRepository.GetItemIdsList(query);
  1197. }
  1198. public QueryResult<Tuple<BaseItem, ItemCounts>> GetStudios(InternalItemsQuery query)
  1199. {
  1200. if (query.User != null)
  1201. {
  1202. AddUserToQuery(query, query.User);
  1203. }
  1204. SetTopParentOrAncestorIds(query);
  1205. return ItemRepository.GetStudios(query);
  1206. }
  1207. public QueryResult<Tuple<BaseItem, ItemCounts>> GetGenres(InternalItemsQuery query)
  1208. {
  1209. if (query.User != null)
  1210. {
  1211. AddUserToQuery(query, query.User);
  1212. }
  1213. SetTopParentOrAncestorIds(query);
  1214. return ItemRepository.GetGenres(query);
  1215. }
  1216. public QueryResult<Tuple<BaseItem, ItemCounts>> GetGameGenres(InternalItemsQuery query)
  1217. {
  1218. if (query.User != null)
  1219. {
  1220. AddUserToQuery(query, query.User);
  1221. }
  1222. SetTopParentOrAncestorIds(query);
  1223. return ItemRepository.GetGameGenres(query);
  1224. }
  1225. public QueryResult<Tuple<BaseItem, ItemCounts>> GetMusicGenres(InternalItemsQuery query)
  1226. {
  1227. if (query.User != null)
  1228. {
  1229. AddUserToQuery(query, query.User);
  1230. }
  1231. SetTopParentOrAncestorIds(query);
  1232. return ItemRepository.GetMusicGenres(query);
  1233. }
  1234. public QueryResult<Tuple<BaseItem, ItemCounts>> GetAllArtists(InternalItemsQuery query)
  1235. {
  1236. if (query.User != null)
  1237. {
  1238. AddUserToQuery(query, query.User);
  1239. }
  1240. SetTopParentOrAncestorIds(query);
  1241. return ItemRepository.GetAllArtists(query);
  1242. }
  1243. public QueryResult<Tuple<BaseItem, ItemCounts>> GetArtists(InternalItemsQuery query)
  1244. {
  1245. if (query.User != null)
  1246. {
  1247. AddUserToQuery(query, query.User);
  1248. }
  1249. SetTopParentOrAncestorIds(query);
  1250. return ItemRepository.GetArtists(query);
  1251. }
  1252. private void SetTopParentOrAncestorIds(InternalItemsQuery query)
  1253. {
  1254. if (query.AncestorIds.Length == 0)
  1255. {
  1256. return;
  1257. }
  1258. var parents = query.AncestorIds.Select(i => GetItemById(new Guid(i))).ToList();
  1259. if (parents.All(i =>
  1260. {
  1261. if (i is ICollectionFolder || i is UserView)
  1262. {
  1263. return true;
  1264. }
  1265. //_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
  1266. return false;
  1267. }))
  1268. {
  1269. // Optimize by querying against top level views
  1270. query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).Select(i => i.ToString("N")).ToArray();
  1271. query.AncestorIds = new string[] { };
  1272. // Prevent searching in all libraries due to empty filter
  1273. if (query.TopParentIds.Length == 0)
  1274. {
  1275. query.TopParentIds = new[] { Guid.NewGuid().ToString("N") };
  1276. }
  1277. }
  1278. }
  1279. public QueryResult<Tuple<BaseItem, ItemCounts>> GetAlbumArtists(InternalItemsQuery query)
  1280. {
  1281. if (query.User != null)
  1282. {
  1283. AddUserToQuery(query, query.User);
  1284. }
  1285. SetTopParentOrAncestorIds(query);
  1286. return ItemRepository.GetAlbumArtists(query);
  1287. }
  1288. public QueryResult<BaseItem> GetItemsResult(InternalItemsQuery query)
  1289. {
  1290. if (query.Recursive && query.ParentId.HasValue)
  1291. {
  1292. var parent = GetItemById(query.ParentId.Value);
  1293. if (parent != null)
  1294. {
  1295. SetTopParentIdsOrAncestors(query, new List<BaseItem> { parent });
  1296. }
  1297. }
  1298. if (query.User != null)
  1299. {
  1300. AddUserToQuery(query, query.User);
  1301. }
  1302. if (query.EnableTotalRecordCount)
  1303. {
  1304. return ItemRepository.GetItems(query);
  1305. }
  1306. return new QueryResult<BaseItem>
  1307. {
  1308. Items = ItemRepository.GetItemList(query).ToArray()
  1309. };
  1310. }
  1311. private void SetTopParentIdsOrAncestors(InternalItemsQuery query, List<BaseItem> parents)
  1312. {
  1313. if (parents.All(i =>
  1314. {
  1315. if (i is ICollectionFolder || i is UserView)
  1316. {
  1317. return true;
  1318. }
  1319. //_logger.Debug("Query requires ancestor query due to type: " + i.GetType().Name);
  1320. return false;
  1321. }))
  1322. {
  1323. // Optimize by querying against top level views
  1324. query.TopParentIds = parents.SelectMany(i => GetTopParentIdsForQuery(i, query.User)).Select(i => i.ToString("N")).ToArray();
  1325. // Prevent searching in all libraries due to empty filter
  1326. if (query.TopParentIds.Length == 0)
  1327. {
  1328. query.TopParentIds = new[] { Guid.NewGuid().ToString("N") };
  1329. }
  1330. }
  1331. else
  1332. {
  1333. // We need to be able to query from any arbitrary ancestor up the tree
  1334. query.AncestorIds = parents.SelectMany(i => i.GetIdsForAncestorQuery()).Select(i => i.ToString("N")).ToArray();
  1335. // Prevent searching in all libraries due to empty filter
  1336. if (query.AncestorIds.Length == 0)
  1337. {
  1338. query.AncestorIds = new[] { Guid.NewGuid().ToString("N") };
  1339. }
  1340. }
  1341. query.ParentId = null;
  1342. }
  1343. private void AddUserToQuery(InternalItemsQuery query, User user)
  1344. {
  1345. if (query.AncestorIds.Length == 0 &&
  1346. !query.ParentId.HasValue &&
  1347. query.ChannelIds.Length == 0 &&
  1348. query.TopParentIds.Length == 0 &&
  1349. string.IsNullOrWhiteSpace(query.AncestorWithPresentationUniqueKey) &&
  1350. string.IsNullOrWhiteSpace(query.SeriesPresentationUniqueKey) &&
  1351. query.ItemIds.Length == 0)
  1352. {
  1353. var userViews = _userviewManager().GetUserViews(new UserViewQuery
  1354. {
  1355. UserId = user.Id.ToString("N"),
  1356. IncludeHidden = true
  1357. }, CancellationToken.None).Result.ToList();
  1358. query.TopParentIds = userViews.SelectMany(i => GetTopParentIdsForQuery(i, user)).Select(i => i.ToString("N")).ToArray();
  1359. }
  1360. }
  1361. private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User user)
  1362. {
  1363. var view = item as UserView;
  1364. if (view != null)
  1365. {
  1366. if (string.Equals(view.ViewType, CollectionType.LiveTv))
  1367. {
  1368. return new[] { view.Id };
  1369. }
  1370. if (string.Equals(view.ViewType, CollectionType.Channels))
  1371. {
  1372. var channelResult = BaseItem.ChannelManager.GetChannelsInternal(new ChannelQuery
  1373. {
  1374. UserId = user.Id.ToString("N")
  1375. }, CancellationToken.None).Result;
  1376. return channelResult.Items.Select(i => i.Id);
  1377. }
  1378. // Translate view into folders
  1379. if (view.DisplayParentId != Guid.Empty)
  1380. {
  1381. var displayParent = GetItemById(view.DisplayParentId);
  1382. if (displayParent != null)
  1383. {
  1384. return GetTopParentIdsForQuery(displayParent, user);
  1385. }
  1386. return new Guid[] { };
  1387. }
  1388. if (view.ParentId != Guid.Empty)
  1389. {
  1390. var displayParent = GetItemById(view.ParentId);
  1391. if (displayParent != null)
  1392. {
  1393. return GetTopParentIdsForQuery(displayParent, user);
  1394. }
  1395. return new Guid[] { };
  1396. }
  1397. // Handle grouping
  1398. if (user != null && !string.IsNullOrWhiteSpace(view.ViewType) && UserView.IsEligibleForGrouping(view.ViewType) && user.Configuration.GroupedFolders.Length > 0)
  1399. {
  1400. return user.RootFolder
  1401. .GetChildren(user, true)
  1402. .OfType<CollectionFolder>()
  1403. .Where(i => string.IsNullOrWhiteSpace(i.CollectionType) || string.Equals(i.CollectionType, view.ViewType, StringComparison.OrdinalIgnoreCase))
  1404. .Where(i => user.IsFolderGrouped(i.Id))
  1405. .SelectMany(i => GetTopParentIdsForQuery(i, user));
  1406. }
  1407. return new Guid[] { };
  1408. }
  1409. var collectionFolder = item as CollectionFolder;
  1410. if (collectionFolder != null)
  1411. {
  1412. return collectionFolder.PhysicalFolderIds;
  1413. }
  1414. var topParent = item.GetTopParent();
  1415. if (topParent != null)
  1416. {
  1417. return new[] { topParent.Id };
  1418. }
  1419. return new Guid[] { };
  1420. }
  1421. /// <summary>
  1422. /// Gets the intros.
  1423. /// </summary>
  1424. /// <param name="item">The item.</param>
  1425. /// <param name="user">The user.</param>
  1426. /// <returns>IEnumerable{System.String}.</returns>
  1427. public async Task<IEnumerable<Video>> GetIntros(BaseItem item, User user)
  1428. {
  1429. var tasks = IntroProviders
  1430. .OrderBy(i => i.GetType().Name.IndexOf("Default", StringComparison.OrdinalIgnoreCase) == -1 ? 0 : 1)
  1431. .Take(1)
  1432. .Select(i => GetIntros(i, item, user));
  1433. var items = await Task.WhenAll(tasks).ConfigureAwait(false);
  1434. return items
  1435. .SelectMany(i => i.ToArray())
  1436. .Select(ResolveIntro)
  1437. .Where(i => i != null);
  1438. }
  1439. /// <summary>
  1440. /// Gets the intros.
  1441. /// </summary>
  1442. /// <param name="provider">The provider.</param>
  1443. /// <param name="item">The item.</param>
  1444. /// <param name="user">The user.</param>
  1445. /// <returns>Task&lt;IEnumerable&lt;IntroInfo&gt;&gt;.</returns>
  1446. private async Task<IEnumerable<IntroInfo>> GetIntros(IIntroProvider provider, BaseItem item, User user)
  1447. {
  1448. try
  1449. {
  1450. return await provider.GetIntros(item, user).ConfigureAwait(false);
  1451. }
  1452. catch (Exception ex)
  1453. {
  1454. _logger.ErrorException("Error getting intros", ex);
  1455. return new List<IntroInfo>();
  1456. }
  1457. }
  1458. /// <summary>
  1459. /// Gets all intro files.
  1460. /// </summary>
  1461. /// <returns>IEnumerable{System.String}.</returns>
  1462. public IEnumerable<string> GetAllIntroFiles()
  1463. {
  1464. return IntroProviders.SelectMany(i =>
  1465. {
  1466. try
  1467. {
  1468. return i.GetAllIntroFiles().ToList();
  1469. }
  1470. catch (Exception ex)
  1471. {
  1472. _logger.ErrorException("Error getting intro files", ex);
  1473. return new List<string>();
  1474. }
  1475. });
  1476. }
  1477. /// <summary>
  1478. /// Resolves the intro.
  1479. /// </summary>
  1480. /// <param name="info">The info.</param>
  1481. /// <returns>Video.</returns>
  1482. private Video ResolveIntro(IntroInfo info)
  1483. {
  1484. Video video = null;
  1485. if (info.ItemId.HasValue)
  1486. {
  1487. // Get an existing item by Id
  1488. video = GetItemById(info.ItemId.Value) as Video;
  1489. if (video == null)
  1490. {
  1491. _logger.Error("Unable to locate item with Id {0}.", info.ItemId.Value);
  1492. }
  1493. }
  1494. else if (!string.IsNullOrEmpty(info.Path))
  1495. {
  1496. try
  1497. {
  1498. // Try to resolve the path into a video
  1499. video = ResolvePath(_fileSystem.GetFileSystemInfo(info.Path)) as Video;
  1500. if (video == null)
  1501. {
  1502. _logger.Error("Intro resolver returned null for {0}.", info.Path);
  1503. }
  1504. else
  1505. {
  1506. // Pull the saved db item that will include metadata
  1507. var dbItem = GetItemById(video.Id) as Video;
  1508. if (dbItem != null)
  1509. {
  1510. video = dbItem;
  1511. }
  1512. else
  1513. {
  1514. return null;
  1515. }
  1516. }
  1517. }
  1518. catch (Exception ex)
  1519. {
  1520. _logger.ErrorException("Error resolving path {0}.", ex, info.Path);
  1521. }
  1522. }
  1523. else
  1524. {
  1525. _logger.Error("IntroProvider returned an IntroInfo with null Path and ItemId.");
  1526. }
  1527. return video;
  1528. }
  1529. /// <summary>
  1530. /// Sorts the specified sort by.
  1531. /// </summary>
  1532. /// <param name="items">The items.</param>
  1533. /// <param name="user">The user.</param>
  1534. /// <param name="sortBy">The sort by.</param>
  1535. /// <param name="sortOrder">The sort order.</param>
  1536. /// <returns>IEnumerable{BaseItem}.</returns>
  1537. public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User user, IEnumerable<string> sortBy, SortOrder sortOrder)
  1538. {
  1539. var isFirst = true;
  1540. IOrderedEnumerable<BaseItem> orderedItems = null;
  1541. foreach (var orderBy in sortBy.Select(o => GetComparer(o, user)).Where(c => c != null))
  1542. {
  1543. if (isFirst)
  1544. {
  1545. orderedItems = sortOrder == SortOrder.Descending ? items.OrderByDescending(i => i, orderBy) : items.OrderBy(i => i, orderBy);
  1546. }
  1547. else
  1548. {
  1549. orderedItems = sortOrder == SortOrder.Descending ? orderedItems.ThenByDescending(i => i, orderBy) : orderedItems.ThenBy(i => i, orderBy);
  1550. }
  1551. isFirst = false;
  1552. }
  1553. return orderedItems ?? items;
  1554. }
  1555. /// <summary>
  1556. /// Gets the comparer.
  1557. /// </summary>
  1558. /// <param name="name">The name.</param>
  1559. /// <param name="user">The user.</param>
  1560. /// <returns>IBaseItemComparer.</returns>
  1561. private IBaseItemComparer GetComparer(string name, User user)
  1562. {
  1563. var comparer = Comparers.FirstOrDefault(c => string.Equals(name, c.Name, StringComparison.OrdinalIgnoreCase));
  1564. if (comparer != null)
  1565. {
  1566. // If it requires a user, create a new one, and assign the user
  1567. if (comparer is IUserBaseItemComparer)
  1568. {
  1569. var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType());
  1570. userComparer.User = user;
  1571. userComparer.UserManager = _userManager;
  1572. userComparer.UserDataRepository = _userDataRepository;
  1573. return userComparer;
  1574. }
  1575. }
  1576. return comparer;
  1577. }
  1578. /// <summary>
  1579. /// Creates the item.
  1580. /// </summary>
  1581. /// <param name="item">The item.</param>
  1582. /// <param name="cancellationToken">The cancellation token.</param>
  1583. /// <returns>Task.</returns>
  1584. public Task CreateItem(BaseItem item, CancellationToken cancellationToken)
  1585. {
  1586. return CreateItems(new[] { item }, cancellationToken);
  1587. }
  1588. /// <summary>
  1589. /// Creates the items.
  1590. /// </summary>
  1591. /// <param name="items">The items.</param>
  1592. /// <param name="cancellationToken">The cancellation token.</param>
  1593. /// <returns>Task.</returns>
  1594. public async Task CreateItems(IEnumerable<BaseItem> items, CancellationToken cancellationToken)
  1595. {
  1596. var list = items.ToList();
  1597. await ItemRepository.SaveItems(list, cancellationToken).ConfigureAwait(false);
  1598. foreach (var item in list)
  1599. {
  1600. RegisterItem(item);
  1601. }
  1602. if (ItemAdded != null)
  1603. {
  1604. foreach (var item in list)
  1605. {
  1606. try
  1607. {
  1608. ItemAdded(this, new ItemChangeEventArgs { Item = item });
  1609. }
  1610. catch (Exception ex)
  1611. {
  1612. _logger.ErrorException("Error in ItemAdded event handler", ex);
  1613. }
  1614. }
  1615. }
  1616. }
  1617. /// <summary>
  1618. /// Updates the item.
  1619. /// </summary>
  1620. /// <param name="item">The item.</param>
  1621. /// <param name="updateReason">The update reason.</param>
  1622. /// <param name="cancellationToken">The cancellation token.</param>
  1623. /// <returns>Task.</returns>
  1624. public async Task UpdateItem(BaseItem item, ItemUpdateType updateReason, CancellationToken cancellationToken)
  1625. {
  1626. var locationType = item.LocationType;
  1627. if (locationType != LocationType.Remote && locationType != LocationType.Virtual)
  1628. {
  1629. await _providerManagerFactory().SaveMetadata(item, updateReason).ConfigureAwait(false);
  1630. }
  1631. item.DateLastSaved = DateTime.UtcNow;
  1632. var logName = item.LocationType == LocationType.Remote ? item.Name ?? item.Path : item.Path ?? item.Name;
  1633. _logger.Debug("Saving {0} to database.", logName);
  1634. await ItemRepository.SaveItem(item, cancellationToken).ConfigureAwait(false);
  1635. RegisterItem(item);
  1636. if (ItemUpdated != null)
  1637. {
  1638. try
  1639. {
  1640. ItemUpdated(this, new ItemChangeEventArgs
  1641. {
  1642. Item = item,
  1643. UpdateReason = updateReason
  1644. });
  1645. }
  1646. catch (Exception ex)
  1647. {
  1648. _logger.ErrorException("Error in ItemUpdated event handler", ex);
  1649. }
  1650. }
  1651. }
  1652. /// <summary>
  1653. /// Reports the item removed.
  1654. /// </summary>
  1655. /// <param name="item">The item.</param>
  1656. public void ReportItemRemoved(BaseItem item)
  1657. {
  1658. if (ItemRemoved != null)
  1659. {
  1660. try
  1661. {
  1662. ItemRemoved(this, new ItemChangeEventArgs { Item = item });
  1663. }
  1664. catch (Exception ex)
  1665. {
  1666. _logger.ErrorException("Error in ItemRemoved event handler", ex);
  1667. }
  1668. }
  1669. }
  1670. /// <summary>
  1671. /// Retrieves the item.
  1672. /// </summary>
  1673. /// <param name="id">The id.</param>
  1674. /// <returns>BaseItem.</returns>
  1675. public BaseItem RetrieveItem(Guid id)
  1676. {
  1677. return ItemRepository.RetrieveItem(id);
  1678. }
  1679. public List<Folder> GetCollectionFolders(BaseItem item)
  1680. {
  1681. while (item != null)
  1682. {
  1683. var parent = item.GetParent();
  1684. if (parent == null || parent is AggregateFolder)
  1685. {
  1686. break;
  1687. }
  1688. item = parent;
  1689. }
  1690. if (item == null)
  1691. {
  1692. return new List<Folder>();
  1693. }
  1694. return GetCollectionFoldersInternal(item, GetUserRootFolder().Children.OfType<Folder>().ToList());
  1695. }
  1696. public List<Folder> GetCollectionFolders(BaseItem item, List<Folder> allUserRootChildren)
  1697. {
  1698. while (item != null)
  1699. {
  1700. var parent = item.GetParent();
  1701. if (parent == null || parent is AggregateFolder)
  1702. {
  1703. break;
  1704. }
  1705. item = parent;
  1706. }
  1707. if (item == null)
  1708. {
  1709. return new List<Folder>();
  1710. }
  1711. return GetCollectionFoldersInternal(item, allUserRootChildren);
  1712. }
  1713. private List<Folder> GetCollectionFoldersInternal(BaseItem item, List<Folder> allUserRootChildren)
  1714. {
  1715. return allUserRootChildren
  1716. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path, StringComparer.OrdinalIgnoreCase))
  1717. .ToList();
  1718. }
  1719. public LibraryOptions GetLibraryOptions(BaseItem item)
  1720. {
  1721. var collectionFolder = item as CollectionFolder;
  1722. if (collectionFolder == null)
  1723. {
  1724. collectionFolder = GetCollectionFolders(item)
  1725. .OfType<CollectionFolder>()
  1726. .FirstOrDefault();
  1727. }
  1728. var options = collectionFolder == null ? new LibraryOptions() : collectionFolder.GetLibraryOptions();
  1729. return options;
  1730. }
  1731. public string GetContentType(BaseItem item)
  1732. {
  1733. string configuredContentType = GetConfiguredContentType(item, false);
  1734. if (!string.IsNullOrWhiteSpace(configuredContentType))
  1735. {
  1736. return configuredContentType;
  1737. }
  1738. configuredContentType = GetConfiguredContentType(item, true);
  1739. if (!string.IsNullOrWhiteSpace(configuredContentType))
  1740. {
  1741. return configuredContentType;
  1742. }
  1743. return GetInheritedContentType(item);
  1744. }
  1745. public string GetInheritedContentType(BaseItem item)
  1746. {
  1747. var type = GetTopFolderContentType(item);
  1748. if (!string.IsNullOrWhiteSpace(type))
  1749. {
  1750. return type;
  1751. }
  1752. return item.GetParents()
  1753. .Select(GetConfiguredContentType)
  1754. .LastOrDefault(i => !string.IsNullOrWhiteSpace(i));
  1755. }
  1756. public string GetConfiguredContentType(BaseItem item)
  1757. {
  1758. return GetConfiguredContentType(item, false);
  1759. }
  1760. public string GetConfiguredContentType(string path)
  1761. {
  1762. return GetContentTypeOverride(path, false);
  1763. }
  1764. public string GetConfiguredContentType(BaseItem item, bool inheritConfiguredPath)
  1765. {
  1766. ICollectionFolder collectionFolder = item as ICollectionFolder;
  1767. if (collectionFolder != null)
  1768. {
  1769. return collectionFolder.CollectionType;
  1770. }
  1771. return GetContentTypeOverride(item.ContainingFolderPath, inheritConfiguredPath);
  1772. }
  1773. private string GetContentTypeOverride(string path, bool inherit)
  1774. {
  1775. var nameValuePair = ConfigurationManager.Configuration.ContentTypes.FirstOrDefault(i => _fileSystem.AreEqual(i.Name, path) || (inherit && !string.IsNullOrWhiteSpace(i.Name) && _fileSystem.ContainsSubPath(i.Name, path)));
  1776. if (nameValuePair != null)
  1777. {
  1778. return nameValuePair.Value;
  1779. }
  1780. return null;
  1781. }
  1782. private string GetTopFolderContentType(BaseItem item)
  1783. {
  1784. if (item == null)
  1785. {
  1786. return null;
  1787. }
  1788. while (!(item.GetParent() is AggregateFolder) && item.GetParent() != null)
  1789. {
  1790. item = item.GetParent();
  1791. }
  1792. return GetUserRootFolder().Children
  1793. .OfType<ICollectionFolder>()
  1794. .Where(i => string.Equals(i.Path, item.Path, StringComparison.OrdinalIgnoreCase) || i.PhysicalLocations.Contains(item.Path))
  1795. .Select(i => i.CollectionType)
  1796. .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i));
  1797. }
  1798. private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromHours(24);
  1799. //private readonly TimeSpan _viewRefreshInterval = TimeSpan.FromMinutes(1);
  1800. public Task<UserView> GetNamedView(User user,
  1801. string name,
  1802. string viewType,
  1803. string sortName,
  1804. CancellationToken cancellationToken)
  1805. {
  1806. return GetNamedView(user, name, null, viewType, sortName, cancellationToken);
  1807. }
  1808. public async Task<UserView> GetNamedView(string name,
  1809. string viewType,
  1810. string sortName,
  1811. CancellationToken cancellationToken)
  1812. {
  1813. var path = Path.Combine(ConfigurationManager.ApplicationPaths.ItemsByNamePath, "views");
  1814. path = Path.Combine(path, _fileSystem.GetValidFilename(viewType));
  1815. var id = GetNewItemId(path + "_namedview_" + name, typeof(UserView));
  1816. var item = GetItemById(id) as UserView;
  1817. var refresh = false;
  1818. if (item == null || !string.Equals(item.Path, path, StringComparison.OrdinalIgnoreCase))
  1819. {
  1820. _fileSystem.CreateDirectory(path);
  1821. item = new UserView
  1822. {
  1823. Path = path,
  1824. Id = id,
  1825. DateCreated = DateTime.UtcNow,
  1826. Name = name,
  1827. ViewType = viewType,
  1828. ForcedSortName = sortName
  1829. };
  1830. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1831. refresh = true;
  1832. }
  1833. if (!refresh)
  1834. {
  1835. refresh = DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1836. }
  1837. if (!refresh && item.DisplayParentId != Guid.Empty)
  1838. {
  1839. var displayParent = GetItemById(item.DisplayParentId);
  1840. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1841. }
  1842. if (refresh)
  1843. {
  1844. await item.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None).ConfigureAwait(false);
  1845. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1846. {
  1847. // Not sure why this is necessary but need to figure it out
  1848. // View images are not getting utilized without this
  1849. ForceSave = true
  1850. }, RefreshPriority.Normal);
  1851. }
  1852. return item;
  1853. }
  1854. public async Task<UserView> GetNamedView(User user,
  1855. string name,
  1856. string parentId,
  1857. string viewType,
  1858. string sortName,
  1859. CancellationToken cancellationToken)
  1860. {
  1861. var idValues = "38_namedview_" + name + user.Id.ToString("N") + (parentId ?? string.Empty) + (viewType ?? string.Empty);
  1862. var id = GetNewItemId(idValues, typeof(UserView));
  1863. var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
  1864. var item = GetItemById(id) as UserView;
  1865. var isNew = false;
  1866. if (item == null)
  1867. {
  1868. _fileSystem.CreateDirectory(path);
  1869. item = new UserView
  1870. {
  1871. Path = path,
  1872. Id = id,
  1873. DateCreated = DateTime.UtcNow,
  1874. Name = name,
  1875. ViewType = viewType,
  1876. ForcedSortName = sortName,
  1877. UserId = user.Id
  1878. };
  1879. if (!string.IsNullOrWhiteSpace(parentId))
  1880. {
  1881. item.DisplayParentId = new Guid(parentId);
  1882. }
  1883. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1884. isNew = true;
  1885. }
  1886. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1887. if (!refresh && item.DisplayParentId != Guid.Empty)
  1888. {
  1889. var displayParent = GetItemById(item.DisplayParentId);
  1890. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1891. }
  1892. if (refresh)
  1893. {
  1894. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1895. {
  1896. // Need to force save to increment DateLastSaved
  1897. ForceSave = true
  1898. }, RefreshPriority.Normal);
  1899. }
  1900. return item;
  1901. }
  1902. public async Task<UserView> GetShadowView(BaseItem parent,
  1903. string viewType,
  1904. string sortName,
  1905. CancellationToken cancellationToken)
  1906. {
  1907. if (parent == null)
  1908. {
  1909. throw new ArgumentNullException("parent");
  1910. }
  1911. var name = parent.Name;
  1912. var parentId = parent.Id;
  1913. var idValues = "38_namedview_" + name + parentId + (viewType ?? string.Empty);
  1914. var id = GetNewItemId(idValues, typeof(UserView));
  1915. var path = parent.Path;
  1916. var item = GetItemById(id) as UserView;
  1917. var isNew = false;
  1918. if (item == null)
  1919. {
  1920. _fileSystem.CreateDirectory(path);
  1921. item = new UserView
  1922. {
  1923. Path = path,
  1924. Id = id,
  1925. DateCreated = DateTime.UtcNow,
  1926. Name = name,
  1927. ViewType = viewType,
  1928. ForcedSortName = sortName
  1929. };
  1930. item.DisplayParentId = parentId;
  1931. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1932. isNew = true;
  1933. }
  1934. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1935. if (!refresh && item.DisplayParentId != Guid.Empty)
  1936. {
  1937. var displayParent = GetItemById(item.DisplayParentId);
  1938. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1939. }
  1940. if (refresh)
  1941. {
  1942. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  1943. {
  1944. // Need to force save to increment DateLastSaved
  1945. ForceSave = true
  1946. }, RefreshPriority.Normal);
  1947. }
  1948. return item;
  1949. }
  1950. public async Task<UserView> GetNamedView(string name,
  1951. string parentId,
  1952. string viewType,
  1953. string sortName,
  1954. string uniqueId,
  1955. CancellationToken cancellationToken)
  1956. {
  1957. if (string.IsNullOrWhiteSpace(name))
  1958. {
  1959. throw new ArgumentNullException("name");
  1960. }
  1961. var idValues = "37_namedview_" + name + (parentId ?? string.Empty) + (viewType ?? string.Empty);
  1962. if (!string.IsNullOrWhiteSpace(uniqueId))
  1963. {
  1964. idValues += uniqueId;
  1965. }
  1966. var id = GetNewItemId(idValues, typeof(UserView));
  1967. var path = Path.Combine(ConfigurationManager.ApplicationPaths.InternalMetadataPath, "views", id.ToString("N"));
  1968. var item = GetItemById(id) as UserView;
  1969. var isNew = false;
  1970. if (item == null)
  1971. {
  1972. _fileSystem.CreateDirectory(path);
  1973. item = new UserView
  1974. {
  1975. Path = path,
  1976. Id = id,
  1977. DateCreated = DateTime.UtcNow,
  1978. Name = name,
  1979. ViewType = viewType,
  1980. ForcedSortName = sortName
  1981. };
  1982. if (!string.IsNullOrWhiteSpace(parentId))
  1983. {
  1984. item.DisplayParentId = new Guid(parentId);
  1985. }
  1986. await CreateItem(item, cancellationToken).ConfigureAwait(false);
  1987. isNew = true;
  1988. }
  1989. if (!string.Equals(viewType, item.ViewType, StringComparison.OrdinalIgnoreCase))
  1990. {
  1991. item.ViewType = viewType;
  1992. await item.UpdateToRepository(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
  1993. }
  1994. var refresh = isNew || DateTime.UtcNow - item.DateLastRefreshed >= _viewRefreshInterval;
  1995. if (!refresh && item.DisplayParentId != Guid.Empty)
  1996. {
  1997. var displayParent = GetItemById(item.DisplayParentId);
  1998. refresh = displayParent != null && displayParent.DateLastSaved > item.DateLastRefreshed;
  1999. }
  2000. if (refresh)
  2001. {
  2002. _providerManagerFactory().QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
  2003. {
  2004. // Need to force save to increment DateLastSaved
  2005. ForceSave = true
  2006. }, RefreshPriority.Normal);
  2007. }
  2008. return item;
  2009. }
  2010. public bool IsVideoFile(string path, LibraryOptions libraryOptions)
  2011. {
  2012. var resolver = new VideoResolver(GetNamingOptions(libraryOptions), new NullLogger());
  2013. return resolver.IsVideoFile(path);
  2014. }
  2015. public bool IsVideoFile(string path)
  2016. {
  2017. return IsVideoFile(path, new LibraryOptions());
  2018. }
  2019. public bool IsAudioFile(string path, LibraryOptions libraryOptions)
  2020. {
  2021. var parser = new AudioFileParser(GetNamingOptions(libraryOptions));
  2022. return parser.IsAudioFile(path);
  2023. }
  2024. public bool IsAudioFile(string path)
  2025. {
  2026. return IsAudioFile(path, new LibraryOptions());
  2027. }
  2028. public int? GetSeasonNumberFromPath(string path)
  2029. {
  2030. return new SeasonPathParser(GetNamingOptions(), new RegexProvider()).Parse(path, true, true).SeasonNumber;
  2031. }
  2032. public bool FillMissingEpisodeNumbersFromPath(Episode episode)
  2033. {
  2034. var resolver = new EpisodeResolver(GetNamingOptions(),
  2035. new NullLogger());
  2036. var isFolder = episode.VideoType == VideoType.BluRay || episode.VideoType == VideoType.Dvd ||
  2037. episode.VideoType == VideoType.HdDvd;
  2038. var locationType = episode.LocationType;
  2039. var episodeInfo = locationType == LocationType.FileSystem || locationType == LocationType.Offline ?
  2040. resolver.Resolve(episode.Path, isFolder) :
  2041. new MediaBrowser.Naming.TV.EpisodeInfo();
  2042. if (episodeInfo == null)
  2043. {
  2044. episodeInfo = new MediaBrowser.Naming.TV.EpisodeInfo();
  2045. }
  2046. var changed = false;
  2047. if (episodeInfo.IsByDate)
  2048. {
  2049. if (episode.IndexNumber.HasValue)
  2050. {
  2051. episode.IndexNumber = null;
  2052. changed = true;
  2053. }
  2054. if (episode.IndexNumberEnd.HasValue)
  2055. {
  2056. episode.IndexNumberEnd = null;
  2057. changed = true;
  2058. }
  2059. if (!episode.PremiereDate.HasValue)
  2060. {
  2061. if (episodeInfo.Year.HasValue && episodeInfo.Month.HasValue && episodeInfo.Day.HasValue)
  2062. {
  2063. episode.PremiereDate = new DateTime(episodeInfo.Year.Value, episodeInfo.Month.Value, episodeInfo.Day.Value).ToUniversalTime();
  2064. }
  2065. if (episode.PremiereDate.HasValue)
  2066. {
  2067. changed = true;
  2068. }
  2069. }
  2070. if (!episode.ProductionYear.HasValue)
  2071. {
  2072. episode.ProductionYear = episodeInfo.Year;
  2073. if (episode.ProductionYear.HasValue)
  2074. {
  2075. changed = true;
  2076. }
  2077. }
  2078. if (!episode.ParentIndexNumber.HasValue)
  2079. {
  2080. var season = episode.Season;
  2081. if (season != null)
  2082. {
  2083. episode.ParentIndexNumber = season.IndexNumber;
  2084. }
  2085. if (episode.ParentIndexNumber.HasValue)
  2086. {
  2087. changed = true;
  2088. }
  2089. }
  2090. }
  2091. else
  2092. {
  2093. if (!episode.IndexNumber.HasValue)
  2094. {
  2095. episode.IndexNumber = episodeInfo.EpisodeNumber;
  2096. if (episode.IndexNumber.HasValue)
  2097. {
  2098. changed = true;
  2099. }
  2100. }
  2101. if (!episode.IndexNumberEnd.HasValue)
  2102. {
  2103. episode.IndexNumberEnd = episodeInfo.EndingEpsiodeNumber;
  2104. if (episode.IndexNumberEnd.HasValue)
  2105. {
  2106. changed = true;
  2107. }
  2108. }
  2109. if (!episode.ParentIndexNumber.HasValue)
  2110. {
  2111. episode.ParentIndexNumber = episodeInfo.SeasonNumber;
  2112. if (!episode.ParentIndexNumber.HasValue)
  2113. {
  2114. var season = episode.Season;
  2115. if (season != null)
  2116. {
  2117. episode.ParentIndexNumber = season.IndexNumber;
  2118. }
  2119. }
  2120. if (episode.ParentIndexNumber.HasValue)
  2121. {
  2122. changed = true;
  2123. }
  2124. }
  2125. }
  2126. return changed;
  2127. }
  2128. public NamingOptions GetNamingOptions()
  2129. {
  2130. return GetNamingOptions(new LibraryOptions());
  2131. }
  2132. private NamingOptions _namingOptions;
  2133. private string[] _videoFileExtensions;
  2134. public NamingOptions GetNamingOptions(LibraryOptions libraryOptions)
  2135. {
  2136. if (_namingOptions == null)
  2137. {
  2138. var options = new ExtendedNamingOptions();
  2139. // These cause apps to have problems
  2140. options.AudioFileExtensions.Remove(".m3u");
  2141. options.AudioFileExtensions.Remove(".wpl");
  2142. //if (!libraryOptions.EnableArchiveMediaFiles)
  2143. {
  2144. options.AudioFileExtensions.Remove(".rar");
  2145. options.AudioFileExtensions.Remove(".zip");
  2146. }
  2147. //if (!libraryOptions.EnableArchiveMediaFiles)
  2148. {
  2149. options.VideoFileExtensions.Remove(".rar");
  2150. options.VideoFileExtensions.Remove(".zip");
  2151. }
  2152. options.VideoFileExtensions.Add(".tp");
  2153. _namingOptions = options;
  2154. _videoFileExtensions = _namingOptions.VideoFileExtensions.ToArray();
  2155. }
  2156. return _namingOptions;
  2157. }
  2158. public ItemLookupInfo ParseName(string name)
  2159. {
  2160. var resolver = new VideoResolver(GetNamingOptions(), new NullLogger());
  2161. var result = resolver.CleanDateTime(name);
  2162. var cleanName = resolver.CleanString(result.Name);
  2163. return new ItemLookupInfo
  2164. {
  2165. Name = cleanName.Name,
  2166. Year = result.Year
  2167. };
  2168. }
  2169. public IEnumerable<Video> FindTrailers(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  2170. {
  2171. var namingOptions = GetNamingOptions();
  2172. var files = owner.DetectIsInMixedFolder() ? new List<FileSystemMetadata>() : fileSystemChildren.Where(i => i.IsDirectory)
  2173. .Where(i => string.Equals(i.Name, BaseItem.TrailerFolderName, StringComparison.OrdinalIgnoreCase))
  2174. .SelectMany(i => _fileSystem.GetFiles(i.FullName, _videoFileExtensions, false, false))
  2175. .ToList();
  2176. var videoListResolver = new VideoListResolver(namingOptions, new NullLogger());
  2177. var videos = videoListResolver.Resolve(fileSystemChildren);
  2178. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
  2179. if (currentVideo != null)
  2180. {
  2181. files.AddRange(currentVideo.Extras.Where(i => string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2182. }
  2183. var resolvers = new IItemResolver[]
  2184. {
  2185. new GenericVideoResolver<Trailer>(this)
  2186. };
  2187. return ResolvePaths(files, directoryService, null, new LibraryOptions(), null, resolvers)
  2188. .OfType<Trailer>()
  2189. .Select(video =>
  2190. {
  2191. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2192. var dbItem = GetItemById(video.Id) as Trailer;
  2193. if (dbItem != null)
  2194. {
  2195. video = dbItem;
  2196. }
  2197. video.ExtraType = ExtraType.Trailer;
  2198. video.TrailerTypes = new List<TrailerType> { TrailerType.LocalTrailer };
  2199. return video;
  2200. // Sort them so that the list can be easily compared for changes
  2201. }).OrderBy(i => i.Path).ToList();
  2202. }
  2203. private static readonly string[] ExtrasSubfolderNames = new[] { "extras", "specials", "shorts", "scenes", "featurettes", "behind the scenes", "deleted scenes", "interviews" };
  2204. public IEnumerable<Video> FindExtras(BaseItem owner, List<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
  2205. {
  2206. var namingOptions = GetNamingOptions();
  2207. var files = fileSystemChildren.Where(i => i.IsDirectory)
  2208. .Where(i => ExtrasSubfolderNames.Contains(i.Name ?? string.Empty, StringComparer.OrdinalIgnoreCase))
  2209. .SelectMany(i => _fileSystem.GetFiles(i.FullName, _videoFileExtensions, false, false))
  2210. .ToList();
  2211. var videoListResolver = new VideoListResolver(namingOptions, new NullLogger());
  2212. var videos = videoListResolver.Resolve(fileSystemChildren);
  2213. var currentVideo = videos.FirstOrDefault(i => string.Equals(owner.Path, i.Files.First().Path, StringComparison.OrdinalIgnoreCase));
  2214. if (currentVideo != null)
  2215. {
  2216. files.AddRange(currentVideo.Extras.Where(i => !string.Equals(i.ExtraType, "trailer", StringComparison.OrdinalIgnoreCase)).Select(i => _fileSystem.GetFileInfo(i.Path)));
  2217. }
  2218. return ResolvePaths(files, directoryService, null, new LibraryOptions(), null)
  2219. .OfType<Video>()
  2220. .Select(video =>
  2221. {
  2222. // Try to retrieve it from the db. If we don't find it, use the resolved version
  2223. var dbItem = GetItemById(video.Id) as Video;
  2224. if (dbItem != null)
  2225. {
  2226. video = dbItem;
  2227. }
  2228. SetExtraTypeFromFilename(video);
  2229. return video;
  2230. // Sort them so that the list can be easily compared for changes
  2231. }).OrderBy(i => i.Path).ToList();
  2232. }
  2233. public string GetPathAfterNetworkSubstitution(string path, BaseItem ownerItem)
  2234. {
  2235. if (ownerItem != null)
  2236. {
  2237. var libraryOptions = GetLibraryOptions(ownerItem);
  2238. if (libraryOptions != null)
  2239. {
  2240. foreach (var pathInfo in libraryOptions.PathInfos)
  2241. {
  2242. if (string.IsNullOrWhiteSpace(pathInfo.Path) || string.IsNullOrWhiteSpace(pathInfo.NetworkPath))
  2243. {
  2244. continue;
  2245. }
  2246. var substitutionResult = SubstitutePathInternal(path, pathInfo.Path, pathInfo.NetworkPath);
  2247. if (substitutionResult.Item2)
  2248. {
  2249. return substitutionResult.Item1;
  2250. }
  2251. }
  2252. }
  2253. }
  2254. var metadataPath = ConfigurationManager.Configuration.MetadataPath;
  2255. var metadataNetworkPath = ConfigurationManager.Configuration.MetadataNetworkPath;
  2256. if (!string.IsNullOrWhiteSpace(metadataPath) && !string.IsNullOrWhiteSpace(metadataNetworkPath))
  2257. {
  2258. var metadataSubstitutionResult = SubstitutePathInternal(path, metadataPath, metadataNetworkPath);
  2259. if (metadataSubstitutionResult.Item2)
  2260. {
  2261. return metadataSubstitutionResult.Item1;
  2262. }
  2263. }
  2264. foreach (var map in ConfigurationManager.Configuration.PathSubstitutions)
  2265. {
  2266. if (!string.IsNullOrWhiteSpace(map.From))
  2267. {
  2268. var substitutionResult = SubstitutePathInternal(path, map.From, map.To);
  2269. if (substitutionResult.Item2)
  2270. {
  2271. return substitutionResult.Item1;
  2272. }
  2273. }
  2274. }
  2275. return path;
  2276. }
  2277. public string SubstitutePath(string path, string from, string to)
  2278. {
  2279. return SubstitutePathInternal(path, from, to).Item1;
  2280. }
  2281. private Tuple<string, bool> SubstitutePathInternal(string path, string from, string to)
  2282. {
  2283. if (string.IsNullOrWhiteSpace(path))
  2284. {
  2285. throw new ArgumentNullException("path");
  2286. }
  2287. if (string.IsNullOrWhiteSpace(from))
  2288. {
  2289. throw new ArgumentNullException("from");
  2290. }
  2291. if (string.IsNullOrWhiteSpace(to))
  2292. {
  2293. throw new ArgumentNullException("to");
  2294. }
  2295. from = from.Trim();
  2296. to = to.Trim();
  2297. var newPath = path.Replace(from, to, StringComparison.OrdinalIgnoreCase);
  2298. var changed = false;
  2299. if (!string.Equals(newPath, path))
  2300. {
  2301. if (to.IndexOf('/') != -1)
  2302. {
  2303. newPath = newPath.Replace('\\', '/');
  2304. }
  2305. else
  2306. {
  2307. newPath = newPath.Replace('/', '\\');
  2308. }
  2309. changed = true;
  2310. }
  2311. return new Tuple<string, bool>(newPath, changed);
  2312. }
  2313. private void SetExtraTypeFromFilename(Video item)
  2314. {
  2315. var resolver = new ExtraResolver(GetNamingOptions(), new NullLogger(), new RegexProvider());
  2316. var result = resolver.GetExtraInfo(item.Path);
  2317. if (string.Equals(result.ExtraType, "deletedscene", StringComparison.OrdinalIgnoreCase))
  2318. {
  2319. item.ExtraType = ExtraType.DeletedScene;
  2320. }
  2321. else if (string.Equals(result.ExtraType, "behindthescenes", StringComparison.OrdinalIgnoreCase))
  2322. {
  2323. item.ExtraType = ExtraType.BehindTheScenes;
  2324. }
  2325. else if (string.Equals(result.ExtraType, "interview", StringComparison.OrdinalIgnoreCase))
  2326. {
  2327. item.ExtraType = ExtraType.Interview;
  2328. }
  2329. else if (string.Equals(result.ExtraType, "scene", StringComparison.OrdinalIgnoreCase))
  2330. {
  2331. item.ExtraType = ExtraType.Scene;
  2332. }
  2333. else if (string.Equals(result.ExtraType, "sample", StringComparison.OrdinalIgnoreCase))
  2334. {
  2335. item.ExtraType = ExtraType.Sample;
  2336. }
  2337. else
  2338. {
  2339. item.ExtraType = ExtraType.Clip;
  2340. }
  2341. }
  2342. public List<PersonInfo> GetPeople(InternalPeopleQuery query)
  2343. {
  2344. return ItemRepository.GetPeople(query);
  2345. }
  2346. public List<PersonInfo> GetPeople(BaseItem item)
  2347. {
  2348. if (item.SupportsPeople)
  2349. {
  2350. var people = GetPeople(new InternalPeopleQuery
  2351. {
  2352. ItemId = item.Id
  2353. });
  2354. if (people.Count > 0)
  2355. {
  2356. return people;
  2357. }
  2358. }
  2359. return new List<PersonInfo>();
  2360. }
  2361. public List<Person> GetPeopleItems(InternalPeopleQuery query)
  2362. {
  2363. return ItemRepository.GetPeopleNames(query).Select(i =>
  2364. {
  2365. try
  2366. {
  2367. return GetPerson(i);
  2368. }
  2369. catch (Exception ex)
  2370. {
  2371. _logger.ErrorException("Error getting person", ex);
  2372. return null;
  2373. }
  2374. }).Where(i => i != null).ToList();
  2375. }
  2376. public List<string> GetPeopleNames(InternalPeopleQuery query)
  2377. {
  2378. return ItemRepository.GetPeopleNames(query);
  2379. }
  2380. public Task UpdatePeople(BaseItem item, List<PersonInfo> people)
  2381. {
  2382. if (!item.SupportsPeople)
  2383. {
  2384. return Task.FromResult(true);
  2385. }
  2386. return ItemRepository.UpdatePeople(item.Id, people);
  2387. }
  2388. public async Task<ItemImageInfo> ConvertImageToLocal(IHasImages item, ItemImageInfo image, int imageIndex)
  2389. {
  2390. foreach (var url in image.Path.Split('|'))
  2391. {
  2392. try
  2393. {
  2394. _logger.Debug("ConvertImageToLocal item {0} - image url: {1}", item.Id, url);
  2395. await _providerManagerFactory().SaveImage(item, url, image.Type, imageIndex, CancellationToken.None).ConfigureAwait(false);
  2396. var newImage = item.GetImageInfo(image.Type, imageIndex);
  2397. if (newImage != null)
  2398. {
  2399. newImage.IsPlaceholder = image.IsPlaceholder;
  2400. }
  2401. await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2402. return item.GetImageInfo(image.Type, imageIndex);
  2403. }
  2404. catch (HttpException ex)
  2405. {
  2406. if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
  2407. {
  2408. continue;
  2409. }
  2410. throw;
  2411. }
  2412. }
  2413. // Remove this image to prevent it from retrying over and over
  2414. item.RemoveImage(image);
  2415. await item.UpdateToRepository(ItemUpdateType.ImageUpdate, CancellationToken.None).ConfigureAwait(false);
  2416. throw new InvalidOperationException();
  2417. }
  2418. public void AddVirtualFolder(string name, string collectionType, LibraryOptions options, bool refreshLibrary)
  2419. {
  2420. if (string.IsNullOrWhiteSpace(name))
  2421. {
  2422. throw new ArgumentNullException("name");
  2423. }
  2424. name = _fileSystem.GetValidFilename(name);
  2425. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2426. var virtualFolderPath = Path.Combine(rootFolderPath, name);
  2427. while (_fileSystem.DirectoryExists(virtualFolderPath))
  2428. {
  2429. name += "1";
  2430. virtualFolderPath = Path.Combine(rootFolderPath, name);
  2431. }
  2432. var mediaPathInfos = options.PathInfos;
  2433. if (mediaPathInfos != null)
  2434. {
  2435. var invalidpath = mediaPathInfos.FirstOrDefault(i => !_fileSystem.DirectoryExists(i.Path));
  2436. if (invalidpath != null)
  2437. {
  2438. throw new ArgumentException("The specified path does not exist: " + invalidpath.Path + ".");
  2439. }
  2440. }
  2441. _libraryMonitorFactory().Stop();
  2442. try
  2443. {
  2444. _fileSystem.CreateDirectory(virtualFolderPath);
  2445. if (!string.IsNullOrEmpty(collectionType))
  2446. {
  2447. var path = Path.Combine(virtualFolderPath, collectionType + ".collection");
  2448. _fileSystem.WriteAllBytes(path, new byte[] { });
  2449. }
  2450. CollectionFolder.SaveLibraryOptions(virtualFolderPath, options);
  2451. if (mediaPathInfos != null)
  2452. {
  2453. foreach (var path in mediaPathInfos)
  2454. {
  2455. AddMediaPathInternal(name, path, false);
  2456. }
  2457. }
  2458. }
  2459. finally
  2460. {
  2461. Task.Run(() =>
  2462. {
  2463. // No need to start if scanning the library because it will handle it
  2464. if (refreshLibrary)
  2465. {
  2466. ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
  2467. }
  2468. else
  2469. {
  2470. // Need to add a delay here or directory watchers may still pick up the changes
  2471. var task = Task.Delay(1000);
  2472. // Have to block here to allow exceptions to bubble
  2473. Task.WaitAll(task);
  2474. _libraryMonitorFactory().Start();
  2475. }
  2476. });
  2477. }
  2478. }
  2479. private bool ValidateNetworkPath(string path)
  2480. {
  2481. //if (Environment.OSVersion.Platform == PlatformID.Win32NT)
  2482. //{
  2483. // // We can't validate protocol-based paths, so just allow them
  2484. // if (path.IndexOf("://", StringComparison.OrdinalIgnoreCase) == -1)
  2485. // {
  2486. // return _fileSystem.DirectoryExists(path);
  2487. // }
  2488. //}
  2489. // Without native support for unc, we cannot validate this when running under mono
  2490. return true;
  2491. }
  2492. private const string ShortcutFileExtension = ".mblink";
  2493. public void AddMediaPath(string virtualFolderName, MediaPathInfo pathInfo)
  2494. {
  2495. AddMediaPathInternal(virtualFolderName, pathInfo, true);
  2496. }
  2497. private void AddMediaPathInternal(string virtualFolderName, MediaPathInfo pathInfo, bool saveLibraryOptions)
  2498. {
  2499. if (pathInfo == null)
  2500. {
  2501. throw new ArgumentNullException("path");
  2502. }
  2503. var path = pathInfo.Path;
  2504. if (string.IsNullOrWhiteSpace(path))
  2505. {
  2506. throw new ArgumentNullException("path");
  2507. }
  2508. if (!_fileSystem.DirectoryExists(path))
  2509. {
  2510. throw new FileNotFoundException("The path does not exist.");
  2511. }
  2512. if (!string.IsNullOrWhiteSpace(pathInfo.NetworkPath) && !ValidateNetworkPath(pathInfo.NetworkPath))
  2513. {
  2514. throw new FileNotFoundException("The network path does not exist.");
  2515. }
  2516. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2517. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2518. var shortcutFilename = _fileSystem.GetFileNameWithoutExtension(path);
  2519. var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2520. while (_fileSystem.FileExists(lnk))
  2521. {
  2522. shortcutFilename += "1";
  2523. lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
  2524. }
  2525. _fileSystem.CreateShortcut(lnk, path);
  2526. RemoveContentTypeOverrides(path);
  2527. if (saveLibraryOptions)
  2528. {
  2529. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2530. var list = libraryOptions.PathInfos.ToList();
  2531. list.Add(pathInfo);
  2532. libraryOptions.PathInfos = list.ToArray();
  2533. SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
  2534. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2535. }
  2536. }
  2537. public void UpdateMediaPath(string virtualFolderName, MediaPathInfo pathInfo)
  2538. {
  2539. if (pathInfo == null)
  2540. {
  2541. throw new ArgumentNullException("path");
  2542. }
  2543. if (!string.IsNullOrWhiteSpace(pathInfo.NetworkPath) && !ValidateNetworkPath(pathInfo.NetworkPath))
  2544. {
  2545. throw new FileNotFoundException("The network path does not exist.");
  2546. }
  2547. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2548. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2549. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2550. SyncLibraryOptionsToLocations(virtualFolderPath, libraryOptions);
  2551. var list = libraryOptions.PathInfos.ToList();
  2552. foreach (var originalPathInfo in list)
  2553. {
  2554. if (string.Equals(pathInfo.Path, originalPathInfo.Path, StringComparison.Ordinal))
  2555. {
  2556. originalPathInfo.NetworkPath = pathInfo.NetworkPath;
  2557. break;
  2558. }
  2559. }
  2560. libraryOptions.PathInfos = list.ToArray();
  2561. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2562. }
  2563. private void SyncLibraryOptionsToLocations(string virtualFolderPath, LibraryOptions options)
  2564. {
  2565. var topLibraryFolders = GetUserRootFolder().Children.ToList();
  2566. var info = GetVirtualFolderInfo(virtualFolderPath, topLibraryFolders);
  2567. if (info.Locations.Count > 0 && info.Locations.Count != options.PathInfos.Length)
  2568. {
  2569. var list = options.PathInfos.ToList();
  2570. foreach (var location in info.Locations)
  2571. {
  2572. if (!list.Any(i => string.Equals(i.Path, location, StringComparison.Ordinal)))
  2573. {
  2574. list.Add(new MediaPathInfo
  2575. {
  2576. Path = location
  2577. });
  2578. }
  2579. }
  2580. options.PathInfos = list.ToArray();
  2581. }
  2582. }
  2583. public void RemoveVirtualFolder(string name, bool refreshLibrary)
  2584. {
  2585. if (string.IsNullOrWhiteSpace(name))
  2586. {
  2587. throw new ArgumentNullException("name");
  2588. }
  2589. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2590. var path = Path.Combine(rootFolderPath, name);
  2591. if (!_fileSystem.DirectoryExists(path))
  2592. {
  2593. throw new FileNotFoundException("The media folder does not exist");
  2594. }
  2595. _libraryMonitorFactory().Stop();
  2596. try
  2597. {
  2598. _fileSystem.DeleteDirectory(path, true);
  2599. }
  2600. finally
  2601. {
  2602. Task.Run(() =>
  2603. {
  2604. // No need to start if scanning the library because it will handle it
  2605. if (refreshLibrary)
  2606. {
  2607. ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
  2608. }
  2609. else
  2610. {
  2611. // Need to add a delay here or directory watchers may still pick up the changes
  2612. var task = Task.Delay(1000);
  2613. // Have to block here to allow exceptions to bubble
  2614. Task.WaitAll(task);
  2615. _libraryMonitorFactory().Start();
  2616. }
  2617. });
  2618. }
  2619. }
  2620. private void RemoveContentTypeOverrides(string path)
  2621. {
  2622. if (string.IsNullOrWhiteSpace(path))
  2623. {
  2624. throw new ArgumentNullException("path");
  2625. }
  2626. var removeList = new List<NameValuePair>();
  2627. foreach (var contentType in ConfigurationManager.Configuration.ContentTypes)
  2628. {
  2629. if (string.IsNullOrWhiteSpace(contentType.Name))
  2630. {
  2631. removeList.Add(contentType);
  2632. }
  2633. else if (_fileSystem.AreEqual(path, contentType.Name)
  2634. || _fileSystem.ContainsSubPath(path, contentType.Name))
  2635. {
  2636. removeList.Add(contentType);
  2637. }
  2638. }
  2639. if (removeList.Count > 0)
  2640. {
  2641. ConfigurationManager.Configuration.ContentTypes = ConfigurationManager.Configuration.ContentTypes
  2642. .Except(removeList)
  2643. .ToArray();
  2644. ConfigurationManager.SaveConfiguration();
  2645. }
  2646. }
  2647. public void RemoveMediaPath(string virtualFolderName, string mediaPath)
  2648. {
  2649. if (string.IsNullOrWhiteSpace(mediaPath))
  2650. {
  2651. throw new ArgumentNullException("mediaPath");
  2652. }
  2653. var rootFolderPath = ConfigurationManager.ApplicationPaths.DefaultUserViewsPath;
  2654. var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
  2655. if (!_fileSystem.DirectoryExists(virtualFolderPath))
  2656. {
  2657. throw new FileNotFoundException(string.Format("The media collection {0} does not exist", virtualFolderName));
  2658. }
  2659. var shortcut = _fileSystem.GetFilePaths(virtualFolderPath, true)
  2660. .Where(i => string.Equals(ShortcutFileExtension, Path.GetExtension(i), StringComparison.OrdinalIgnoreCase))
  2661. .FirstOrDefault(f => _fileSystem.ResolveShortcut(f).Equals(mediaPath, StringComparison.OrdinalIgnoreCase));
  2662. if (!string.IsNullOrEmpty(shortcut))
  2663. {
  2664. _fileSystem.DeleteFile(shortcut);
  2665. }
  2666. var libraryOptions = CollectionFolder.GetLibraryOptions(virtualFolderPath);
  2667. libraryOptions.PathInfos = libraryOptions
  2668. .PathInfos
  2669. .Where(i => !string.Equals(i.Path, mediaPath, StringComparison.Ordinal))
  2670. .ToArray();
  2671. CollectionFolder.SaveLibraryOptions(virtualFolderPath, libraryOptions);
  2672. }
  2673. }
  2674. }