private bool IsEnabled(MetadataOptions options, ImageType type, IHasImages item)
{
if (type == ImageType.Backdrop)
{
if (item.LockedFields.Contains(MetadataFields.Backdrops))
{
return(false);
}
}
else if (type == ImageType.Screenshot)
{
if (item.LockedFields.Contains(MetadataFields.Screenshots))
{
return(false);
}
}
else
{
if (item.LockedFields.Contains(MetadataFields.Images))
{
return(false);
}
}
return(options.IsEnabled(type));
}
private int GetConfiguredOrder(IMetadataProvider provider, MetadataOptions options)
{
// See if there's a user-defined order
if (provider is ILocalMetadataProvider)
{
var index = Array.IndexOf(options.LocalMetadataReaderOrder, provider.Name);
if (index != -1)
{
return(index);
}
}
// See if there's a user-defined order
if (provider is IRemoteMetadataProvider)
{
var index = Array.IndexOf(options.MetadataFetcherOrder, provider.Name);
if (index != -1)
{
return(index);
}
}
// Not configured. Just return some high number to put it at the end.
return(100);
}
private void AddMetadataPlugins <T>(List <MetadataPlugin> list, T item, MetadataOptions options)
where T : IHasMetadata
{
var providers = GetMetadataProvidersInternal <T>(item, options, true, false).ToList();
// Locals
list.AddRange(providers.Where(i => (i is ILocalMetadataProvider)).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.LocalMetadataProvider
}));
if (item.IsInternetMetadataEnabled())
{
// Fetchers
list.AddRange(providers.Where(i => (i is IRemoteMetadataProvider)).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.MetadataFetcher
}));
}
if (item.IsSaveLocalMetadataEnabled())
{
// Savers
list.AddRange(_savers.Where(i => IsSaverEnabledForItem(i, item, ItemUpdateType.MetadataEdit, true)).OrderBy(i => i.Name).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.MetadataSaver
}));
}
}
public static void Run()
{
// ExStart:1
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Open Workbook metadata
MetadataOptions options = new MetadataOptions(MetadataType.DocumentProperties);
WorkbookMetadata meta = new WorkbookMetadata(dataDir + "Sample1.xlsx", options);
// Set some properties
meta.CustomDocumentProperties.Add("test", "test");
// Save the metadata info
meta.Save(dataDir + "Sample2.out.xlsx");
// Open the workbook
Workbook w = new Workbook(dataDir + "Sample2.out.xlsx");
// Read document property
Console.WriteLine(w.CustomDocumentProperties["test"]);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
// ExEnd:1
}
/// <summary>
/// Creates a new instance of <see cref="MetaModel"/>.
/// </summary>
/// <param name="options">The options to use.</param>
/// <param name="canonicalUri">The optional canonical URI of the page.</param>
/// <param name="hostName">The optional host name.</param>
/// <param name="description">The optional page description.</param>
/// <param name="imageUri">The optional image URI.</param>
/// <param name="imageAltText">The optional image alternate text.</param>
/// <param name="robots">The optional robots value.</param>
/// <param name="title">The optional page title.</param>
/// <returns>
/// The created instance of <see cref="MetaModel"/>.
/// </returns>
public static MetaModel Create(
MetadataOptions options,
string canonicalUri = null,
string hostName = null,
string description = null,
string imageUri = null,
string imageAltText = null,
string robots = null,
string title = null)
{
return new MetaModel()
{
Author = options.Author.Name,
Bitcoin = options.Author.Bitcoin,
CanonicalUri = canonicalUri ?? string.Empty,
Description = description ?? options.Description,
FacebookApp = options?.SocialMedia?.Facebook,
FacebookProfile = options?.Author?.SocialMedia?.Facebook,
HostName = options.Domain,
ImageUri = imageUri ?? options.Image ?? string.Empty,
ImageAltText = imageAltText ?? options.Name,
Keywords = options.Keywords ?? "alexa,london travel",
Robots = robots ?? options.Robots,
SiteName = options.Name ?? "London Travel is an Amazon Alexa skill for checking the status for travel in London.",
SiteType = options.Type ?? "website",
Title = $"{title} - {options.Name}",
TwitterCard = "summary",
TwitterHandle = options?.Author?.SocialMedia?.Twitter,
};
}
public static void Run()
{
//Source directory
string sourceDir = RunExamples.Get_SourceDirectory();
//Output directory
string outputDir = RunExamples.Get_OutputDirectory();
// Open Workbook metadata
MetadataOptions options = new MetadataOptions(MetadataType.DocumentProperties);
WorkbookMetadata meta = new WorkbookMetadata(sourceDir + "sampleUsingWorkbookMetadata.xlsx", options);
// Set some properties
meta.CustomDocumentProperties.Add("MyTest", "This is My Test");
// Save the metadata info
meta.Save(outputDir + "outputUsingWorkbookMetadata.xlsx");
// Open the workbook
Workbook w = new Workbook(outputDir + "outputUsingWorkbookMetadata.xlsx");
// Read document property
Console.WriteLine("Metadata Custom Property MyTest: " + w.CustomDocumentProperties["MyTest"]);
Console.WriteLine("UsingWorkbookMetadata executed successfully.");
}
/// <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 (!savedOptions.IsEnabled(imageType))
{
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>
/// Registers the metadata middleware into the HTTP pipeline.
/// </summary>
/// <param name="app">The application builder</param>
/// <param name="options">The middleware options</param>
/// <returns>The builder after changes</returns>
/// <exception cref="ArgumentNullException"></exception>
public static IApplicationBuilder UseMetadata(this IApplicationBuilder app, MetadataOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(app.UseMetadata(Options.Create(options)));
}
public void TestMetadataOptions()
{
var options = new MetadataOptions();
Assert.AreEqual(0, options.Depth);
Assert.AreEqual(0, options.LongEntries);
Assert.IsNull(options.MaxSize);
Assert.Throws <ArgumentOutOfRangeException> (() => options.Depth = 500);
}
public static void MetaModel_Create_Handles_Null_Author()
{
// Arrange
var options = new MetadataOptions();
// Act
MetaModel actual = MetaModel.Create(options);
// Assert
actual.ShouldNotBeNull();
}
public R4FhirSpecificationProviderTests()
{
var dataClient = Substitute.For <IFhirDataClient>();
var metadataOptions = new MetadataOptions();
dataClient.Search(metadataOptions)
.ReturnsForAnyArgs(x => TestDataProvider.GetBundleFromFile(TestDataConstants.MetadataFile));
_r4FhirSpecificationProvider = new R4FhirSpecificationProvider(dataClient, _nullR4FhirSpecificationProviderLogger);
}
/// <summary>
/// Creates a new instance of <see cref="MetaModel"/>.
/// </summary>
/// <param name="options">The options to use.</param>
/// <param name="canonicalUri">The optional canonical URI of the page.</param>
/// <param name="hostName">The optional host name.</param>
/// <param name="description">The optional page description.</param>
/// <param name="imageUri">The optional image URI.</param>
/// <param name="imageAltText">The optional image alternate text.</param>
/// <param name="robots">The optional robots value.</param>
/// <param name="title">The optional page title.</param>
/// <returns>
/// The created instance of <see cref="MetaModel"/>.
/// </returns>
public static MetaModel Create(
MetadataOptions?options,
string?canonicalUri = null,
string?hostName = null,
string?description = null,
string?imageUri = null,
string?imageAltText = null,
string?robots = null,
string?title = null)
{
if (options == null)
{
options = new MetadataOptions();
}
var model = new MetaModel();
if (options != null)
{
if (options.Author != null)
{
model.Author = options.Author.Name;
model.Bitcoin = options.Author.Bitcoin;
if (options.Author.SocialMedia != null)
{
model.FacebookProfile = options.Author.SocialMedia.Facebook;
model.TwitterHandle = options.Author.SocialMedia.Twitter;
}
}
model.CanonicalUri = canonicalUri ?? string.Empty;
model.Description = description ?? options.Description;
model.FacebookApp = options.SocialMedia?.Facebook;
model.HostName = hostName ?? options.Domain;
model.ImageUri = imageUri ?? options.Image ?? string.Empty;
model.ImageAltText = imageAltText ?? options.Name;
model.Keywords = options.Keywords ?? "alexa,london travel";
model.Robots = robots ?? options.Robots;
model.SiteName = options.Name ?? "London Travel is an Amazon Alexa skill for checking the status for travel in London.";
model.SiteType = options.Type ?? "website";
model.Title = $"{title} - {model.SiteName}";
model.TwitterCard = "summary";
model.Reviews = BuildReviews();
}
return(model);
}
/// <summary>
/// Determines if an item already contains the given images
/// </summary>
/// <param name="item">The item.</param>
/// <param name="images">The images.</param>
/// <param name="savedOptions">The saved options.</param>
/// <param name="backdropLimit">The backdrop limit.</param>
/// <param name="screenshotLimit">The screenshot limit.</param>
/// <returns><c>true</c> if the specified item contains images; otherwise, <c>false</c>.</returns>
private bool ContainsImages(BaseItem item, List<ImageType> images, MetadataOptions savedOptions, int backdropLimit, int screenshotLimit)
{
if (_singularImages.Any(i => images.Contains(i) && !HasImage(item, i) && savedOptions.GetLimit(i) > 0))
{
return false;
}
if (images.Contains(ImageType.Backdrop) && item.GetImages(ImageType.Backdrop).Count() < backdropLimit)
{
return false;
}
if (images.Contains(ImageType.Screenshot) && item.GetImages(ImageType.Screenshot).Count() < screenshotLimit)
{
return false;
}
return true;
}
public static IMvcBuilder AddIdServerMetadata(this IMvcBuilder builder, Action <MetadataOptions> optionsBuilder)
{
//Build the options each time they are requested, this will not happen that much
builder.Services.AddScoped <MetadataOptions>(s =>
{
var options = new MetadataOptions();
if (optionsBuilder != null)
{
optionsBuilder.Invoke(options);
}
return(options);
});
builder.AddApplicationPart(typeof(MetadataServiceExtensions).Assembly);
return(builder);
}
private bool CanRefresh(IImageProvider provider, IHasImages item, MetadataOptions options, bool includeDisabled)
{
if (!includeDisabled)
{
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalImageProvider))
{
return(false);
}
if (provider is IRemoteImageProvider || provider is IDynamicImageProvider)
{
if (Array.IndexOf(options.DisabledImageFetchers, provider.Name) != -1)
{
return(false);
}
if (provider is IRemoteImageProvider)
{
if (!ConfigurationManager.Configuration.EnableInternetProviders)
{
return(false);
}
}
}
}
if (!item.SupportsLocalMetadata && provider is ILocalImageProvider)
{
return(false);
}
try
{
return(provider.Supports(item));
}
catch (Exception ex)
{
_logger.ErrorException("{0} failed in Supports for type {1}", ex, provider.GetType().Name, item.GetType().Name);
return(false);
}
}
private MetadataOptions GetMetadataOptions(Type type, ServerConfiguration config)
{
var options = config.MetadataOptions
.FirstOrDefault(i => string.Equals(i.ItemType, type.Name, StringComparison.OrdinalIgnoreCase));
if (options == null)
{
var list = config.MetadataOptions.ToList();
options = new MetadataOptions
{
ItemType = type.Name
};
list.Add(options);
config.MetadataOptions = list.ToArray();
}
return(options);
}
private bool CanRefresh(IMetadataProvider provider, IHasMetadata item, MetadataOptions options, bool includeDisabled)
{
if (!includeDisabled)
{
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalMetadataProvider) && !(provider is IForcedProvider))
{
return(false);
}
if (provider is IRemoteMetadataProvider)
{
if (!ConfigurationManager.Configuration.EnableInternetProviders)
{
return(false);
}
if (Array.IndexOf(options.DisabledMetadataFetchers, provider.Name) != -1)
{
return(false);
}
}
}
if (!item.SupportsLocalMetadata && provider is ILocalMetadataProvider)
{
return(false);
}
// If this restriction is ever lifted, movie xml providers will have to be updated to prevent owned items like trailers from reading those files
if (item.IsOwnedItem)
{
if (provider is ILocalMetadataProvider || provider is IRemoteMetadataProvider)
{
return(false);
}
}
return(true);
}
private bool CanRefresh(IImageProvider provider, IHasMetadata item, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
{
if (!includeDisabled)
{
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalImageProvider))
{
if (refreshOptions.ImageRefreshMode != ImageRefreshMode.FullRefresh)
{
return(false);
}
}
if (provider is IRemoteImageProvider || provider is IDynamicImageProvider)
{
if (Array.IndexOf(options.DisabledImageFetchers, provider.Name) != -1)
{
return(false);
}
if (provider is IRemoteImageProvider)
{
if (!refreshOptions.ForceEnableInternetMetadata && !item.IsInternetMetadataEnabled())
{
return(false);
}
}
}
}
try
{
return(provider.Supports(item));
}
catch (Exception ex)
{
_logger.ErrorException("{0} failed in Supports for type {1}", ex, provider.GetType().Name, item.GetType().Name);
return(false);
}
}
public MetadataOptions GetMetadataOptions()
{
MetadataOptions options = new MetadataOptions();
// Copy Json Metdata Options
options.SaveJsonFlags =
(JsonTrimWhiteSpace ? DicomDataSetSaveJsonFlags.TrimWhiteSpace : DicomDataSetSaveJsonFlags.None) |
(JsonWriteKeyword ? DicomDataSetSaveJsonFlags.WriteKeyword : DicomDataSetSaveJsonFlags.None) |
(JsonMinify ? DicomDataSetSaveJsonFlags.Minify : DicomDataSetSaveJsonFlags.None) |
(JsonIgnoreBinaryData ? DicomDataSetSaveJsonFlags.IgnoreBinaryData : DicomDataSetSaveJsonFlags.None);
options.StoreJson = JsonStore;
// Copy XML MetadataOptions
options.SaveXmlFlags =
(XmlTrimWhiteSpace ? DicomDataSetSaveXmlFlags.TrimWhiteSpace : DicomDataSetSaveXmlFlags.None) |
(XmlFullEndStatement ? DicomDataSetSaveXmlFlags.WriteFullEndElement : DicomDataSetSaveXmlFlags.None) |
(XmlIgnoreBinaryData ? DicomDataSetSaveXmlFlags.IgnoreBinaryData : DicomDataSetSaveXmlFlags.None);
options.StoreXml = XmlStore;
return(options);
}
private IEnumerable <IImageProvider> GetImageProviders(IHasImages item, MetadataOptions options, bool includeDisabled)
{
// Avoid implicitly captured closure
var currentOptions = options;
return(ImageProviders.Where(i => CanRefresh(i, item, options, includeDisabled))
.OrderBy(i =>
{
// See if there's a user-defined order
if (!(i is ILocalImageProvider))
{
var index = Array.IndexOf(currentOptions.ImageFetcherOrder, i.Name);
if (index != -1)
{
return index;
}
}
// Not configured. Just return some high number to put it at the end.
return 100;
})
.ThenBy(GetOrder));
}
public static void Main(string[] args)
{
// The path to the documents directory.
string dataDir = Aspose.Cells.Examples.Utils.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Open Workbook metadata
MetadataOptions options = new MetadataOptions(MetadataType.DocumentProperties);
WorkbookMetadata meta = new WorkbookMetadata(dataDir + "Sample1.xlsx", options);
// Set some properties
meta.CustomDocumentProperties.Add("test", "test");
// Save the metadata info
meta.Save(dataDir + "Sample2.xlsx");
// Open the workbook
Workbook w = new Workbook(dataDir+ "Sample2.xlsx");
// Read document property
Console.WriteLine(w.CustomDocumentProperties["test"]);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public void EnableMetadataItems(bool enable, MetadataOptions options)
{
if (this.InvokeRequired)
{
this.BeginInvoke((MethodInvoker) delegate
{
EnableMetadataItems(enable, options);
});
return;
}
// Json
checkBoxJsonStore.Enabled = enable;
checkBoxJsonTrimWhiteSpace.Enabled = enable;
checkBoxJsonWriteKeyword.Enabled = enable;
checkBoxJsonMinify.Enabled = enable;
checkBoxJsonIgnoreBinaryData.Enabled = enable;
buttonJsonDeleteAll.Enabled = enable;
buttonJsonGenerateAll.Enabled = enable;
buttonJsonGenerateMissing.Enabled = enable;
buttonJsonStopGenerate.Visible = !enable && options.StoreJson;
// xml
checkBoxXmlStore.Enabled = enable;
checkBoxXmlTrimWhiteSpace.Enabled = enable;
checkBoxXmlFullEndStatement.Enabled = enable;
checkBoxXmlIgnoreBinaryData.Enabled = enable;
buttonXmlDeleteAll.Enabled = enable;
buttonXmlGenerateAll.Enabled = enable;
buttonXmlGenerateMissing.Enabled = enable;
buttonXmlStopGenerate.Visible = !enable && options.StoreXml;
ClearMetadataStatus();
}
private IEnumerable <IMetadataProvider <T> > GetMetadataProvidersInternal <T>(IHasMetadata item, MetadataOptions options, bool includeDisabled)
where T : IHasMetadata
{
// Avoid implicitly captured closure
var currentOptions = options;
return(_metadataProviders.OfType <IMetadataProvider <T> >()
.Where(i => CanRefresh(i, item, currentOptions, includeDisabled))
.OrderBy(i => GetConfiguredOrder(i, options))
.ThenBy(GetDefaultOrder));
}
private void AddMetadataPlugins <T>(List <MetadataPlugin> list, T item, LibraryOptions libraryOptions, MetadataOptions options)
where T : BaseItem
{
var providers = GetMetadataProvidersInternal <T>(item, libraryOptions, options, true, true).ToList();
// Locals
list.AddRange(providers.Where(i => i is ILocalMetadataProvider).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.LocalMetadataProvider
}));
// Fetchers
list.AddRange(providers.Where(i => i is IRemoteMetadataProvider).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.MetadataFetcher
}));
// Savers
list.AddRange(_savers.Where(i => IsSaverEnabledForItem(i, item, libraryOptions, ItemUpdateType.MetadataEdit, true)).OrderBy(i => i.Name).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.MetadataSaver
}));
}
private int GetConfiguredOrder(BaseItem item, IMetadataProvider provider, LibraryOptions libraryOptions, MetadataOptions globalMetadataOptions)
{
// See if there's a user-defined order
if (provider is ILocalMetadataProvider)
{
var configuredOrder = libraryOptions.LocalMetadataReaderOrder ?? globalMetadataOptions.LocalMetadataReaderOrder;
var index = Array.IndexOf(configuredOrder, provider.Name);
if (index != -1)
{
return(index);
}
}
// See if there's a user-defined order
if (provider is IRemoteMetadataProvider)
{
var typeOptions = libraryOptions.GetTypeOptions(item.GetType().Name);
var typeFetcherOrder = typeOptions?.MetadataFetcherOrder;
var fetcherOrder = typeFetcherOrder ?? globalMetadataOptions.MetadataFetcherOrder;
var index = Array.IndexOf(fetcherOrder, provider.Name);
if (index != -1)
{
return(index);
}
}
// Not configured. Just return some high number to put it at the end.
return(100);
}
private IEnumerable <IMetadataProvider <T> > GetMetadataProvidersInternal <T>(BaseItem item, LibraryOptions libraryOptions, MetadataOptions globalMetadataOptions, bool includeDisabled, bool forceEnableInternetMetadata)
where T : BaseItem
{
// Avoid implicitly captured closure
var currentOptions = globalMetadataOptions;
return(_metadataProviders.OfType <IMetadataProvider <T> >()
.Where(i => CanRefresh(i, item, libraryOptions, includeDisabled, forceEnableInternetMetadata))
.OrderBy(i => GetConfiguredOrder(item, i, libraryOptions, globalMetadataOptions))
.ThenBy(GetDefaultOrder));
}
private IEnumerable <IImageProvider> GetImageProviders(BaseItem item, LibraryOptions libraryOptions, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
{
// Avoid implicitly captured closure
var currentOptions = options;
var typeOptions = libraryOptions.GetTypeOptions(item.GetType().Name);
var typeFetcherOrder = typeOptions?.ImageFetcherOrder;
return(ImageProviders.Where(i => CanRefresh(i, item, libraryOptions, refreshOptions, includeDisabled))
.OrderBy(i =>
{
// See if there's a user-defined order
if (!(i is ILocalImageProvider))
{
var fetcherOrder = typeFetcherOrder ?? currentOptions.ImageFetcherOrder;
var index = Array.IndexOf(fetcherOrder, i.Name);
if (index != -1)
{
return index;
}
}
// Not configured. Just return some high number to put it at the end.
return 100;
})
.ThenBy(GetOrder));
}
private bool CanRefresh(IImageProvider provider, BaseItem item, LibraryOptions libraryOptions, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
{
if (!includeDisabled)
{
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalImageProvider))
{
if (refreshOptions.ImageRefreshMode != MetadataRefreshMode.FullRefresh)
{
return(false);
}
}
if (provider is IRemoteImageProvider || provider is IDynamicImageProvider)
{
if (!item.IsImageFetcherEnabled(libraryOptions, provider.Name))
{
return(false);
}
}
}
try
{
return(provider.Supports(item));
}
catch (Exception ex)
{
_logger.LogError(ex, "{0} failed in Supports for type {1}", provider.GetType().Name, item.GetType().Name);
return(false);
}
}
private bool CanRefresh(IMetadataProvider provider, BaseItem item, LibraryOptions libraryOptions, MetadataOptions options, bool includeDisabled, bool forceEnableInternetMetadata)
{
if (!includeDisabled)
{
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalMetadataProvider) && !(provider is IForcedProvider))
{
return(false);
}
if (provider is IRemoteMetadataProvider)
{
if (!forceEnableInternetMetadata && !item.IsMetadataFetcherEnabled(libraryOptions, provider.Name))
{
return(false);
}
}
}
if (!item.SupportsLocalMetadata && provider is ILocalMetadataProvider)
{
return(false);
}
// If this restriction is ever lifted, movie xml providers will have to be updated to prevent owned items like trailers from reading those files
if (!item.OwnerId.Equals(Guid.Empty))
{
if (provider is ILocalMetadataProvider || provider is IRemoteMetadataProvider)
{
return(false);
}
}
return(true);
}
public async Task<RefreshResult> RefreshImages(BaseItem item, LibraryOptions libraryOptions, List<IImageProvider> providers, 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 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, libraryOptions, 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;
}
private bool IsEnabled(MetadataOptions options, ImageType type, BaseItem item)
{
return options.IsEnabled(type);
}
/// <summary>
/// Gets the specified metadata.
/// </summary>
/// <remarks>
/// Gets the specified metadata.
/// </remarks>
/// <returns>The requested metadata.</returns>
/// <param name="options">The metadata options.</param>
/// <param name="tags">The metadata tags.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="options"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="tags"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The <see cref="ImapClient"/> has been disposed.
/// </exception>
/// <exception cref="ServiceNotConnectedException">
/// The <see cref="ImapClient"/> is not connected.
/// </exception>
/// <exception cref="ServiceNotAuthenticatedException">
/// The <see cref="ImapClient"/> is not authenticated.
/// </exception>
/// <exception cref="System.NotSupportedException">
/// The IMAP server does not support the METADATA extension.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation was canceled via the cancellation token.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
/// <exception cref="ImapProtocolException">
/// The server's response contained unexpected tokens.
/// </exception>
/// <exception cref="ImapCommandException">
/// The server replied with a NO or BAD response.
/// </exception>
public override MetadataCollection GetMetadata (MetadataOptions options, IEnumerable<MetadataTag> tags, CancellationToken cancellationToken = default (CancellationToken))
{
if (options == null)
throw new ArgumentNullException (nameof (options));
if (tags == null)
throw new ArgumentNullException (nameof (tags));
CheckState (false, false);
if ((Engine.Capabilities & ImapCapabilities.Metadata) == 0)
throw new NotSupportedException ("The IMAP server does not support the METADATA extension.");
var command = new StringBuilder ("GETMETADATA %F");
var args = new List<object> ();
bool hasOptions = false;
if (options.MaxSize.HasValue || options.Depth != 0) {
command.Append (" (");
if (options.MaxSize.HasValue)
command.AppendFormat ("MAXSIZE {0} ", options.MaxSize.Value);
if (options.Depth > 0)
command.AppendFormat ("DEPTH {0} ", options.Depth == int.MaxValue ? "infinity" : "1");
command[command.Length - 1] = ')';
command.Append (' ');
hasOptions = true;
}
args.Add (this);
int startIndex = command.Length;
foreach (var tag in tags) {
command.Append (" %S");
args.Add (tag.Id);
}
if (hasOptions) {
command[startIndex] = '(';
command.Append (')');
}
command.Append ("\r\n");
if (args.Count == 1)
return new MetadataCollection ();
var ic = new ImapCommand (Engine, cancellationToken, null, command.ToString (), args.ToArray ());
ic.RegisterUntaggedHandler ("METADATA", ImapUtils.ParseMetadata);
ic.UserData = new MetadataCollection ();
options.LongEntries = 0;
Engine.QueueCommand (ic);
Engine.Wait (ic);
ProcessResponseCodes (ic, null);
if (ic.Response != ImapCommandResponse.Ok)
throw ImapCommandException.Create ("GETMETADATA", ic);
if (ic.RespCodes.Count > 0 && ic.RespCodes[ic.RespCodes.Count - 1].Type == ImapResponseCodeType.Metadata) {
var metadata = (MetadataResponseCode) ic.RespCodes[ic.RespCodes.Count - 1];
if (metadata.SubType == MetadataResponseCodeSubType.LongEntries)
options.LongEntries = metadata.Value;
}
return (MetadataCollection) ic.UserData;
}
