public ExportCatalog(DefaultMetadataProvider defaultMetadataProvider)
{
MetadataProviders.Add(defaultMetadataProvider);
DefaultMetadataProvider = defaultMetadataProvider;
Types.TryAdd(defaultMetadataProvider.GetType(), new List <ITypeInfo>());
}
private async Task <string> GetSeriesByRemoteId(string id, MetadataProviders idType, CancellationToken cancellationToken)
{
var idTypeString = idType.ToString().ToLower();
if (idTypeString == "tvdb")
{
idTypeString = "thetvdb";
}
var url = string.Format(UrlByRemoteId, idTypeString, id);
using (var response = await _httpClient.GetResponse(new HttpRequestOptions
{
Url = url,
ResourcePool = TvMazeResourcePool,
CancellationToken = cancellationToken
}).ConfigureAwait(false))
{
if (response.StatusCode == HttpStatusCode.OK)
{
var arr = response.ResponseUrl.Split('/');
return(arr[arr.Length - 1]);
}
}
return(null);
}
private IEnumerable <ITypeInfo> GetTypes <TProvider>() where TProvider : class, IMetadataProvider
{
var metadataProviderType = typeof(TProvider);
if (!Types.ContainsKey(metadataProviderType))
{
throw new NotImplementedException($"Provider {metadataProviderType.Name} not registered.");
}
var providerTypes = Types[metadataProviderType];
if (providerTypes.Count == 0)
{
var metadataProvider = MetadataProviders.FirstOrDefault(o => o.GetType() == metadataProviderType);
var exportedTypes = Assemblies.SelectMany(o => o.GetExportedTypes().Where(t => t.HasAttribute <ExportAttribute>()));
var projectedTypes = exportedTypes.Select(o => metadataProvider.Create(o));
foreach (var t in projectedTypes)
{
providerTypes.Add(t);
}
}
return(providerTypes);
}
public void RegisterMetadataProvider(IMetadataProvider provider)
{
if (!Types.ContainsKey(provider.GetType()))
{
MetadataProviders.Add(provider);
Types.TryAdd(provider.GetType(), new List <ITypeInfo>());
}
}
/// <summary>
/// Sets a provider id.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <param name="value">The value.</param>
public static void SetProviderId(this IHasProviderIds instance, MetadataProviders provider, string value)
{
instance.SetProviderId(provider.ToString(), value);
}
/// <summary>
/// Gets a provider id.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <returns>System.String.</returns>
public static string?GetProviderId(this IHasProviderIds instance, MetadataProviders provider)
{
return(instance.GetProviderId(provider.ToString()));
}
/// <summary>
/// Determines whether [has provider identifier] [the specified instance].
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <returns><c>true</c> if [has provider identifier] [the specified instance]; otherwise, <c>false</c>.</returns>
public static bool HasProviderId(this IHasProviderIds instance, MetadataProviders provider)
{
return(!string.IsNullOrEmpty(instance.GetProviderId(provider.ToString())));
}
public XamlApp()
{
MetadataProviders.Add(new ControlPlaygroundUwpLib.ControlPlaygroundUwpLib_XamlTypeInfo.XamlMetaDataProvider());
}
/// <summary>
/// Sets a provider id
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <param name="value">The value.</param>
public static void SetProviderId(this IHasProviderIds instance, MetadataProviders provider, string value)
{
instance.SetProviderId(provider.ToString(), value);
}
/// <summary>
/// Gets a provider id
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <returns>System.String.</returns>
public static string GetProviderId(this IHasProviderIds instance, MetadataProviders provider)
{
return instance.GetProviderId(provider.ToString());
}
/// <summary>
/// Determines whether [has provider identifier] [the specified instance].
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="provider">The provider.</param>
/// <returns><c>true</c> if [has provider identifier] [the specified instance]; otherwise, <c>false</c>.</returns>
public static bool HasProviderId(this IHasProviderIds instance, MetadataProviders provider)
{
return !string.IsNullOrEmpty(instance.GetProviderId(provider.ToString()));
}
/// <summary>
/// Runs all metadata providers for an entity, and returns true or false indicating if at least one was refreshed and requires persistence
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="force">if set to <c>true</c> [force].</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{System.Boolean}.</returns>
public async Task <bool> ExecuteMetadataProviders(BaseItem item, CancellationToken cancellationToken, bool force = false, bool allowSlowProviders = true)
{
// Allow providers of the same priority to execute in parallel
MetadataProviderPriority?currentPriority = null;
var currentTasks = new List <Task <bool> >();
var result = false;
cancellationToken.ThrowIfCancellationRequested();
// Determine if supported providers have changed
var supportedProviders = MetadataProviders.Where(p => p.Supports(item)).ToList();
BaseProviderInfo supportedProvidersInfo;
if (SupportedProvidersKey == Guid.Empty)
{
SupportedProvidersKey = "SupportedProviders".GetMD5();
}
var supportedProvidersHash = string.Join("+", supportedProviders.Select(i => i.GetType().Name)).GetMD5();
bool providersChanged;
item.ProviderData.TryGetValue(SupportedProvidersKey, out supportedProvidersInfo);
if (supportedProvidersInfo == null)
{
// First time
supportedProvidersInfo = new BaseProviderInfo {
ProviderId = SupportedProvidersKey, FileSystemStamp = supportedProvidersHash
};
providersChanged = force = true;
}
else
{
// Force refresh if the supported providers have changed
providersChanged = force = force || supportedProvidersInfo.FileSystemStamp != supportedProvidersHash;
}
// If providers have changed, clear provider info and update the supported providers hash
if (providersChanged)
{
_logger.Debug("Providers changed for {0}. Clearing and forcing refresh.", item.Name);
item.ProviderData.Clear();
supportedProvidersInfo.FileSystemStamp = supportedProvidersHash;
}
if (force)
{
item.ClearMetaValues();
}
// Run the normal providers sequentially in order of priority
foreach (var provider in supportedProviders)
{
cancellationToken.ThrowIfCancellationRequested();
// Skip if internet providers are currently disabled
if (provider.RequiresInternet && !ConfigurationManager.Configuration.EnableInternetProviders)
{
continue;
}
// Skip if is slow and we aren't allowing slow ones
if (provider.IsSlow && !allowSlowProviders)
{
continue;
}
// Skip if internet provider and this type is not allowed
if (provider.RequiresInternet && ConfigurationManager.Configuration.EnableInternetProviders && ConfigurationManager.Configuration.InternetProviderExcludeTypes.Contains(item.GetType().Name, StringComparer.OrdinalIgnoreCase))
{
continue;
}
// When a new priority is reached, await the ones that are currently running and clear the list
if (currentPriority.HasValue && currentPriority.Value != provider.Priority && currentTasks.Count > 0)
{
var results = await Task.WhenAll(currentTasks).ConfigureAwait(false);
result |= results.Contains(true);
currentTasks.Clear();
}
// Put this check below the await because the needs refresh of the next tier of providers may depend on the previous ones running
// This is the case for the fan art provider which depends on the movie and tv providers having run before them
if (!force && !provider.NeedsRefresh(item))
{
continue;
}
currentTasks.Add(FetchAsync(provider, item, force, cancellationToken));
currentPriority = provider.Priority;
}
if (currentTasks.Count > 0)
{
var results = await Task.WhenAll(currentTasks).ConfigureAwait(false);
result |= results.Contains(true);
}
if (providersChanged)
{
item.ProviderData[SupportedProvidersKey] = supportedProvidersInfo;
}
return(result || providersChanged);
}
/// <summary>
/// Initializes this <see cref="LocalOutputAdapter"/>.
/// </summary>
/// <exception cref="ArgumentException"><b>InstanceName</b> is missing from the <see cref="AdapterBase.Settings"/>.</exception>
public override void Initialize()
{
base.Initialize();
Dictionary<string, string> settings = Settings;
string setting;
ulong badDataMessageInterval;
// Validate settings.
if (!settings.TryGetValue("instanceName", out m_instanceName) || string.IsNullOrWhiteSpace(m_instanceName))
m_instanceName = Name.ToLower();
// Track instance in static dictionary
Instances[InstanceName] = this;
if (!settings.TryGetValue("archivePath", out m_archivePath))
m_archivePath = FilePath.GetAbsolutePath(FilePath.AddPathSuffix("Archive"));
if (settings.TryGetValue("refreshMetadata", out setting) || settings.TryGetValue("autoRefreshMetadata", out setting))
m_autoRefreshMetadata = setting.ParseBoolean();
if (settings.TryGetValue("badDataMessageInterval", out setting) && ulong.TryParse(setting, out badDataMessageInterval))
m_badDataMessageInterval = badDataMessageInterval;
//if (settings.TryGetValue("useNamespaceReservation", out setting))
// m_useNamespaceReservation = setting.ParseBoolean();
//else
// m_useNamespaceReservation = false;
// Initialize metadata file.
m_instanceName = m_instanceName.ToLower();
m_archive.MetadataFile.FileName = Path.Combine(m_archivePath, m_instanceName + "_dbase.dat");
m_archive.MetadataFile.PersistSettings = true;
m_archive.MetadataFile.SettingsCategory = m_instanceName + m_archive.MetadataFile.SettingsCategory;
m_archive.MetadataFile.FileAccessMode = FileAccess.ReadWrite;
m_archive.MetadataFile.Initialize();
// Initialize state file.
m_archive.StateFile.FileName = Path.Combine(m_archivePath, m_instanceName + "_startup.dat");
m_archive.StateFile.PersistSettings = true;
m_archive.StateFile.SettingsCategory = m_instanceName + m_archive.StateFile.SettingsCategory;
m_archive.StateFile.FileAccessMode = FileAccess.ReadWrite;
m_archive.StateFile.Initialize();
// Initialize intercom file.
m_archive.IntercomFile.FileName = Path.Combine(m_archivePath, "scratch.dat");
m_archive.IntercomFile.PersistSettings = true;
m_archive.IntercomFile.SettingsCategory = m_instanceName + m_archive.IntercomFile.SettingsCategory;
m_archive.IntercomFile.FileAccessMode = FileAccess.ReadWrite;
m_archive.IntercomFile.Initialize();
// Initialize data archive file.
m_archive.FileName = Path.Combine(m_archivePath, m_instanceName + "_archive.d");
m_archive.FileSize = 100;
m_archive.CompressData = false;
m_archive.PersistSettings = true;
m_archive.SettingsCategory = m_instanceName + m_archive.SettingsCategory;
m_archive.RolloverStart += m_archive_RolloverStart;
m_archive.RolloverComplete += m_archive_RolloverComplete;
m_archive.RolloverException += m_archive_RolloverException;
m_archive.DataReadException += m_archive_DataReadException;
m_archive.DataWriteException += m_archive_DataWriteException;
m_archive.OffloadStart += m_archive_OffloadStart;
m_archive.OffloadComplete += m_archive_OffloadComplete;
m_archive.OffloadException += m_archive_OffloadException;
m_archive.OrphanDataReceived += m_archive_OrphanDataReceived;
m_archive.FutureDataReceived += m_archive_FutureDataReceived;
m_archive.OutOfSequenceDataReceived += m_archive_OutOfSequenceDataReceived;
m_archive.Initialize();
// Provide web service support.
m_dataServices = new DataServices();
m_dataServices.AdapterCreated += DataServices_AdapterCreated;
m_dataServices.AdapterLoaded += DataServices_AdapterLoaded;
m_dataServices.AdapterUnloaded += DataServices_AdapterUnloaded;
m_dataServices.AdapterLoadException += AdapterLoader_AdapterLoadException;
// Provide metadata sync support.
m_metadataProviders = new MetadataProviders();
m_metadataProviders.AdapterCreated += MetadataProviders_AdapterCreated;
m_metadataProviders.AdapterLoaded += MetadataProviders_AdapterLoaded;
m_metadataProviders.AdapterUnloaded += MetadataProviders_AdapterUnloaded;
m_metadataProviders.AdapterLoadException += AdapterLoader_AdapterLoadException;
// Provide archive replication support.
m_replicationProviders = new ReplicationProviders();
m_replicationProviders.AdapterCreated += ReplicationProviders_AdapterCreated;
m_replicationProviders.AdapterLoaded += ReplicationProviders_AdapterLoaded;
m_replicationProviders.AdapterUnloaded += ReplicationProviders_AdapterUnloaded;
m_replicationProviders.AdapterLoadException += AdapterLoader_AdapterLoadException;
}
