private MetadataStatus GetStatus(IDataReader reader)
{
var result = new MetadataStatus
{
ItemId = reader.GetGuid(0)
};
if (!reader.IsDBNull(1))
{
result.ItemName = reader.GetString(1);
}
if (!reader.IsDBNull(2))
{
result.ItemName = reader.GetString(2);
}
if (!reader.IsDBNull(3))
{
result.SeriesName = reader.GetString(3);
}
if (!reader.IsDBNull(4))
{
result.DateLastMetadataRefresh = reader.GetDateTime(4).ToUniversalTime();
}
if (!reader.IsDBNull(5))
{
result.DateLastImagesRefresh = reader.GetDateTime(5).ToUniversalTime();
}
if (!reader.IsDBNull(6))
{
result.LastErrorMessage = reader.GetString(6);
}
if (!reader.IsDBNull(7))
{
result.ItemDateModified = reader.GetDateTime(7).ToUniversalTime();
}
return(result);
}
public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService)
{
if (!TvdbSeriesProvider.Current.GetTvDbOptions().EnableAutomaticUpdates)
{
return(false);
}
if (TvdbSeriesProvider.IsValidSeries(item.ProviderIds))
{
// Process images
var imagesXmlPath = Path.Combine(TvdbSeriesProvider.GetSeriesDataPath(_config.ApplicationPaths, item.ProviderIds), "banners.xml");
var fileInfo = _fileSystem.GetFileInfo(imagesXmlPath);
return(fileInfo.Exists && _fileSystem.GetLastWriteTimeUtc(fileInfo) > (status.DateLastMetadataRefresh ?? DateTime.MinValue));
}
return(false);
}
public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService)
{
if (!_config.Configuration.EnableTvDbUpdates)
{
return(false);
}
var tvdbId = item.GetProviderId(MetadataProviders.Tvdb);
if (!String.IsNullOrEmpty(tvdbId))
{
// Process images
var imagesXmlPath = Path.Combine(TvdbSeriesProvider.GetSeriesDataPath(_config.ApplicationPaths, tvdbId), "banners.xml");
var fileInfo = new FileInfo(imagesXmlPath);
return(fileInfo.Exists && _fileSystem.GetLastWriteTimeUtc(fileInfo) > (status.DateLastMetadataRefresh ?? DateTime.MinValue));
}
return(false);
}
/// <summary>
/// Saves the provider result.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="result">The result.</param>
/// <param name="directoryService">The directory service.</param>
/// <returns>Task.</returns>
protected Task SaveProviderResult(TItemType item, MetadataStatus result, IDirectoryService directoryService)
{
result.ItemId = item.Id;
//var locationType = item.LocationType;
//if (locationType == LocationType.FileSystem || locationType == LocationType.Offline)
//{
// if (!string.IsNullOrWhiteSpace(item.Path))
// {
// var file = directoryService.GetFile(item.Path);
// if ((file.Attributes & FileAttributes.Directory) != FileAttributes.Directory && file.Exists)
// {
// result.ItemDateModified = FileSystem.GetLastWriteTimeUtc(file);
// }
// }
//}
result.ItemDateModified = item.DateModified;
return(ProviderRepo.SaveMetadataStatus(result, CancellationToken.None));
}
private MetadataStatus GetStatus(IDataReader reader)
{
var result = new MetadataStatus
{
ItemId = reader.GetGuid(0)
};
if (!reader.IsDBNull(1))
{
result.DateLastMetadataRefresh = reader.GetDateTime(1).ToUniversalTime();
}
if (!reader.IsDBNull(2))
{
result.DateLastImagesRefresh = reader.GetDateTime(2).ToUniversalTime();
}
if (!reader.IsDBNull(3))
{
result.ItemDateModified = reader.GetDateTime(3).ToUniversalTime();
}
return(result);
}
public override void setMetadataStatus(MetadataKey metadataKey, MetadataStatus metadataStatus)
{
Log.v(TAG, "setMetadataStatus: " + metadataKey + ", " + metadataStatus);
}
private bool HasChanged(IHasMetadata item, IHasItemChangeMonitor changeMonitor, MetadataStatus status, IDirectoryService directoryService)
{
try
{
return(changeMonitor.HasChanged(item, status, directoryService));
}
catch (Exception ex)
{
Logger.ErrorException("Error in {0}.HasChanged", ex, changeMonitor.GetType().Name);
return(false);
}
}
protected virtual IEnumerable <IImageProvider> GetNonLocalImageProviders(IHasMetadata item, IEnumerable <IImageProvider> allImageProviders, MetadataStatus status, ImageRefreshOptions options)
{
// Get providers to refresh
var providers = allImageProviders.Where(i => !(i is ILocalImageProvider)).ToList();
// Run all if either of these flags are true
var runAllProviders = options.ImageRefreshMode == ImageRefreshMode.FullRefresh || !status.DateLastImagesRefresh.HasValue;
if (!runAllProviders)
{
providers = providers
.Where(i =>
{
var hasChangeMonitor = i as IHasChangeMonitor;
if (hasChangeMonitor != null)
{
return(HasChanged(item, hasChangeMonitor, status.DateLastImagesRefresh.Value, options.DirectoryService));
}
var hasFileChangeMonitor = i as IHasItemChangeMonitor;
if (hasFileChangeMonitor != null)
{
return(HasChanged(item, hasFileChangeMonitor, status, options.DirectoryService));
}
return(false);
})
.ToList();
}
return(providers);
}
/// <summary>
/// Gets the providers.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="status">The status.</param>
/// <param name="options">The options.</param>
/// <returns>IEnumerable{`0}.</returns>
protected IEnumerable <IMetadataProvider> GetProviders(IHasMetadata item, MetadataStatus status, MetadataRefreshOptions options)
{
// Get providers to refresh
var providers = ((ProviderManager)ProviderManager).GetMetadataProviders <TItemType>(item).ToList();
// Run all if either of these flags are true
var runAllProviders = options.ReplaceAllMetadata || options.MetadataRefreshMode == MetadataRefreshMode.FullRefresh || !status.DateLastMetadataRefresh.HasValue;
if (!runAllProviders)
{
// Avoid implicitly captured closure
var currentItem = item;
var providersWithChanges = providers
.Where(i =>
{
var hasChangeMonitor = i as IHasChangeMonitor;
if (hasChangeMonitor != null)
{
return(HasChanged(item, hasChangeMonitor, currentItem.DateLastSaved, options.DirectoryService));
}
var hasFileChangeMonitor = i as IHasItemChangeMonitor;
if (hasFileChangeMonitor != null)
{
return(HasChanged(item, hasFileChangeMonitor, status, options.DirectoryService));
}
return(false);
})
.ToList();
if (providersWithChanges.Count == 0)
{
providers = new List <IMetadataProvider <TItemType> >();
}
else
{
providers = providers.Where(i =>
{
// If any provider reports a change, always run local ones as well
if (i is ILocalMetadataProvider)
{
return(true);
}
var anyRemoteProvidersChanged = providersWithChanges.OfType <IRemoteMetadataProvider>()
.Any();
// If any remote providers changed, run them all so that priorities can be honored
if (i is IRemoteMetadataProvider)
{
return(anyRemoteProvidersChanged);
}
// Run custom providers if they report a change or any remote providers change
return(anyRemoteProvidersChanged || providersWithChanges.Contains(i));
}).ToList();
}
}
return(providers);
}
public MetadataBaseFilter(XmlElement node) : base(node)
{
foreach (XmlElement propertyNode in node.ChildNodes)
{
switch (propertyNode.Name)
{
case "partnerIdEqual":
this._PartnerIdEqual = ParseInt(propertyNode.InnerText);
continue;
case "metadataProfileIdEqual":
this._MetadataProfileIdEqual = ParseInt(propertyNode.InnerText);
continue;
case "metadataProfileIdIn":
this._MetadataProfileIdIn = propertyNode.InnerText;
continue;
case "metadataProfileVersionEqual":
this._MetadataProfileVersionEqual = ParseInt(propertyNode.InnerText);
continue;
case "metadataProfileVersionGreaterThanOrEqual":
this._MetadataProfileVersionGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "metadataProfileVersionLessThanOrEqual":
this._MetadataProfileVersionLessThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "metadataObjectTypeEqual":
this._MetadataObjectTypeEqual = (MetadataObjectType)StringEnum.Parse(typeof(MetadataObjectType), propertyNode.InnerText);
continue;
case "objectIdEqual":
this._ObjectIdEqual = propertyNode.InnerText;
continue;
case "objectIdIn":
this._ObjectIdIn = propertyNode.InnerText;
continue;
case "versionEqual":
this._VersionEqual = ParseInt(propertyNode.InnerText);
continue;
case "versionGreaterThanOrEqual":
this._VersionGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "versionLessThanOrEqual":
this._VersionLessThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "createdAtGreaterThanOrEqual":
this._CreatedAtGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "createdAtLessThanOrEqual":
this._CreatedAtLessThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "updatedAtGreaterThanOrEqual":
this._UpdatedAtGreaterThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "updatedAtLessThanOrEqual":
this._UpdatedAtLessThanOrEqual = ParseInt(propertyNode.InnerText);
continue;
case "statusEqual":
this._StatusEqual = (MetadataStatus)ParseEnum(typeof(MetadataStatus), propertyNode.InnerText);
continue;
case "statusIn":
this._StatusIn = propertyNode.InnerText;
continue;
}
}
}
public async Task SaveMetadataStatus(MetadataStatus status, CancellationToken cancellationToken)
{
if (status == null)
{
throw new ArgumentNullException("status");
}
cancellationToken.ThrowIfCancellationRequested();
await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(false);
IDbTransaction transaction = null;
try
{
transaction = _connection.BeginTransaction();
_saveStatusCommand.GetParameter(0).Value = status.ItemId;
_saveStatusCommand.GetParameter(1).Value = status.ItemName;
_saveStatusCommand.GetParameter(2).Value = status.ItemType;
_saveStatusCommand.GetParameter(3).Value = status.SeriesName;
_saveStatusCommand.GetParameter(4).Value = status.DateLastMetadataRefresh;
_saveStatusCommand.GetParameter(5).Value = status.DateLastImagesRefresh;
_saveStatusCommand.GetParameter(6).Value = status.LastStatus.ToString();
_saveStatusCommand.GetParameter(7).Value = status.LastErrorMessage;
_saveStatusCommand.GetParameter(8).Value = string.Join("|", status.MetadataProvidersRefreshed.ToArray());
_saveStatusCommand.GetParameter(9).Value = string.Join("|", status.ImageProvidersRefreshed.ToArray());
_saveStatusCommand.GetParameter(10).Value = status.ItemDateModified;
_saveStatusCommand.Transaction = transaction;
_saveStatusCommand.ExecuteNonQuery();
transaction.Commit();
}
catch (OperationCanceledException)
{
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
catch (Exception e)
{
_logger.ErrorException("Failed to save provider info:", e);
if (transaction != null)
{
transaction.Rollback();
}
throw;
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
_writeLock.Release();
}
}
public override void setMetadataStatus(MetadataKey metadataKey, MetadataStatus metadataStatus)
{
Log.v(TAG, "setMetadataStatus: " + metadataKey + ", " + metadataStatus);
}
public bool HasChanged(IHasMetadata item, MetadataStatus status, IDirectoryService directoryService)
{
return(GetSupportedImages(item).Any(i => !item.HasImage(i)));
}
private bool HasChanged(IHasMetadata item, IHasItemChangeMonitor changeMonitor, MetadataStatus status, IDirectoryService directoryService)
{
try
{
var hasChanged = changeMonitor.HasChanged(item, status, directoryService);
//if (hasChanged)
//{
// Logger.Debug("{0} reports change to {1}", changeMonitor.GetType().Name, item.Path ?? item.Name);
//}
return(hasChanged);
}
catch (Exception ex)
{
Logger.ErrorException("Error in {0}.HasChanged", ex, changeMonitor.GetType().Name);
return(false);
}
}
public MetadataBaseFilter(JToken node) : base(node)
{
if (node["partnerIdEqual"] != null)
{
this._PartnerIdEqual = ParseInt(node["partnerIdEqual"].Value <string>());
}
if (node["metadataProfileIdEqual"] != null)
{
this._MetadataProfileIdEqual = ParseInt(node["metadataProfileIdEqual"].Value <string>());
}
if (node["metadataProfileIdIn"] != null)
{
this._MetadataProfileIdIn = node["metadataProfileIdIn"].Value <string>();
}
if (node["metadataProfileVersionEqual"] != null)
{
this._MetadataProfileVersionEqual = ParseInt(node["metadataProfileVersionEqual"].Value <string>());
}
if (node["metadataProfileVersionGreaterThanOrEqual"] != null)
{
this._MetadataProfileVersionGreaterThanOrEqual = ParseInt(node["metadataProfileVersionGreaterThanOrEqual"].Value <string>());
}
if (node["metadataProfileVersionLessThanOrEqual"] != null)
{
this._MetadataProfileVersionLessThanOrEqual = ParseInt(node["metadataProfileVersionLessThanOrEqual"].Value <string>());
}
if (node["metadataObjectTypeEqual"] != null)
{
this._MetadataObjectTypeEqual = (MetadataObjectType)StringEnum.Parse(typeof(MetadataObjectType), node["metadataObjectTypeEqual"].Value <string>());
}
if (node["objectIdEqual"] != null)
{
this._ObjectIdEqual = node["objectIdEqual"].Value <string>();
}
if (node["objectIdIn"] != null)
{
this._ObjectIdIn = node["objectIdIn"].Value <string>();
}
if (node["versionEqual"] != null)
{
this._VersionEqual = ParseInt(node["versionEqual"].Value <string>());
}
if (node["versionGreaterThanOrEqual"] != null)
{
this._VersionGreaterThanOrEqual = ParseInt(node["versionGreaterThanOrEqual"].Value <string>());
}
if (node["versionLessThanOrEqual"] != null)
{
this._VersionLessThanOrEqual = ParseInt(node["versionLessThanOrEqual"].Value <string>());
}
if (node["createdAtGreaterThanOrEqual"] != null)
{
this._CreatedAtGreaterThanOrEqual = ParseInt(node["createdAtGreaterThanOrEqual"].Value <string>());
}
if (node["createdAtLessThanOrEqual"] != null)
{
this._CreatedAtLessThanOrEqual = ParseInt(node["createdAtLessThanOrEqual"].Value <string>());
}
if (node["updatedAtGreaterThanOrEqual"] != null)
{
this._UpdatedAtGreaterThanOrEqual = ParseInt(node["updatedAtGreaterThanOrEqual"].Value <string>());
}
if (node["updatedAtLessThanOrEqual"] != null)
{
this._UpdatedAtLessThanOrEqual = ParseInt(node["updatedAtLessThanOrEqual"].Value <string>());
}
if (node["statusEqual"] != null)
{
this._StatusEqual = (MetadataStatus)ParseEnum(typeof(MetadataStatus), node["statusEqual"].Value <string>());
}
if (node["statusIn"] != null)
{
this._StatusIn = node["statusIn"].Value <string>();
}
}
