MetadataService.cs 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. using MediaBrowser.Common.Extensions;
  2. using MediaBrowser.Common.IO;
  3. using MediaBrowser.Controller.Configuration;
  4. using MediaBrowser.Controller.Entities;
  5. using MediaBrowser.Controller.Library;
  6. using MediaBrowser.Controller.Providers;
  7. using MediaBrowser.Model.Entities;
  8. using MediaBrowser.Model.Logging;
  9. using System;
  10. using System.Collections.Generic;
  11. using System.Linq;
  12. using System.Threading;
  13. using System.Threading.Tasks;
  14. using CommonIO;
  15. using MediaBrowser.Controller.Entities.Audio;
  16. using MediaBrowser.Controller.Entities.Movies;
  17. namespace MediaBrowser.Providers.Manager
  18. {
  19. public abstract class MetadataService<TItemType, TIdType> : IMetadataService
  20. where TItemType : IHasMetadata, IHasLookupInfo<TIdType>, new()
  21. where TIdType : ItemLookupInfo, new()
  22. {
  23. protected readonly IServerConfigurationManager ServerConfigurationManager;
  24. protected readonly ILogger Logger;
  25. protected readonly IProviderManager ProviderManager;
  26. protected readonly IProviderRepository ProviderRepo;
  27. protected readonly IFileSystem FileSystem;
  28. protected readonly IUserDataManager UserDataManager;
  29. protected readonly ILibraryManager LibraryManager;
  30. protected MetadataService(IServerConfigurationManager serverConfigurationManager, ILogger logger, IProviderManager providerManager, IProviderRepository providerRepo, IFileSystem fileSystem, IUserDataManager userDataManager, ILibraryManager libraryManager)
  31. {
  32. ServerConfigurationManager = serverConfigurationManager;
  33. Logger = logger;
  34. ProviderManager = providerManager;
  35. ProviderRepo = providerRepo;
  36. FileSystem = fileSystem;
  37. UserDataManager = userDataManager;
  38. LibraryManager = libraryManager;
  39. }
  40. /// <summary>
  41. /// Saves the provider result.
  42. /// </summary>
  43. /// <param name="item">The item.</param>
  44. /// <param name="result">The result.</param>
  45. /// <param name="directoryService">The directory service.</param>
  46. /// <returns>Task.</returns>
  47. protected Task SaveProviderResult(TItemType item, MetadataStatus result, IDirectoryService directoryService)
  48. {
  49. result.ItemId = item.Id;
  50. result.ItemName = item.Name;
  51. result.ItemType = item.GetType().Name;
  52. var series = item as IHasSeries;
  53. result.SeriesName = series == null ? null : series.SeriesName;
  54. //var locationType = item.LocationType;
  55. //if (locationType == LocationType.FileSystem || locationType == LocationType.Offline)
  56. //{
  57. // if (!string.IsNullOrWhiteSpace(item.Path))
  58. // {
  59. // var file = directoryService.GetFile(item.Path);
  60. // if ((file.Attributes & FileAttributes.Directory) != FileAttributes.Directory && file.Exists)
  61. // {
  62. // result.ItemDateModified = FileSystem.GetLastWriteTimeUtc(file);
  63. // }
  64. // }
  65. //}
  66. result.ItemDateModified = item.DateModified;
  67. return ProviderRepo.SaveMetadataStatus(result, CancellationToken.None);
  68. }
  69. /// <summary>
  70. /// Gets the last result.
  71. /// </summary>
  72. /// <param name="item">The item.</param>
  73. /// <returns>ProviderResult.</returns>
  74. protected MetadataStatus GetLastResult(IHasMetadata item)
  75. {
  76. if (GetLastRefreshDate(item) == default(DateTime))
  77. {
  78. return new MetadataStatus { ItemId = item.Id };
  79. }
  80. return ProviderRepo.GetMetadataStatus(item.Id) ?? new MetadataStatus { ItemId = item.Id };
  81. }
  82. public async Task<ItemUpdateType> RefreshMetadata(IHasMetadata item, MetadataRefreshOptions refreshOptions, CancellationToken cancellationToken)
  83. {
  84. var itemOfType = (TItemType)item;
  85. var config = ProviderManager.GetMetadataOptions(item);
  86. var updateType = ItemUpdateType.None;
  87. var refreshResult = GetLastResult(item);
  88. refreshResult.LastErrorMessage = string.Empty;
  89. var itemImageProvider = new ItemImageProvider(Logger, ProviderManager, ServerConfigurationManager, FileSystem);
  90. var localImagesFailed = false;
  91. var allImageProviders = ((ProviderManager)ProviderManager).GetImageProviders(item).ToList();
  92. // Start by validating images
  93. try
  94. {
  95. // Always validate images and check for new locally stored ones.
  96. if (itemImageProvider.ValidateImages(item, allImageProviders.OfType<ILocalImageProvider>(), refreshOptions.DirectoryService))
  97. {
  98. updateType = updateType | ItemUpdateType.ImageUpdate;
  99. }
  100. }
  101. catch (Exception ex)
  102. {
  103. localImagesFailed = true;
  104. Logger.ErrorException("Error validating images for {0}", ex, item.Path ?? item.Name ?? "Unknown name");
  105. refreshResult.AddStatus(ex.Message);
  106. }
  107. var metadataResult = new MetadataResult<TItemType>
  108. {
  109. Item = itemOfType
  110. };
  111. // Next run metadata providers
  112. if (refreshOptions.MetadataRefreshMode != MetadataRefreshMode.None)
  113. {
  114. var providers = GetProviders(item, refreshResult, refreshOptions)
  115. .ToList();
  116. if (providers.Count > 0 || !refreshResult.DateLastMetadataRefresh.HasValue)
  117. {
  118. if (item.BeforeMetadataRefresh())
  119. {
  120. updateType = updateType | ItemUpdateType.MetadataImport;
  121. }
  122. }
  123. if (providers.Count > 0)
  124. {
  125. var id = itemOfType.GetLookupInfo();
  126. await ItemIdentifier<TIdType>.FindIdentities(id, ProviderManager, cancellationToken);
  127. var result = await RefreshWithProviders(metadataResult, id, refreshOptions, providers, itemImageProvider, cancellationToken).ConfigureAwait(false);
  128. updateType = updateType | result.UpdateType;
  129. refreshResult.AddStatus(result.ErrorMessage);
  130. if (result.Failures == 0)
  131. {
  132. refreshResult.SetDateLastMetadataRefresh(DateTime.UtcNow);
  133. }
  134. else
  135. {
  136. refreshResult.SetDateLastMetadataRefresh(null);
  137. }
  138. }
  139. }
  140. // Next run remote image providers, but only if local image providers didn't throw an exception
  141. if (!localImagesFailed && refreshOptions.ImageRefreshMode != ImageRefreshMode.ValidationOnly)
  142. {
  143. var providers = GetNonLocalImageProviders(item, allImageProviders, refreshResult, refreshOptions).ToList();
  144. if (providers.Count > 0)
  145. {
  146. var result = await itemImageProvider.RefreshImages(itemOfType, providers, refreshOptions, config, cancellationToken).ConfigureAwait(false);
  147. updateType = updateType | result.UpdateType;
  148. refreshResult.AddStatus(result.ErrorMessage);
  149. if (result.Failures == 0)
  150. {
  151. refreshResult.SetDateLastImagesRefresh(DateTime.UtcNow);
  152. }
  153. else
  154. {
  155. refreshResult.SetDateLastImagesRefresh(null);
  156. }
  157. }
  158. }
  159. var isFirstRefresh = GetLastRefreshDate(item) == default(DateTime);
  160. var beforeSaveResult = await BeforeSave(itemOfType, isFirstRefresh || refreshOptions.ReplaceAllMetadata || refreshOptions.MetadataRefreshMode == MetadataRefreshMode.FullRefresh, updateType).ConfigureAwait(false);
  161. updateType = updateType | beforeSaveResult;
  162. // Save if changes were made, or it's never been saved before
  163. if (refreshOptions.ForceSave || updateType > ItemUpdateType.None || isFirstRefresh || refreshOptions.ReplaceAllMetadata)
  164. {
  165. // If any of these properties are set then make sure the updateType is not None, just to force everything to save
  166. if (refreshOptions.ForceSave || refreshOptions.ReplaceAllMetadata)
  167. {
  168. updateType = updateType | ItemUpdateType.MetadataDownload;
  169. }
  170. if (refreshOptions.MetadataRefreshMode >= MetadataRefreshMode.Default && refreshOptions.ImageRefreshMode >= ImageRefreshMode.Default)
  171. {
  172. item.DateLastRefreshed = DateTime.UtcNow;
  173. }
  174. // Save to database
  175. await SaveItem(metadataResult, updateType, cancellationToken).ConfigureAwait(false);
  176. }
  177. if (updateType > ItemUpdateType.None || refreshResult.IsDirty)
  178. {
  179. await SaveProviderResult(itemOfType, refreshResult, refreshOptions.DirectoryService).ConfigureAwait(false);
  180. }
  181. await AfterMetadataRefresh(itemOfType, refreshOptions, cancellationToken).ConfigureAwait(false);
  182. return updateType;
  183. }
  184. private DateTime GetLastRefreshDate(IHasMetadata item)
  185. {
  186. if (item.DateLastRefreshed != default(DateTime))
  187. {
  188. return item.DateLastRefreshed;
  189. }
  190. if (ServerConfigurationManager.Configuration.EnableDateLastRefresh)
  191. {
  192. return item.DateLastRefreshed;
  193. }
  194. if (item is BoxSet || (item is IItemByName && !(item is MusicArtist)))
  195. {
  196. return item.DateLastRefreshed;
  197. }
  198. return item.DateLastSaved;
  199. }
  200. protected async Task SaveItem(MetadataResult<TItemType> result, ItemUpdateType reason, CancellationToken cancellationToken)
  201. {
  202. if (result.Item.SupportsPeople && result.People != null)
  203. {
  204. await LibraryManager.UpdatePeople(result.Item as BaseItem, result.People.ToList());
  205. }
  206. await result.Item.UpdateToRepository(reason, cancellationToken).ConfigureAwait(false);
  207. }
  208. private readonly Task _cachedTask = Task.FromResult(true);
  209. protected virtual Task AfterMetadataRefresh(TItemType item, MetadataRefreshOptions refreshOptions, CancellationToken cancellationToken)
  210. {
  211. item.AfterMetadataRefresh();
  212. return _cachedTask;
  213. }
  214. private readonly Task<ItemUpdateType> _cachedResult = Task.FromResult(ItemUpdateType.None);
  215. /// <summary>
  216. /// Befores the save.
  217. /// </summary>
  218. /// <param name="item">The item.</param>
  219. /// <param name="isFullRefresh">if set to <c>true</c> [is full refresh].</param>
  220. /// <param name="currentUpdateType">Type of the current update.</param>
  221. /// <returns>ItemUpdateType.</returns>
  222. protected virtual Task<ItemUpdateType> BeforeSave(TItemType item, bool isFullRefresh, ItemUpdateType currentUpdateType)
  223. {
  224. return _cachedResult;
  225. }
  226. /// <summary>
  227. /// Gets the providers.
  228. /// </summary>
  229. /// <param name="item">The item.</param>
  230. /// <param name="status">The status.</param>
  231. /// <param name="options">The options.</param>
  232. /// <returns>IEnumerable{`0}.</returns>
  233. protected IEnumerable<IMetadataProvider> GetProviders(IHasMetadata item, MetadataStatus status, MetadataRefreshOptions options)
  234. {
  235. // Get providers to refresh
  236. var providers = ((ProviderManager)ProviderManager).GetMetadataProviders<TItemType>(item).ToList();
  237. // Run all if either of these flags are true
  238. var runAllProviders = options.ReplaceAllMetadata || options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh || !status.DateLastMetadataRefresh.HasValue;
  239. if (!runAllProviders)
  240. {
  241. // Avoid implicitly captured closure
  242. var currentItem = item;
  243. var providersWithChanges = providers
  244. .Where(i =>
  245. {
  246. var hasChangeMonitor = i as IHasChangeMonitor;
  247. if (hasChangeMonitor != null)
  248. {
  249. return HasChanged(item, hasChangeMonitor, currentItem.DateLastSaved, options.DirectoryService);
  250. }
  251. var hasFileChangeMonitor = i as IHasItemChangeMonitor;
  252. if (hasFileChangeMonitor != null)
  253. {
  254. return HasChanged(item, hasFileChangeMonitor, status, options.DirectoryService);
  255. }
  256. return false;
  257. })
  258. .ToList();
  259. if (providersWithChanges.Count == 0)
  260. {
  261. providers = new List<IMetadataProvider<TItemType>>();
  262. }
  263. else
  264. {
  265. providers = providers.Where(i =>
  266. {
  267. // If any provider reports a change, always run local ones as well
  268. if (i is ILocalMetadataProvider)
  269. {
  270. return true;
  271. }
  272. var anyRemoteProvidersChanged = providersWithChanges.OfType<IRemoteMetadataProvider>()
  273. .Any();
  274. // If any remote providers changed, run them all so that priorities can be honored
  275. if (i is IRemoteMetadataProvider)
  276. {
  277. return anyRemoteProvidersChanged;
  278. }
  279. // Run custom providers if they report a change or any remote providers change
  280. return anyRemoteProvidersChanged || providersWithChanges.Contains(i);
  281. }).ToList();
  282. }
  283. }
  284. return providers;
  285. }
  286. protected virtual IEnumerable<IImageProvider> GetNonLocalImageProviders(IHasMetadata item, IEnumerable<IImageProvider> allImageProviders, MetadataStatus status, ImageRefreshOptions options)
  287. {
  288. // Get providers to refresh
  289. var providers = allImageProviders.Where(i => !(i is ILocalImageProvider)).ToList();
  290. // Run all if either of these flags are true
  291. var runAllProviders = options.ImageRefreshMode == ImageRefreshMode.FullRefresh || !status.DateLastImagesRefresh.HasValue;
  292. if (!runAllProviders)
  293. {
  294. providers = providers
  295. .Where(i =>
  296. {
  297. var hasChangeMonitor = i as IHasChangeMonitor;
  298. if (hasChangeMonitor != null)
  299. {
  300. return HasChanged(item, hasChangeMonitor, status.DateLastImagesRefresh.Value, options.DirectoryService);
  301. }
  302. var hasFileChangeMonitor = i as IHasItemChangeMonitor;
  303. if (hasFileChangeMonitor != null)
  304. {
  305. return HasChanged(item, hasFileChangeMonitor, status, options.DirectoryService);
  306. }
  307. return false;
  308. })
  309. .ToList();
  310. }
  311. return providers;
  312. }
  313. public bool CanRefresh(IHasMetadata item)
  314. {
  315. return item is TItemType;
  316. }
  317. protected virtual async Task<RefreshResult> RefreshWithProviders(MetadataResult<TItemType> metadata,
  318. TIdType id,
  319. MetadataRefreshOptions options,
  320. List<IMetadataProvider> providers,
  321. ItemImageProvider imageService,
  322. CancellationToken cancellationToken)
  323. {
  324. var refreshResult = new RefreshResult
  325. {
  326. UpdateType = ItemUpdateType.None,
  327. Providers = providers.Select(i => i.GetType().FullName.GetMD5()).ToList()
  328. };
  329. var item = metadata.Item;
  330. var customProviders = providers.OfType<ICustomMetadataProvider<TItemType>>().ToList();
  331. var logName = item.LocationType == LocationType.Remote ? item.Name ?? item.Path : item.Path ?? item.Name;
  332. foreach (var provider in customProviders.Where(i => i is IPreRefreshProvider))
  333. {
  334. await RunCustomProvider(provider, item, logName, options, refreshResult, cancellationToken).ConfigureAwait(false);
  335. }
  336. var temp = new MetadataResult<TItemType>
  337. {
  338. Item = CreateNew()
  339. };
  340. temp.Item.Path = item.Path;
  341. var userDataList = new List<UserItemData>();
  342. // If replacing all metadata, run internet providers first
  343. if (options.ReplaceAllMetadata)
  344. {
  345. var remoteResult = await ExecuteRemoteProviders(temp, logName, id, providers.OfType<IRemoteMetadataProvider<TItemType, TIdType>>(), cancellationToken)
  346. .ConfigureAwait(false);
  347. refreshResult.UpdateType = refreshResult.UpdateType | remoteResult.UpdateType;
  348. refreshResult.ErrorMessage = remoteResult.ErrorMessage;
  349. refreshResult.Failures += remoteResult.Failures;
  350. }
  351. var hasLocalMetadata = false;
  352. foreach (var provider in providers.OfType<ILocalMetadataProvider<TItemType>>().ToList())
  353. {
  354. var providerName = provider.GetType().Name;
  355. Logger.Debug("Running {0} for {1}", providerName, logName);
  356. var itemInfo = new ItemInfo(item);
  357. try
  358. {
  359. var localItem = await provider.GetMetadata(itemInfo, options.DirectoryService, cancellationToken).ConfigureAwait(false);
  360. if (localItem.HasMetadata)
  361. {
  362. if (imageService.MergeImages(item, localItem.Images))
  363. {
  364. refreshResult.UpdateType = refreshResult.UpdateType | ItemUpdateType.ImageUpdate;
  365. }
  366. if (localItem.UserDataList != null)
  367. {
  368. userDataList.AddRange(localItem.UserDataList);
  369. }
  370. MergeData(localItem, temp, new List<MetadataFields>(), !options.ReplaceAllMetadata, true);
  371. refreshResult.UpdateType = refreshResult.UpdateType | ItemUpdateType.MetadataImport;
  372. // Only one local provider allowed per item
  373. if (IsFullLocalMetadata(localItem.Item))
  374. {
  375. hasLocalMetadata = true;
  376. }
  377. break;
  378. }
  379. Logger.Debug("{0} returned no metadata for {1}", providerName, logName);
  380. }
  381. catch (OperationCanceledException)
  382. {
  383. throw;
  384. }
  385. catch (Exception ex)
  386. {
  387. refreshResult.Failures++;
  388. Logger.ErrorException("Error in {0}", ex, provider.Name);
  389. // If a local provider fails, consider that a failure
  390. refreshResult.ErrorMessage = ex.Message;
  391. if (options.MetadataRefreshMode != MetadataRefreshMode.FullRefresh)
  392. {
  393. // If the local provider fails don't continue with remote providers because the user's saved metadata could be lost
  394. return refreshResult;
  395. }
  396. }
  397. }
  398. // Local metadata is king - if any is found don't run remote providers
  399. if (!options.ReplaceAllMetadata && (!hasLocalMetadata || options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh))
  400. {
  401. var remoteResult = await ExecuteRemoteProviders(temp, logName, id, providers.OfType<IRemoteMetadataProvider<TItemType, TIdType>>(), cancellationToken)
  402. .ConfigureAwait(false);
  403. refreshResult.UpdateType = refreshResult.UpdateType | remoteResult.UpdateType;
  404. refreshResult.ErrorMessage = remoteResult.ErrorMessage;
  405. refreshResult.Failures += remoteResult.Failures;
  406. }
  407. if (providers.Any(i => !(i is ICustomMetadataProvider)))
  408. {
  409. if (refreshResult.UpdateType > ItemUpdateType.None)
  410. {
  411. // If no local metadata, take data from item itself
  412. if (!hasLocalMetadata)
  413. {
  414. // TODO: If the new metadata from above has some blank data, this can cause old data to get filled into those empty fields
  415. MergeData(metadata, temp, new List<MetadataFields>(), false, true);
  416. }
  417. MergeData(temp, metadata, item.LockedFields, true, true);
  418. }
  419. }
  420. //var isUnidentified = failedProviderCount > 0 && successfulProviderCount == 0;
  421. foreach (var provider in customProviders.Where(i => !(i is IPreRefreshProvider)))
  422. {
  423. await RunCustomProvider(provider, item, logName, options, refreshResult, cancellationToken).ConfigureAwait(false);
  424. }
  425. await ImportUserData(item, userDataList, cancellationToken).ConfigureAwait(false);
  426. return refreshResult;
  427. }
  428. protected virtual bool IsFullLocalMetadata(TItemType item)
  429. {
  430. if (string.IsNullOrWhiteSpace(item.Name))
  431. {
  432. return false;
  433. }
  434. return true;
  435. }
  436. private async Task ImportUserData(TItemType item, List<UserItemData> userDataList, CancellationToken cancellationToken)
  437. {
  438. var hasUserData = item as IHasUserData;
  439. if (hasUserData != null)
  440. {
  441. foreach (var userData in userDataList)
  442. {
  443. await UserDataManager.SaveUserData(userData.UserId, hasUserData, userData, UserDataSaveReason.Import, cancellationToken)
  444. .ConfigureAwait(false);
  445. }
  446. }
  447. }
  448. private async Task RunCustomProvider(ICustomMetadataProvider<TItemType> provider, TItemType item, string logName, MetadataRefreshOptions options, RefreshResult refreshResult, CancellationToken cancellationToken)
  449. {
  450. Logger.Debug("Running {0} for {1}", provider.GetType().Name, logName);
  451. try
  452. {
  453. refreshResult.UpdateType = refreshResult.UpdateType | await provider.FetchAsync(item, options, cancellationToken).ConfigureAwait(false);
  454. }
  455. catch (OperationCanceledException)
  456. {
  457. throw;
  458. }
  459. catch (Exception ex)
  460. {
  461. refreshResult.ErrorMessage = ex.Message;
  462. Logger.ErrorException("Error in {0}", ex, provider.Name);
  463. }
  464. }
  465. protected virtual TItemType CreateNew()
  466. {
  467. return new TItemType();
  468. }
  469. private async Task<RefreshResult> ExecuteRemoteProviders(MetadataResult<TItemType> temp, string logName, TIdType id, IEnumerable<IRemoteMetadataProvider<TItemType, TIdType>> providers, CancellationToken cancellationToken)
  470. {
  471. var refreshResult = new RefreshResult();
  472. foreach (var provider in providers)
  473. {
  474. var providerName = provider.GetType().Name;
  475. Logger.Debug("Running {0} for {1}", providerName, logName);
  476. if (id != null)
  477. {
  478. MergeNewData(temp.Item, id);
  479. }
  480. try
  481. {
  482. var result = await provider.GetMetadata(id, cancellationToken).ConfigureAwait(false);
  483. if (result.HasMetadata)
  484. {
  485. NormalizeRemoteResult(result.Item);
  486. MergeData(result, temp, new List<MetadataFields>(), false, false);
  487. refreshResult.UpdateType = refreshResult.UpdateType | ItemUpdateType.MetadataDownload;
  488. }
  489. else
  490. {
  491. refreshResult.Failures++;
  492. Logger.Debug("{0} returned no metadata for {1}", providerName, logName);
  493. }
  494. }
  495. catch (OperationCanceledException)
  496. {
  497. throw;
  498. }
  499. catch (Exception ex)
  500. {
  501. refreshResult.Failures++;
  502. refreshResult.ErrorMessage = ex.Message;
  503. Logger.ErrorException("Error in {0}", ex, provider.Name);
  504. }
  505. }
  506. return refreshResult;
  507. }
  508. private void NormalizeRemoteResult(TItemType item)
  509. {
  510. if (!ServerConfigurationManager.Configuration.FindInternetTrailers)
  511. {
  512. var hasTrailers = item as IHasTrailers;
  513. if (hasTrailers != null)
  514. {
  515. hasTrailers.RemoteTrailers.Clear();
  516. }
  517. }
  518. }
  519. private void MergeNewData(TItemType source, TIdType lookupInfo)
  520. {
  521. // Copy new provider id's that may have been obtained
  522. foreach (var providerId in source.ProviderIds)
  523. {
  524. var key = providerId.Key;
  525. // Don't replace existing Id's.
  526. if (!lookupInfo.ProviderIds.ContainsKey(key))
  527. {
  528. lookupInfo.ProviderIds[key] = providerId.Value;
  529. }
  530. }
  531. }
  532. protected abstract void MergeData(MetadataResult<TItemType> source,
  533. MetadataResult<TItemType> target,
  534. List<MetadataFields> lockedFields,
  535. bool replaceData,
  536. bool mergeMetadataSettings);
  537. public virtual int Order
  538. {
  539. get
  540. {
  541. return 0;
  542. }
  543. }
  544. private bool HasChanged(IHasMetadata item, IHasItemChangeMonitor changeMonitor, MetadataStatus status, IDirectoryService directoryService)
  545. {
  546. try
  547. {
  548. return changeMonitor.HasChanged(item, status, directoryService);
  549. }
  550. catch (Exception ex)
  551. {
  552. Logger.ErrorException("Error in {0}.HasChanged", ex, changeMonitor.GetType().Name);
  553. return false;
  554. }
  555. }
  556. private bool HasChanged(IHasMetadata item, IHasChangeMonitor changeMonitor, DateTime date, IDirectoryService directoryService)
  557. {
  558. try
  559. {
  560. return changeMonitor.HasChanged(item, directoryService, date);
  561. }
  562. catch (Exception ex)
  563. {
  564. Logger.ErrorException("Error in {0}.HasChanged", ex, changeMonitor.GetType().Name);
  565. return false;
  566. }
  567. }
  568. }
  569. public class RefreshResult
  570. {
  571. public ItemUpdateType UpdateType { get; set; }
  572. public string ErrorMessage { get; set; }
  573. public List<Guid> Providers { get; set; }
  574. public int Failures { get; set; }
  575. }
  576. }