SyncManager.cs 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974
  1. using MediaBrowser.Common;
  2. using MediaBrowser.Common.Configuration;
  3. using MediaBrowser.Common.Events;
  4. using MediaBrowser.Common.Extensions;
  5. using MediaBrowser.Common.IO;
  6. using MediaBrowser.Controller.Channels;
  7. using MediaBrowser.Controller.Drawing;
  8. using MediaBrowser.Controller.Dto;
  9. using MediaBrowser.Controller.Entities;
  10. using MediaBrowser.Controller.Entities.Audio;
  11. using MediaBrowser.Controller.Entities.TV;
  12. using MediaBrowser.Controller.Library;
  13. using MediaBrowser.Controller.LiveTv;
  14. using MediaBrowser.Controller.MediaEncoding;
  15. using MediaBrowser.Controller.Playlists;
  16. using MediaBrowser.Controller.Sync;
  17. using MediaBrowser.Controller.TV;
  18. using MediaBrowser.Model.Dlna;
  19. using MediaBrowser.Model.Dto;
  20. using MediaBrowser.Model.Entities;
  21. using MediaBrowser.Model.Events;
  22. using MediaBrowser.Model.Logging;
  23. using MediaBrowser.Model.Querying;
  24. using MediaBrowser.Model.Sync;
  25. using MediaBrowser.Model.Users;
  26. using MoreLinq;
  27. using System;
  28. using System.Collections.Generic;
  29. using System.IO;
  30. using System.Linq;
  31. using System.Threading;
  32. using System.Threading.Tasks;
  33. namespace MediaBrowser.Server.Implementations.Sync
  34. {
  35. public class SyncManager : ISyncManager
  36. {
  37. private readonly ILibraryManager _libraryManager;
  38. private readonly ISyncRepository _repo;
  39. private readonly IImageProcessor _imageProcessor;
  40. private readonly ILogger _logger;
  41. private readonly IUserManager _userManager;
  42. private readonly Func<IDtoService> _dtoService;
  43. private readonly IApplicationHost _appHost;
  44. private readonly ITVSeriesManager _tvSeriesManager;
  45. private readonly Func<IMediaEncoder> _mediaEncoder;
  46. private readonly IFileSystem _fileSystem;
  47. private readonly Func<ISubtitleEncoder> _subtitleEncoder;
  48. private readonly IConfigurationManager _config;
  49. private ISyncProvider[] _providers = { };
  50. public event EventHandler<GenericEventArgs<SyncJobCreationResult>> SyncJobCreated;
  51. public event EventHandler<GenericEventArgs<SyncJob>> SyncJobCancelled;
  52. public event EventHandler<GenericEventArgs<SyncJob>> SyncJobUpdated;
  53. public event EventHandler<GenericEventArgs<SyncJobItem>> SyncJobItemUpdated;
  54. public event EventHandler<GenericEventArgs<SyncJobItem>> SyncJobItemCreated;
  55. public SyncManager(ILibraryManager libraryManager, ISyncRepository repo, IImageProcessor imageProcessor, ILogger logger, IUserManager userManager, Func<IDtoService> dtoService, IApplicationHost appHost, ITVSeriesManager tvSeriesManager, Func<IMediaEncoder> mediaEncoder, IFileSystem fileSystem, Func<ISubtitleEncoder> subtitleEncoder, IConfigurationManager config)
  56. {
  57. _libraryManager = libraryManager;
  58. _repo = repo;
  59. _imageProcessor = imageProcessor;
  60. _logger = logger;
  61. _userManager = userManager;
  62. _dtoService = dtoService;
  63. _appHost = appHost;
  64. _tvSeriesManager = tvSeriesManager;
  65. _mediaEncoder = mediaEncoder;
  66. _fileSystem = fileSystem;
  67. _subtitleEncoder = subtitleEncoder;
  68. _config = config;
  69. }
  70. public void AddParts(IEnumerable<ISyncProvider> providers)
  71. {
  72. _providers = providers.ToArray();
  73. }
  74. public async Task<SyncJobCreationResult> CreateJob(SyncJobRequest request)
  75. {
  76. var processor = GetSyncJobProcessor();
  77. var user = _userManager.GetUserById(request.UserId);
  78. var items = (await processor
  79. .GetItemsForSync(request.Category, request.ParentId, request.ItemIds, user, request.UnwatchedOnly).ConfigureAwait(false))
  80. .ToList();
  81. if (items.Any(i => !SupportsSync(i)))
  82. {
  83. throw new ArgumentException("Item does not support sync.");
  84. }
  85. if (string.IsNullOrWhiteSpace(request.Name))
  86. {
  87. if (request.ItemIds.Count == 1)
  88. {
  89. request.Name = GetDefaultName(_libraryManager.GetItemById(request.ItemIds[0]));
  90. }
  91. }
  92. if (string.IsNullOrWhiteSpace(request.Name))
  93. {
  94. throw new ArgumentException("Please supply a name for the sync job.");
  95. }
  96. var target = GetSyncTargets(request.UserId)
  97. .FirstOrDefault(i => string.Equals(request.TargetId, i.Id));
  98. if (target == null)
  99. {
  100. throw new ArgumentException("Sync target not found.");
  101. }
  102. var jobId = Guid.NewGuid().ToString("N");
  103. var job = new SyncJob
  104. {
  105. Id = jobId,
  106. Name = request.Name,
  107. TargetId = target.Id,
  108. UserId = request.UserId,
  109. UnwatchedOnly = request.UnwatchedOnly,
  110. ItemLimit = request.ItemLimit,
  111. RequestedItemIds = request.ItemIds ?? new List<string> { },
  112. DateCreated = DateTime.UtcNow,
  113. DateLastModified = DateTime.UtcNow,
  114. SyncNewContent = request.SyncNewContent,
  115. ItemCount = items.Count,
  116. Quality = request.Quality,
  117. Category = request.Category,
  118. ParentId = request.ParentId
  119. };
  120. // It's just a static list
  121. if (!items.Any(i => i.IsFolder || i is IItemByName))
  122. {
  123. job.SyncNewContent = false;
  124. }
  125. await _repo.Create(job).ConfigureAwait(false);
  126. await processor.EnsureJobItems(job).ConfigureAwait(false);
  127. // If it already has a converting status then is must have been aborted during conversion
  128. var jobItemsResult = _repo.GetJobItems(new SyncJobItemQuery
  129. {
  130. Statuses = new List<SyncJobItemStatus> { SyncJobItemStatus.Queued, SyncJobItemStatus.Converting },
  131. JobId = jobId
  132. });
  133. await processor.SyncJobItems(jobItemsResult.Items, false, new Progress<double>(), CancellationToken.None)
  134. .ConfigureAwait(false);
  135. jobItemsResult = _repo.GetJobItems(new SyncJobItemQuery
  136. {
  137. Statuses = new List<SyncJobItemStatus> { SyncJobItemStatus.Queued, SyncJobItemStatus.Converting },
  138. JobId = jobId
  139. });
  140. var returnResult = new SyncJobCreationResult
  141. {
  142. Job = GetJob(jobId),
  143. JobItems = jobItemsResult.Items.ToList()
  144. };
  145. if (SyncJobCreated != null)
  146. {
  147. EventHelper.FireEventIfNotNull(SyncJobCreated, this, new GenericEventArgs<SyncJobCreationResult>
  148. {
  149. Argument = returnResult
  150. }, _logger);
  151. }
  152. return returnResult;
  153. }
  154. public async Task UpdateJob(SyncJob job)
  155. {
  156. // Get fresh from the db and only update the fields that are supported to be changed.
  157. var instance = _repo.GetJob(job.Id);
  158. instance.Name = job.Name;
  159. instance.Quality = job.Quality;
  160. instance.UnwatchedOnly = job.UnwatchedOnly;
  161. instance.SyncNewContent = job.SyncNewContent;
  162. instance.ItemLimit = job.ItemLimit;
  163. await _repo.Update(instance).ConfigureAwait(false);
  164. OnSyncJobUpdated(instance);
  165. }
  166. internal void OnSyncJobUpdated(SyncJob job)
  167. {
  168. if (SyncJobUpdated != null)
  169. {
  170. EventHelper.FireEventIfNotNull(SyncJobUpdated, this, new GenericEventArgs<SyncJob>
  171. {
  172. Argument = job
  173. }, _logger);
  174. }
  175. }
  176. internal async Task UpdateSyncJobItemInternal(SyncJobItem jobItem)
  177. {
  178. await _repo.Update(jobItem).ConfigureAwait(false);
  179. if (SyncJobUpdated != null)
  180. {
  181. EventHelper.FireEventIfNotNull(SyncJobItemUpdated, this, new GenericEventArgs<SyncJobItem>
  182. {
  183. Argument = jobItem
  184. }, _logger);
  185. }
  186. }
  187. internal void OnSyncJobItemCreated(SyncJobItem job)
  188. {
  189. if (SyncJobUpdated != null)
  190. {
  191. EventHelper.FireEventIfNotNull(SyncJobItemCreated, this, new GenericEventArgs<SyncJobItem>
  192. {
  193. Argument = job
  194. }, _logger);
  195. }
  196. }
  197. public async Task<QueryResult<SyncJob>> GetJobs(SyncJobQuery query)
  198. {
  199. var result = _repo.GetJobs(query);
  200. foreach (var item in result.Items)
  201. {
  202. await FillMetadata(item).ConfigureAwait(false);
  203. }
  204. return result;
  205. }
  206. private async Task FillMetadata(SyncJob job)
  207. {
  208. var target = GetSyncTargets(job.UserId)
  209. .FirstOrDefault(i => string.Equals(i.Id, job.TargetId, StringComparison.OrdinalIgnoreCase));
  210. if (target != null)
  211. {
  212. job.TargetName = target.Name;
  213. }
  214. var item = job.RequestedItemIds
  215. .Select(_libraryManager.GetItemById)
  216. .FirstOrDefault(i => i != null);
  217. if (item == null)
  218. {
  219. var processor = GetSyncJobProcessor();
  220. var user = _userManager.GetUserById(job.UserId);
  221. item = (await processor
  222. .GetItemsForSync(job.Category, job.ParentId, job.RequestedItemIds, user, job.UnwatchedOnly).ConfigureAwait(false))
  223. .FirstOrDefault();
  224. }
  225. if (item != null)
  226. {
  227. var hasSeries = item as IHasSeries;
  228. if (hasSeries != null)
  229. {
  230. job.ParentName = hasSeries.SeriesName;
  231. }
  232. var hasAlbumArtist = item as IHasAlbumArtist;
  233. if (hasAlbumArtist != null)
  234. {
  235. job.ParentName = hasAlbumArtist.AlbumArtists.FirstOrDefault();
  236. }
  237. var primaryImage = item.GetImageInfo(ImageType.Primary, 0);
  238. var itemWithImage = item;
  239. if (primaryImage == null)
  240. {
  241. var parentWithImage = item.Parents.FirstOrDefault(i => i.HasImage(ImageType.Primary));
  242. if (parentWithImage != null)
  243. {
  244. itemWithImage = parentWithImage;
  245. primaryImage = parentWithImage.GetImageInfo(ImageType.Primary, 0);
  246. }
  247. }
  248. if (primaryImage != null)
  249. {
  250. try
  251. {
  252. job.PrimaryImageTag = _imageProcessor.GetImageCacheTag(itemWithImage, ImageType.Primary);
  253. job.PrimaryImageItemId = itemWithImage.Id.ToString("N");
  254. }
  255. catch (Exception ex)
  256. {
  257. _logger.ErrorException("Error getting image info", ex);
  258. }
  259. }
  260. }
  261. }
  262. private void FillMetadata(SyncJobItem jobItem)
  263. {
  264. var item = _libraryManager.GetItemById(jobItem.ItemId);
  265. if (item == null)
  266. {
  267. return;
  268. }
  269. var primaryImage = item.GetImageInfo(ImageType.Primary, 0);
  270. var itemWithImage = item;
  271. if (primaryImage == null)
  272. {
  273. var parentWithImage = item.Parents.FirstOrDefault(i => i.HasImage(ImageType.Primary));
  274. if (parentWithImage != null)
  275. {
  276. itemWithImage = parentWithImage;
  277. primaryImage = parentWithImage.GetImageInfo(ImageType.Primary, 0);
  278. }
  279. }
  280. if (primaryImage != null)
  281. {
  282. try
  283. {
  284. jobItem.PrimaryImageTag = _imageProcessor.GetImageCacheTag(itemWithImage, ImageType.Primary);
  285. jobItem.PrimaryImageItemId = itemWithImage.Id.ToString("N");
  286. }
  287. catch (Exception ex)
  288. {
  289. _logger.ErrorException("Error getting image info", ex);
  290. }
  291. }
  292. }
  293. public async Task CancelJob(string id)
  294. {
  295. var job = GetJob(id);
  296. if (job == null)
  297. {
  298. throw new ArgumentException("Job not found.");
  299. }
  300. await _repo.DeleteJob(id).ConfigureAwait(false);
  301. var path = GetSyncJobProcessor().GetTemporaryPath(id);
  302. try
  303. {
  304. _fileSystem.DeleteDirectory(path, true);
  305. }
  306. catch (DirectoryNotFoundException)
  307. {
  308. }
  309. catch (Exception ex)
  310. {
  311. _logger.ErrorException("Error deleting directory {0}", ex, path);
  312. }
  313. if (SyncJobCancelled != null)
  314. {
  315. EventHelper.FireEventIfNotNull(SyncJobCancelled, this, new GenericEventArgs<SyncJob>
  316. {
  317. Argument = job
  318. }, _logger);
  319. }
  320. }
  321. public SyncJob GetJob(string id)
  322. {
  323. return _repo.GetJob(id);
  324. }
  325. public IEnumerable<SyncTarget> GetSyncTargets(string userId)
  326. {
  327. return _providers
  328. .SelectMany(i => GetSyncTargets(i, userId))
  329. .OrderBy(i => i.Name);
  330. }
  331. private IEnumerable<SyncTarget> GetSyncTargets(ISyncProvider provider, string userId)
  332. {
  333. return provider.GetSyncTargets(userId).Select(i => new SyncTarget
  334. {
  335. Name = i.Name,
  336. Id = GetSyncTargetId(provider, i)
  337. });
  338. }
  339. private string GetSyncTargetId(ISyncProvider provider, SyncTarget target)
  340. {
  341. var hasUniqueId = provider as IHasUniqueTargetIds;
  342. if (hasUniqueId != null)
  343. {
  344. return target.Id;
  345. }
  346. var providerId = GetSyncProviderId(provider);
  347. return (providerId + "-" + target.Id).GetMD5().ToString("N");
  348. }
  349. private ISyncProvider GetSyncProvider(SyncTarget target)
  350. {
  351. var providerId = target.Id.Split(new[] { '-' }, 2).First();
  352. return _providers.First(i => string.Equals(providerId, GetSyncProviderId(i)));
  353. }
  354. private string GetSyncProviderId(ISyncProvider provider)
  355. {
  356. return (provider.GetType().Name).GetMD5().ToString("N");
  357. }
  358. public bool SupportsSync(BaseItem item)
  359. {
  360. if (item is Playlist)
  361. {
  362. return true;
  363. }
  364. if (item is Person)
  365. {
  366. return false;
  367. }
  368. if (item is Year)
  369. {
  370. return false;
  371. }
  372. if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase) ||
  373. string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase) ||
  374. string.Equals(item.MediaType, MediaType.Photo, StringComparison.OrdinalIgnoreCase) ||
  375. string.Equals(item.MediaType, MediaType.Game, StringComparison.OrdinalIgnoreCase) ||
  376. string.Equals(item.MediaType, MediaType.Book, StringComparison.OrdinalIgnoreCase))
  377. {
  378. if (item.LocationType == LocationType.Virtual)
  379. {
  380. return false;
  381. }
  382. if (!item.RunTimeTicks.HasValue)
  383. {
  384. return false;
  385. }
  386. var video = item as Video;
  387. if (video != null)
  388. {
  389. if (video.VideoType == VideoType.Iso)
  390. {
  391. return false;
  392. }
  393. if (video.VideoType == VideoType.BluRay || video.VideoType == VideoType.Dvd || video.VideoType == VideoType.HdDvd)
  394. {
  395. return false;
  396. }
  397. if (video.IsPlaceHolder)
  398. {
  399. return false;
  400. }
  401. if (video.IsArchive)
  402. {
  403. return false;
  404. }
  405. if (video.IsStacked)
  406. {
  407. return false;
  408. }
  409. if (video.IsShortcut)
  410. {
  411. return false;
  412. }
  413. }
  414. var game = item as Game;
  415. if (game != null)
  416. {
  417. if (game.IsMultiPart)
  418. {
  419. return false;
  420. }
  421. }
  422. if (item is LiveTvChannel || item is IChannelItem || item is ILiveTvRecording)
  423. {
  424. return false;
  425. }
  426. // It would be nice to support these later
  427. if (item is Game || item is Book)
  428. {
  429. return false;
  430. }
  431. return true;
  432. }
  433. return item.LocationType == LocationType.FileSystem || item is Season || item is ILiveTvRecording;
  434. }
  435. private string GetDefaultName(BaseItem item)
  436. {
  437. return item.Name;
  438. }
  439. public DeviceProfile GetDeviceProfile(string targetId)
  440. {
  441. foreach (var provider in _providers)
  442. {
  443. foreach (var target in GetSyncTargets(provider, null))
  444. {
  445. if (string.Equals(target.Id, targetId, StringComparison.OrdinalIgnoreCase))
  446. {
  447. return provider.GetDeviceProfile(target);
  448. }
  449. }
  450. }
  451. return null;
  452. }
  453. public async Task ReportSyncJobItemTransferred(string id)
  454. {
  455. var jobItem = _repo.GetJobItem(id);
  456. jobItem.Status = SyncJobItemStatus.Synced;
  457. jobItem.Progress = 100;
  458. if (!string.IsNullOrWhiteSpace(jobItem.TemporaryPath))
  459. {
  460. try
  461. {
  462. _fileSystem.DeleteDirectory(jobItem.TemporaryPath, true);
  463. }
  464. catch (DirectoryNotFoundException)
  465. {
  466. }
  467. catch (Exception ex)
  468. {
  469. _logger.ErrorException("Error deleting temporary job file: {0}", ex, jobItem.OutputPath);
  470. }
  471. }
  472. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  473. var processor = GetSyncJobProcessor();
  474. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  475. }
  476. private SyncJobProcessor GetSyncJobProcessor()
  477. {
  478. return new SyncJobProcessor(_libraryManager, _repo, this, _logger, _userManager, _tvSeriesManager, _mediaEncoder(), _subtitleEncoder(), _config, _fileSystem);
  479. }
  480. public SyncJobItem GetJobItem(string id)
  481. {
  482. return _repo.GetJobItem(id);
  483. }
  484. public QueryResult<SyncJobItem> GetJobItems(SyncJobItemQuery query)
  485. {
  486. var result = _repo.GetJobItems(query);
  487. if (query.AddMetadata)
  488. {
  489. result.Items.ForEach(FillMetadata);
  490. }
  491. return result;
  492. }
  493. private SyncedItem GetJobItemInfo(SyncJobItem jobItem)
  494. {
  495. var job = _repo.GetJob(jobItem.JobId);
  496. if (job == null)
  497. {
  498. _logger.Error("GetJobItemInfo job id {0} no longer exists", jobItem.JobId);
  499. return null;
  500. }
  501. var libraryItem = _libraryManager.GetItemById(jobItem.ItemId);
  502. if (libraryItem == null)
  503. {
  504. _logger.Error("GetJobItemInfo library item with id {0} no longer exists", jobItem.ItemId);
  505. return null;
  506. }
  507. var syncedItem = new SyncedItem
  508. {
  509. SyncJobId = jobItem.JobId,
  510. SyncJobItemId = jobItem.Id,
  511. ServerId = _appHost.SystemId,
  512. UserId = job.UserId,
  513. AdditionalFiles = jobItem.AdditionalFiles.Select(i => new ItemFileInfo
  514. {
  515. ImageType = i.ImageType,
  516. Name = i.Name,
  517. Type = i.Type,
  518. Index = i.Index
  519. }).ToList()
  520. };
  521. var dtoOptions = new DtoOptions();
  522. // Remove some bloat
  523. dtoOptions.Fields.Remove(ItemFields.MediaStreams);
  524. dtoOptions.Fields.Remove(ItemFields.IndexOptions);
  525. dtoOptions.Fields.Remove(ItemFields.MediaSourceCount);
  526. dtoOptions.Fields.Remove(ItemFields.OriginalPrimaryImageAspectRatio);
  527. dtoOptions.Fields.Remove(ItemFields.Path);
  528. dtoOptions.Fields.Remove(ItemFields.SeriesGenres);
  529. dtoOptions.Fields.Remove(ItemFields.Settings);
  530. dtoOptions.Fields.Remove(ItemFields.SyncInfo);
  531. syncedItem.Item = _dtoService().GetBaseItemDto(libraryItem, dtoOptions);
  532. var mediaSource = syncedItem.Item.MediaSources
  533. .FirstOrDefault(i => string.Equals(i.Id, jobItem.MediaSourceId));
  534. syncedItem.Item.MediaSources = new List<MediaSourceInfo>();
  535. // This will be null for items that are not audio/video
  536. if (mediaSource == null)
  537. {
  538. syncedItem.OriginalFileName = Path.GetFileName(libraryItem.Path);
  539. }
  540. else
  541. {
  542. syncedItem.OriginalFileName = Path.GetFileName(mediaSource.Path);
  543. syncedItem.Item.MediaSources.Add(mediaSource);
  544. }
  545. return syncedItem;
  546. }
  547. public Task ReportOfflineAction(UserAction action)
  548. {
  549. return Task.FromResult(true);
  550. }
  551. public List<SyncedItem> GetReadySyncItems(string targetId)
  552. {
  553. var jobItemResult = GetJobItems(new SyncJobItemQuery
  554. {
  555. TargetId = targetId,
  556. Statuses = new List<SyncJobItemStatus>
  557. {
  558. SyncJobItemStatus.ReadyToTransfer
  559. }
  560. });
  561. return jobItemResult.Items
  562. .Select(GetJobItemInfo)
  563. .Where(i => i != null)
  564. .ToList();
  565. }
  566. public async Task<SyncDataResponse> SyncData(SyncDataRequest request)
  567. {
  568. var jobItemResult = GetJobItems(new SyncJobItemQuery
  569. {
  570. TargetId = request.TargetId,
  571. Statuses = new List<SyncJobItemStatus> { SyncJobItemStatus.Synced }
  572. });
  573. var response = new SyncDataResponse();
  574. foreach (var jobItem in jobItemResult.Items)
  575. {
  576. if (request.LocalItemIds.Contains(jobItem.ItemId, StringComparer.OrdinalIgnoreCase))
  577. {
  578. var job = _repo.GetJob(jobItem.JobId);
  579. var user = _userManager.GetUserById(job.UserId);
  580. if (jobItem.IsMarkedForRemoval)
  581. {
  582. // Tell the device to remove it since it has been marked for removal
  583. response.ItemIdsToRemove.Add(jobItem.ItemId);
  584. }
  585. else if (user == null)
  586. {
  587. // Tell the device to remove it since the user is gone now
  588. response.ItemIdsToRemove.Add(jobItem.ItemId);
  589. }
  590. else if (job.UnwatchedOnly)
  591. {
  592. var libraryItem = _libraryManager.GetItemById(jobItem.ItemId);
  593. if (IsLibraryItemAvailable(libraryItem))
  594. {
  595. if (libraryItem.IsPlayed(user) && libraryItem is Video)
  596. {
  597. // Tell the device to remove it since it has been played
  598. response.ItemIdsToRemove.Add(jobItem.ItemId);
  599. }
  600. }
  601. else
  602. {
  603. // Tell the device to remove it since it's no longer available
  604. response.ItemIdsToRemove.Add(jobItem.ItemId);
  605. }
  606. }
  607. }
  608. else
  609. {
  610. // Content is no longer on the device
  611. jobItem.Status = SyncJobItemStatus.RemovedFromDevice;
  612. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  613. }
  614. }
  615. // Now check each item that's on the device
  616. foreach (var itemId in request.LocalItemIds)
  617. {
  618. // See if it's already marked for removal
  619. if (response.ItemIdsToRemove.Contains(itemId, StringComparer.OrdinalIgnoreCase))
  620. {
  621. continue;
  622. }
  623. // If there isn't a sync job for this item, mark it for removal
  624. if (!jobItemResult.Items.Any(i => string.Equals(itemId, i.ItemId, StringComparison.OrdinalIgnoreCase)))
  625. {
  626. response.ItemIdsToRemove.Add(itemId);
  627. }
  628. }
  629. response.ItemIdsToRemove = response.ItemIdsToRemove.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
  630. var itemsOnDevice = request.LocalItemIds
  631. .Except(response.ItemIdsToRemove)
  632. .ToList();
  633. SetUserAccess(request, response, itemsOnDevice);
  634. return response;
  635. }
  636. private void SetUserAccess(SyncDataRequest request, SyncDataResponse response, List<string> itemIds)
  637. {
  638. var users = request.OfflineUserIds
  639. .Select(_userManager.GetUserById)
  640. .Where(i => i != null)
  641. .ToList();
  642. foreach (var itemId in itemIds)
  643. {
  644. var item = _libraryManager.GetItemById(itemId);
  645. if (item != null)
  646. {
  647. var usersWithAccess = new List<User>();
  648. foreach (var user in users)
  649. {
  650. if (IsUserVisible(item, user))
  651. {
  652. usersWithAccess.Add(user);
  653. }
  654. }
  655. response.ItemUserAccess[itemId] = users
  656. .Select(i => i.Id.ToString("N"))
  657. .OrderBy(i => i)
  658. .ToList();
  659. }
  660. }
  661. }
  662. private bool IsUserVisible(BaseItem item, User user)
  663. {
  664. return item.IsVisibleStandalone(user);
  665. }
  666. private bool IsLibraryItemAvailable(BaseItem item)
  667. {
  668. if (item == null)
  669. {
  670. return false;
  671. }
  672. // TODO: Make sure it hasn't been deleted
  673. return true;
  674. }
  675. public async Task ReEnableJobItem(string id)
  676. {
  677. var jobItem = _repo.GetJobItem(id);
  678. if (jobItem.Status != SyncJobItemStatus.Failed && jobItem.Status != SyncJobItemStatus.Cancelled)
  679. {
  680. throw new ArgumentException("Operation is not valid for this job item");
  681. }
  682. jobItem.Status = SyncJobItemStatus.Queued;
  683. jobItem.Progress = 0;
  684. jobItem.IsMarkedForRemoval = false;
  685. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  686. var processor = GetSyncJobProcessor();
  687. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  688. }
  689. public async Task CancelJobItem(string id)
  690. {
  691. var jobItem = _repo.GetJobItem(id);
  692. if (jobItem.Status != SyncJobItemStatus.Queued && jobItem.Status != SyncJobItemStatus.ReadyToTransfer && jobItem.Status != SyncJobItemStatus.Converting)
  693. {
  694. throw new ArgumentException("Operation is not valid for this job item");
  695. }
  696. jobItem.Status = SyncJobItemStatus.Cancelled;
  697. jobItem.Progress = 0;
  698. jobItem.IsMarkedForRemoval = true;
  699. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  700. var processor = GetSyncJobProcessor();
  701. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  702. var path = processor.GetTemporaryPath(jobItem);
  703. try
  704. {
  705. _fileSystem.DeleteDirectory(path, true);
  706. }
  707. catch (DirectoryNotFoundException)
  708. {
  709. }
  710. catch (Exception ex)
  711. {
  712. _logger.ErrorException("Error deleting directory {0}", ex, path);
  713. }
  714. }
  715. public async Task MarkJobItemForRemoval(string id)
  716. {
  717. var jobItem = _repo.GetJobItem(id);
  718. if (jobItem.Status != SyncJobItemStatus.Synced)
  719. {
  720. throw new ArgumentException("Operation is not valid for this job item");
  721. }
  722. jobItem.IsMarkedForRemoval = true;
  723. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  724. var processor = GetSyncJobProcessor();
  725. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  726. }
  727. public async Task UnmarkJobItemForRemoval(string id)
  728. {
  729. var jobItem = _repo.GetJobItem(id);
  730. if (jobItem.Status != SyncJobItemStatus.Synced)
  731. {
  732. throw new ArgumentException("Operation is not valid for this job item");
  733. }
  734. jobItem.IsMarkedForRemoval = false;
  735. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  736. var processor = GetSyncJobProcessor();
  737. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  738. }
  739. public async Task ReportSyncJobItemTransferBeginning(string id)
  740. {
  741. var jobItem = _repo.GetJobItem(id);
  742. jobItem.Status = SyncJobItemStatus.Transferring;
  743. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  744. var processor = GetSyncJobProcessor();
  745. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  746. }
  747. public async Task ReportSyncJobItemTransferFailed(string id)
  748. {
  749. var jobItem = _repo.GetJobItem(id);
  750. jobItem.Status = SyncJobItemStatus.ReadyToTransfer;
  751. await UpdateSyncJobItemInternal(jobItem).ConfigureAwait(false);
  752. var processor = GetSyncJobProcessor();
  753. await processor.UpdateJobStatus(jobItem.JobId).ConfigureAwait(false);
  754. }
  755. public QueryResult<string> GetLibraryItemIds(SyncJobItemQuery query)
  756. {
  757. return _repo.GetLibraryItemIds(query);
  758. }
  759. public AudioOptions GetAudioOptions(SyncJobItem jobItem)
  760. {
  761. var profile = GetDeviceProfile(jobItem.TargetId);
  762. return new AudioOptions
  763. {
  764. Profile = profile
  765. };
  766. }
  767. public VideoOptions GetVideoOptions(SyncJobItem jobItem, SyncJob job)
  768. {
  769. var profile = GetDeviceProfile(jobItem.TargetId);
  770. var maxBitrate = profile.MaxStaticBitrate;
  771. if (maxBitrate.HasValue)
  772. {
  773. if (job.Quality == SyncQuality.Medium)
  774. {
  775. maxBitrate = Convert.ToInt32(maxBitrate.Value * .75);
  776. }
  777. else if (job.Quality == SyncQuality.Low)
  778. {
  779. maxBitrate = Convert.ToInt32(maxBitrate.Value * .5);
  780. }
  781. }
  782. return new VideoOptions
  783. {
  784. Profile = profile,
  785. MaxBitrate = maxBitrate
  786. };
  787. }
  788. }
  789. }