public async Task<RefreshResult> RefreshImages(IHasImages item, IEnumerable<IImageProvider> imageProviders, ImageRefreshOptions refreshOptions, MetadataOptions savedOptions, CancellationToken cancellationToken)
{
if (refreshOptions.IsReplacingImage(ImageType.Backdrop))
{
ClearImages(item, ImageType.Backdrop);
}
if (refreshOptions.IsReplacingImage(ImageType.Screenshot))
{
ClearImages(item, ImageType.Screenshot);
}
var result = new RefreshResult { UpdateType = ItemUpdateType.None };
var providers = imageProviders.ToList();
var providerIds = new List<Guid>();
// In order to avoid duplicates, only download these if there are none already
var backdropLimit = savedOptions.GetLimit(ImageType.Backdrop);
var screenshotLimit = savedOptions.GetLimit(ImageType.Screenshot);
var downloadedImages = new List<ImageType>();
foreach (var provider in providers)
{
var remoteProvider = provider as IRemoteImageProvider;
if (remoteProvider != null)
{
await RefreshFromProvider(item, remoteProvider, refreshOptions, savedOptions, backdropLimit, screenshotLimit, downloadedImages, result, cancellationToken).ConfigureAwait(false);
providerIds.Add(provider.GetType().FullName.GetMD5());
continue;
}
var dynamicImageProvider = provider as IDynamicImageProvider;
if (dynamicImageProvider != null)
{
await RefreshFromProvider(item, dynamicImageProvider, refreshOptions, savedOptions, downloadedImages, result, cancellationToken).ConfigureAwait(false);
providerIds.Add(provider.GetType().FullName.GetMD5());
}
}
result.Providers = providerIds;
return result;
}
public void RefreshResultTest()
{
StateController.Navigate("d0");
StateController.Navigate("t0", new NavigationData { { "a", 1 } });
RefreshResult result = new RefreshResult();
result.ExecuteResult(GetControllerContext(false));
Assert.AreEqual("s1", StateContext.State.Key);
Assert.IsNull(StateContext.Bag.a);
}
public void RefreshResultChildActionTest()
{
StateController.Navigate("d0");
StateController.Navigate("t0", new NavigationData { { "a", 1 } });
RefreshResult result = new RefreshResult();
result.ExecuteResult(GetControllerContext(true));
}
public void RefreshResultNullContextTest()
{
StateController.Navigate("d0");
StateController.Navigate("t0", new NavigationData { { "a", 1 } });
RefreshResult result = new RefreshResult();
result.ExecuteResult(null);
}
private async Task<bool> DownloadImage(IHasImages item,
IRemoteImageProvider provider,
RefreshResult result,
IEnumerable<RemoteImageInfo> images,
int minWidth,
ImageType type,
CancellationToken cancellationToken)
{
foreach (var image in images.Where(i => i.Type == type))
{
if (image.Width.HasValue && image.Width.Value < minWidth)
{
continue;
}
var url = image.Url;
try
{
var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
await _providerManager.SaveImage(item, response.Content, response.ContentType, type, null, cancellationToken).ConfigureAwait(false);
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
return true;
}
catch (HttpException ex)
{
// Sometimes providers send back bad url's. Just move to the next image
if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
{
continue;
}
break;
}
}
return false;
}
private async Task DownloadBackdrops(IHasImages item, ImageType imageType, int limit, IRemoteImageProvider provider, RefreshResult result, IEnumerable<RemoteImageInfo> images, int minWidth, CancellationToken cancellationToken)
{
foreach (var image in images.Where(i => i.Type == imageType))
{
if (item.GetImages(imageType).Count() >= limit)
{
break;
}
if (image.Width.HasValue && image.Width.Value < minWidth)
{
continue;
}
var url = image.Url;
try
{
var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
// If there's already an image of the same size, skip it
if (response.ContentLength.HasValue)
{
try
{
if (item.GetImages(imageType).Any(i => new FileInfo(i.Path).Length == response.ContentLength.Value))
{
response.Content.Dispose();
continue;
}
}
catch (IOException ex)
{
_logger.ErrorException("Error examining images", ex);
}
}
await _providerManager.SaveImage(item, response.Content, response.ContentType, imageType, null, cancellationToken).ConfigureAwait(false);
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
}
catch (HttpException ex)
{
// Sometimes providers send back bad url's. Just move onto the next image
if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
{
continue;
}
break;
}
}
}
/// <summary>
/// Refreshes from provider.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="provider">The provider.</param>
/// <param name="refreshOptions">The refresh options.</param>
/// <param name="savedOptions">The saved options.</param>
/// <param name="downloadedImages">The downloaded images.</param>
/// <param name="result">The result.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task RefreshFromProvider(IHasImages item,
IDynamicImageProvider provider,
ImageRefreshOptions refreshOptions,
MetadataOptions savedOptions,
ICollection<ImageType> downloadedImages,
RefreshResult result,
CancellationToken cancellationToken)
{
try
{
var images = provider.GetSupportedImages(item);
foreach (var imageType in images)
{
if (!IsEnabled(savedOptions, imageType, item)) continue;
if (!item.HasImage(imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
{
_logger.Debug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
var response = await provider.GetImage(item, imageType, cancellationToken).ConfigureAwait(false);
if (response.HasImage)
{
if (!string.IsNullOrEmpty(response.Path))
{
var mimeType = "image/" + Path.GetExtension(response.Path).TrimStart('.').ToLower();
var stream = _fileSystem.GetFileStream(response.Path, FileMode.Open, FileAccess.Read, FileShare.Read, true);
await _providerManager.SaveImage(item, stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
}
else
{
var mimeType = "image/" + response.Format.ToString().ToLower();
await _providerManager.SaveImage(item, response.Stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
}
downloadedImages.Add(imageType);
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
result.Status = ProviderRefreshStatus.CompletedWithErrors;
_logger.ErrorException("Error in {0}", ex, provider.Name);
}
}
/// <summary>
/// Refreshes from provider.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="provider">The provider.</param>
/// <param name="refreshOptions">The refresh options.</param>
/// <param name="savedOptions">The saved options.</param>
/// <param name="backdropLimit">The backdrop limit.</param>
/// <param name="screenshotLimit">The screenshot limit.</param>
/// <param name="downloadedImages">The downloaded images.</param>
/// <param name="result">The result.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task RefreshFromProvider(IHasImages item,
IRemoteImageProvider provider,
ImageRefreshOptions refreshOptions,
MetadataOptions savedOptions,
int backdropLimit,
int screenshotLimit,
ICollection<ImageType> downloadedImages,
RefreshResult result,
CancellationToken cancellationToken)
{
try
{
if (!item.SupportsRemoteImageDownloading)
{
return;
}
if (!refreshOptions.ReplaceAllImages &&
refreshOptions.ReplaceImages.Count == 0 &&
ContainsImages(item, provider.GetSupportedImages(item).ToList(), savedOptions, backdropLimit, screenshotLimit))
{
return;
}
_logger.Debug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
var images = await _providerManager.GetAvailableRemoteImages(item, new RemoteImageQuery
{
ProviderName = provider.Name,
IncludeAllLanguages = false,
IncludeDisabledProviders = false,
}, cancellationToken).ConfigureAwait(false);
var list = images.ToList();
int minWidth;
foreach (var imageType in _singularImages)
{
if (!IsEnabled(savedOptions, imageType, item)) continue;
if (!item.HasImage(imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
{
minWidth = savedOptions.GetMinWidth(imageType);
var downloaded = await DownloadImage(item, provider, result, list, minWidth, imageType, cancellationToken).ConfigureAwait(false);
if (downloaded)
{
downloadedImages.Add(imageType);
}
}
}
if (!item.LockedFields.Contains(MetadataFields.Backdrops))
{
minWidth = savedOptions.GetMinWidth(ImageType.Backdrop);
await DownloadBackdrops(item, ImageType.Backdrop, backdropLimit, provider, result, list, minWidth, cancellationToken).ConfigureAwait(false);
}
if (!item.LockedFields.Contains(MetadataFields.Screenshots))
{
var hasScreenshots = item as IHasScreenshots;
if (hasScreenshots != null)
{
minWidth = savedOptions.GetMinWidth(ImageType.Screenshot);
await DownloadBackdrops(item, ImageType.Screenshot, screenshotLimit, provider, result, list, minWidth, cancellationToken).ConfigureAwait(false);
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
result.Status = ProviderRefreshStatus.CompletedWithErrors;
_logger.ErrorException("Error in {0}", ex, provider.Name);
}
}
private List<RefreshResult> ExecuteAllFuns()
{
List<RefreshResult> results = new List<RefreshResult>();
foreach (var item in funs.OrderByDescending(c => c.Value.Order))
{
RefreshResult rr = null;
try
{
rr = item.Value.Refresh();
rr.Source = item.Value;
}
catch (Exception ex)
{
rr = new RefreshResult() { IsSuccessful = false, Message = ex.Message, Source = item.Value };
}
results.Add(rr);
}
return results;
}
private List<RefreshResult> ExecuteFun(string keyFullName)
{
List<RefreshResult> results = new List<RefreshResult>();
// Func<RefreshResult> fun = null;
if (string.IsNullOrWhiteSpace(keyFullName))
{
results.Add(new RefreshResult() { IsSuccessful = false, Message = "keyFullName 不能为空。" });
return results;
}
try
{
keyFullName = keyFullName.ToLowerInvariant();
var query = funs.Where(c => GetFullName(c.Value).Equals(keyFullName, StringComparison.CurrentCultureIgnoreCase)).OrderByDescending(c => c.Value.Order).ToList();
if (query.Count > 0)
{
RefreshResult rr = null;
foreach (var item in query)
{
try
{
rr = item.Value.Refresh();
rr.Source = item.Value;
}
catch (Exception ex)
{
rr = new RefreshResult() { IsSuccessful = false, Message = ex.Message, Source = item.Value };
}
results.Add(rr);
}
}
}
catch (Exception ex)
{
results.Add(new RefreshResult() { IsSuccessful = false, Message = ex.Message });
}
return results;
}
public RefreshResponseInfoDC(TimeSpan registrationLifetime, RefreshResult result)
{
this.RegistrationLifetime = registrationLifetime;
this.Result = result;
}
public RefreshResponseInfo(TimeSpan registrationLifetime, RefreshResult result)
{
this.body = new RefreshResponseInfoDC(registrationLifetime, result);
}
/// <summary>
/// Refreshes from provider.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="provider">The provider.</param>
/// <param name="refreshOptions">The refresh options.</param>
/// <param name="savedOptions">The saved options.</param>
/// <param name="downloadedImages">The downloaded images.</param>
/// <param name="result">The result.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task RefreshFromProvider(IHasImages item,
IDynamicImageProvider provider,
ImageRefreshOptions refreshOptions,
MetadataOptions savedOptions,
ICollection<ImageType> downloadedImages,
RefreshResult result,
CancellationToken cancellationToken)
{
try
{
var images = provider.GetSupportedImages(item);
foreach (var imageType in images)
{
if (!IsEnabled(savedOptions, imageType, item)) continue;
if (!HasImage(item, imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
{
_logger.Debug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
var response = await provider.GetImage(item, imageType, cancellationToken).ConfigureAwait(false);
if (response.HasImage)
{
if (!string.IsNullOrEmpty(response.Path))
{
if (response.Protocol == MediaProtocol.Http)
{
_logger.Debug("Setting image url into item {0}", item.Id);
item.SetImage(new ItemImageInfo
{
Path = response.Path,
Type = imageType
}, 0);
}
else
{
var mimeType = MimeTypes.GetMimeType(response.Path);
var stream = _fileSystem.GetFileStream(response.Path, FileMode.Open, FileAccess.Read, FileShare.Read, true);
await _providerManager.SaveImage(item, stream, mimeType, imageType, null, response.InternalCacheKey, cancellationToken).ConfigureAwait(false);
}
}
else
{
var mimeType = "image/" + response.Format.ToString().ToLower();
await _providerManager.SaveImage(item, response.Stream, mimeType, imageType, null, response.InternalCacheKey, cancellationToken).ConfigureAwait(false);
}
downloadedImages.Add(imageType);
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
_logger.ErrorException("Error in {0}", ex, provider.Name);
}
}
public RefreshResponseInfo (TimeSpan registrationLifetime, RefreshResult result)
{
Body.RegistrationLifetime = registrationLifetime;
Body.Result = result;
}
public RefreshResponseInfo (TimeSpan registrationLifetime, RefreshResult result)
: this ()
{
body.RegistrationLifetime = registrationLifetime;
body.Result = result;
}
