michael.heier/jellyfin
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

added movie, series, folder and episode xml saving support

Browse Source
This commit is contained in:
Luke Pulverenti 2013-06-23 13:48:30 -04:00
parent cc2cfabda8
commit d6cf7b51ac
19 changed files with 740 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
MediaBrowser.Controller/Entities/BaseItem.cs
View File

@ -464,6 +464,12 @@ namespace MediaBrowser.Controller.Entities
/// <value>The official rating.</value>
public virtual string OfficialRating { get; set; }
/// <summary>
/// Gets or sets the official rating description.
/// </summary>
/// <value>The official rating description.</value>
public string OfficialRatingDescription { get; set; }
/// <summary>
/// Gets or sets the custom rating.
/// </summary>

5
MediaBrowser.Controller/Library/ILibraryManager.cs
View File

@ -152,16 +152,13 @@ namespace MediaBrowser.Controller.Library
/// <param name="itemComparers">The item comparers.</param>
/// <param name="prescanTasks">The prescan tasks.</param>
/// <param name="postscanTasks">The postscan tasks.</param>
/// <param name="savers">The savers.</param>
/// <param name="?">The ?.</param>
void AddParts(IEnumerable<IResolverIgnoreRule> rules,
IEnumerable<IVirtualFolderCreator> pluginFolders,
IEnumerable<IItemResolver> resolvers,
IEnumerable<IIntroProvider> introProviders,
IEnumerable<IBaseItemComparer> itemComparers,
IEnumerable<ILibraryPrescanTask> prescanTasks,
IEnumerable<ILibraryPostScanTask> postscanTasks,
IEnumerable<IMetadataSaver> savers);
IEnumerable<ILibraryPostScanTask> postscanTasks);
/// <summary>
/// Sorts the specified items.

3
MediaBrowser.Controller/Library/IMetadataSaver.cs
View File

@ -1,6 +1,5 @@
using MediaBrowser.Controller.Entities;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Controller.Library
{
@ -29,6 +28,6 @@ namespace MediaBrowser.Controller.Library
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
Task Save(BaseItem item, CancellationToken cancellationToken);
void Save(BaseItem item, CancellationToken cancellationToken);
}
}

27
MediaBrowser.Controller/Providers/BaseItemXmlParser.cs
View File

@ -205,6 +205,17 @@ namespace MediaBrowser.Controller.Providers
break;
}
case "MPAADescription":
{
var rating = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(rating))
{
item.OfficialRatingDescription = rating;
}
break;
}
case "CustomRating":
{
var val = reader.ReadElementContentAsString();
@ -412,6 +423,14 @@ namespace MediaBrowser.Controller.Providers
}
break;
case "CollectionNumber":
var tmdbCollection = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(tmdbCollection))
{
item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
}
break;
case "TVcomId":
var TVcomId = reader.ReadElementContentAsString();
if (!string.IsNullOrWhiteSpace(TVcomId))
@ -679,7 +698,7 @@ namespace MediaBrowser.Controller.Providers
// Only split by comma if there is no pipe in the string
// We have to be careful to not split names like Matthew, Jr.
var separator = value.IndexOf('|') == -1 ? ',' : '|';
var separator = value.IndexOf('|') == -1 && value.IndexOf(';') == -1 ? new[] { ',' } : new[] { '|', ';' };
value = value.Trim().Trim(separator);
@ -690,12 +709,12 @@ namespace MediaBrowser.Controller.Providers
/// Provides an additional overload for string.split
/// </summary>
/// <param name="val">The val.</param>
/// <param name="separator">The separator.</param>
/// <param name="separators">The separators.</param>
/// <param name="options">The options.</param>
/// <returns>System.String[][].</returns>
private static string[] Split(string val, char separator, StringSplitOptions options)
private static string[] Split(string val, char[] separators, StringSplitOptions options)
{
return val.Split(new[] { separator }, options);
return val.Split(separators, options);
}
}

17
MediaBrowser.Controller/Providers/IProviderManager.cs
View File

@ -1,4 +1,5 @@
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using System.Collections.Generic;
using System.IO;
using System.Threading;
@ -6,6 +7,9 @@ using System.Threading.Tasks;
namespace MediaBrowser.Controller.Providers
{
/// <summary>
/// Interface IProviderManager
/// </summary>
public interface IProviderManager
{
/// <summary>
@ -21,6 +25,15 @@ namespace MediaBrowser.Controller.Providers
/// <exception cref="System.ArgumentNullException">item</exception>
Task<string> DownloadAndSaveImage(BaseItem item, string source, string targetName, bool saveLocally, SemaphoreSlim resourcePool, CancellationToken cancellationToken);
/// <summary>
/// Saves the image.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="source">The source.</param>
/// <param name="targetName">Name of the target.</param>
/// <param name="saveLocally">if set to <c>true</c> [save locally].</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{System.String}.</returns>
Task<string> SaveImage(BaseItem item, Stream source, string targetName, bool saveLocally, CancellationToken cancellationToken);
/// <summary>
@ -48,7 +61,9 @@ namespace MediaBrowser.Controller.Providers
/// Adds the metadata providers.
/// </summary>
/// <param name="providers">The providers.</param>
void AddMetadataProviders(IEnumerable<BaseMetadataProvider> providers);
/// <param name="savers">The savers.</param>
void AddParts(IEnumerable<BaseMetadataProvider> providers,
IEnumerable<IMetadataSaver> savers);
/// <summary>
/// Gets the save path.

5
MediaBrowser.Providers/MediaBrowser.Providers.csproj
View File

@ -60,7 +60,6 @@
<Compile Include="Movies\FanArtMovieUpdatesPrescanTask.cs" />
<Compile Include="Movies\MovieDbImagesProvider.cs" />
<Compile Include="Movies\MovieDbProvider.cs" />
<Compile Include="Movies\MovieProviderFromJson.cs" />
<Compile Include="Movies\MovieProviderFromXml.cs" />
<Compile Include="Movies\OpenMovieDatabaseProvider.cs" />
<Compile Include="Movies\PersonProviderFromJson.cs" />
@ -77,7 +76,11 @@
<Compile Include="Music\LastfmHelper.cs" />
<Compile Include="Music\MusicArtistProviderFromJson.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Savers\EpisodeXmlSaver.cs" />
<Compile Include="Savers\FolderXmlSaver.cs" />
<Compile Include="Savers\MovieXmlSaver.cs" />
<Compile Include="Savers\SeriesXmlSaver.cs" />
<Compile Include="Savers\XmlHelpers.cs" />
<Compile Include="TV\EpisodeImageFromMediaLocationProvider.cs" />
<Compile Include="TV\EpisodeIndexNumberProvider.cs" />
<Compile Include="TV\EpisodeProviderFromXml.cs" />

55
MediaBrowser.Providers/Movies/MovieDbProvider.cs
View File

@ -180,40 +180,6 @@ namespace MediaBrowser.Providers.Movies
}
}
/// <summary>
/// The json provider
/// </summary>
protected MovieProviderFromJson JsonProvider;
/// <summary>
/// Sets the persisted last refresh date on the item for this provider.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="value">The value.</param>
/// <param name="providerVersion">The provider version.</param>
/// <param name="status">The status.</param>
public override void SetLastRefreshed(BaseItem item, DateTime value, string providerVersion, ProviderRefreshStatus status = ProviderRefreshStatus.Success)
{
base.SetLastRefreshed(item, value, providerVersion, status);
if (ConfigurationManager.Configuration.SaveLocalMeta && item.LocationType == LocationType.FileSystem)
{
//in addition to ours, we need to set the last refreshed time for the local data provider
//so it won't see the new files we download and process them all over again
if (JsonProvider == null) JsonProvider = new MovieProviderFromJson(LogManager, ConfigurationManager, JsonSerializer, HttpClient, ProviderManager);
BaseProviderInfo data;
if (!item.ProviderData.TryGetValue(JsonProvider.Id, out data))
{
data = new BaseProviderInfo();
}
data.LastRefreshed = value;
item.ProviderData[JsonProvider.Id] = data;
}
}
private const string TmdbConfigUrl = "http://api.themoviedb.org/3/configuration?api_key={0}";
private const string Search3 = @"http://api.themoviedb.org/3/search/movie?api_key={1}&query={0}&language={2}";
private const string AltTitleSearch = @"http://api.themoviedb.org/3/movie/{0}/alternative_titles?api_key={1}&country={2}";
@ -228,7 +194,6 @@ namespace MediaBrowser.Providers.Movies
new Regex(@"(?<name>.*)") // last resort matches the whole string as the name
};
public const string LocalMetaFileName = "tmdb3.json";
public const string AltMetaFileName = "movie.xml";
protected override bool NeedsRefreshInternal(BaseItem item, BaseProviderInfo providerInfo)
@ -248,13 +213,6 @@ namespace MediaBrowser.Providers.Movies
/// <returns>Task{System.Boolean}.</returns>
public override async Task<bool> FetchAsync(BaseItem item, bool force, CancellationToken cancellationToken)
{
if (HasAltMeta(item))
{
Logger.Info("MovieDbProvider - Not fetching because 3rd party meta exists for " + item.Name);
SetLastRefreshed(item, DateTime.UtcNow);
return true;
}
cancellationToken.ThrowIfCancellationRequested();
await FetchMovieData(item, cancellationToken).ConfigureAwait(false);
@ -638,19 +596,6 @@ namespace MediaBrowser.Providers.Movies
if (mainResult == null) return;
ProcessMainInfo(item, mainResult);
cancellationToken.ThrowIfCancellationRequested();
//and save locally
if (ConfigurationManager.Configuration.SaveLocalMeta && item.LocationType == LocationType.FileSystem)
{
var ms = new MemoryStream();
JsonSerializer.SerializeToStream(mainResult, ms);
cancellationToken.ThrowIfCancellationRequested();
await ProviderManager.SaveToLibraryFilesystem(item, Path.Combine(item.MetaLocation, LocalMetaFileName), ms, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>

122
MediaBrowser.Providers/Movies/MovieProviderFromJson.cs
View File

@ -1,122 +0,0 @@
using MediaBrowser.Common.Net;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Providers.Movies
{
/// <summary>
/// Class MovieProviderFromJson
/// </summary>
public class MovieProviderFromJson : MovieDbProvider
{
public MovieProviderFromJson(ILogManager logManager, IServerConfigurationManager configurationManager, IJsonSerializer jsonSerializer, IHttpClient httpClient, IProviderManager providerManager)
: base(logManager, configurationManager, jsonSerializer, httpClient, providerManager)
{
}
public override bool Supports(BaseItem item)
{
if (item.LocationType != LocationType.FileSystem)
{
return false;
}
var trailer = item as Trailer;
if (trailer != null)
{
return !trailer.IsLocalTrailer;
}
return item is Movie || item is BoxSet || item is MusicVideo;
}
/// <summary>
/// Gets the priority.
/// </summary>
/// <value>The priority.</value>
public override MetadataProviderPriority Priority
{
get { return MetadataProviderPriority.Second; }
}
/// <summary>
/// Gets a value indicating whether [requires internet].
/// </summary>
/// <value><c>true</c> if [requires internet]; otherwise, <c>false</c>.</value>
public override bool RequiresInternet
{
get { return false; }
}
/// <summary>
/// Override this to return the date that should be compared to the last refresh date
/// to determine if this provider should be re-fetched.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>DateTime.</returns>
protected override DateTime CompareDate(BaseItem item)
{
var entry = item.ResolveArgs.GetMetaFileByPath(Path.Combine(item.MetaLocation, LocalMetaFileName));
return entry != null ? entry.LastWriteTimeUtc : DateTime.MinValue;
}
/// <summary>
/// Needses the refresh internal.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="providerInfo">The provider info.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
protected override bool NeedsRefreshInternal(BaseItem item, BaseProviderInfo providerInfo)
{
if (item.ResolveArgs.ContainsMetaFileByName(AltMetaFileName))
{
return false; // don't read our file if 3rd party data exists
}
if (!item.ResolveArgs.ContainsMetaFileByName(LocalMetaFileName))
{
return false; // nothing to read
}
// Need to re-override to jump over intermediate implementation
return CompareDate(item) > providerInfo.LastRefreshed;
}
/// <summary>
/// Fetches the async.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="force">if set to <c>true</c> [force].</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{System.Boolean}.</returns>
public override Task<bool> FetchAsync(BaseItem item, bool force, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var entry = item.ResolveArgs.GetMetaFileByPath(Path.Combine(item.MetaLocation, LocalMetaFileName));
if (entry != null)
{
// read in our saved meta and pass to processing function
var movieData = JsonSerializer.DeserializeFromFile<CompleteMovieData>(entry.FullName);
cancellationToken.ThrowIfCancellationRequested();
ProcessMainInfo(item, movieData);
SetLastRefreshed(item, DateTime.UtcNow);
return TrueTaskResult;
}
return FalseTaskResult;
}
}
}

3
MediaBrowser.Providers/Movies/MovieProviderFromXml.cs
View File

@ -15,9 +15,12 @@ namespace MediaBrowser.Providers.Movies
/// </summary>
public class MovieProviderFromXml : BaseMetadataProvider
{
internal static MovieProviderFromXml Current { get; private set; }
public MovieProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager)
: base(logManager, configurationManager)
{
Current = this;
}
/// <summary>

93
MediaBrowser.Providers/Savers/EpisodeXmlSaver.cs Normal file
View File

@ -0,0 +1,93 @@
using System;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System.Globalization;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
using MediaBrowser.Providers.TV;
namespace MediaBrowser.Providers.Savers
{
public class EpisodeXmlSaver : IMetadataSaver
{
/// <summary>
/// Supportses the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
public bool Supports(BaseItem item)
{
if (item.LocationType != LocationType.FileSystem)
{
return false;
}
return item is Episode;
}
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
/// <summary>
/// Saves the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var episode = (Episode)item;
var builder = new StringBuilder();
builder.Append("<Item>");
if (!string.IsNullOrEmpty(item.Name))
{
builder.Append("<EpisodeName>" + SecurityElement.Escape(episode.Name) + "</EpisodeName>");
}
if (episode.IndexNumber.HasValue)
{
builder.Append("<EpisodeNumber>" + SecurityElement.Escape(episode.IndexNumber.Value.ToString(_usCulture)) + "</EpisodeNumber>");
}
if (episode.ParentIndexNumber.HasValue)
{
builder.Append("<SeasonNumber>" + SecurityElement.Escape(episode.ParentIndexNumber.Value.ToString(_usCulture)) + "</SeasonNumber>");
}
if (episode.PremiereDate.HasValue)
{
builder.Append("<FirstAired>" + SecurityElement.Escape(episode.PremiereDate.Value.ToString("yyyy-MM-dd")) + "</FirstAired>");
}
XmlHelpers.AddCommonNodes(item, builder);
XmlHelpers.AppendMediaInfo(episode, builder);
builder.Append("</Item>");
var xmlFilePath = GetSavePath(item);
XmlHelpers.Save(builder, xmlFilePath);
// Set last refreshed so that the provider doesn't trigger after the file save
EpisodeProviderFromXml.Current.SetLastRefreshed(item, DateTime.UtcNow);
}
/// <summary>
/// Gets the save path.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
public string GetSavePath(BaseItem item)
{
var filename = Path.ChangeExtension(Path.GetFileName(item.Path), ".xml");
return Path.Combine(Path.GetDirectoryName(item.Path), "metadata", filename);
}
}
}

60
MediaBrowser.Providers/Savers/FolderXmlSaver.cs Normal file
View File

@ -0,0 +1,60 @@
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System.IO;
using System.Text;
using System.Threading;
namespace MediaBrowser.Providers.Savers
{
public class FolderXmlSaver : IMetadataSaver
{
/// <summary>
/// Supportses the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
public bool Supports(BaseItem item)
{
if (item.LocationType != LocationType.FileSystem)
{
return false;
}
return item is Folder && !(item is Series) && !(item is BoxSet);
}
/// <summary>
/// Saves the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var builder = new StringBuilder();
builder.Append("<Item>");
XmlHelpers.AddCommonNodes(item, builder);
builder.Append("</Item>");
var xmlFilePath = GetSavePath(item);
XmlHelpers.Save(builder, xmlFilePath);
}
/// <summary>
/// Gets the save path.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
public string GetSavePath(BaseItem item)
{
return Path.Combine(item.Path, "folder.xml");
}
}
}

22
MediaBrowser.Providers/Savers/MovieXmlSaver.cs
View File

@ -1,10 +1,12 @@
using MediaBrowser.Controller.Entities;
using System.Text;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using MediaBrowser.Providers.Movies;
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Providers.Savers
{
@ -42,15 +44,23 @@ namespace MediaBrowser.Providers.Savers
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public Task Save(BaseItem item, CancellationToken cancellationToken)
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var video = (Video)item;
var builder = new StringBuilder();
builder.Append("<Title>");
XmlHelpers.AddCommonNodes(item, builder);
builder.Append("</Title>");
var xmlFilePath = GetSavePath(item);
return Task.Run(() => { });
}
XmlHelpers.Save(builder, xmlFilePath);
// Set last refreshed so that the provider doesn't trigger after the file save
MovieProviderFromXml.Current.SetLastRefreshed(item, DateTime.UtcNow);
}
public string GetSavePath(BaseItem item)
{

103
MediaBrowser.Providers/Savers/SeriesXmlSaver.cs Normal file
View File

@ -0,0 +1,103 @@
using System;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
using MediaBrowser.Providers.TV;
namespace MediaBrowser.Providers.Savers
{
public class SeriesXmlSaver : IMetadataSaver
{
/// <summary>
/// Supportses the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
public bool Supports(BaseItem item)
{
if (item.LocationType != LocationType.FileSystem)
{
return false;
}
return item is Series;
}
/// <summary>
/// Saves the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
public void Save(BaseItem item, CancellationToken cancellationToken)
{
var series = (Series)item;
var builder = new StringBuilder();
builder.Append("<Series>");
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<id>" + SecurityElement.Escape(tvdb) + "</id>");
}
if (!string.IsNullOrEmpty(item.Name))
{
builder.Append("<SeriesName>" + SecurityElement.Escape(item.Name) + "</SeriesName>");
}
if (series.Status.HasValue)
{
builder.Append("<Status>" + SecurityElement.Escape(series.Status.Value.ToString()) + "</Status>");
}
if (series.Studios.Count > 0)
{
builder.Append("<Network>" + SecurityElement.Escape(item.Studios[0]) + "</Network>");
}
if (!string.IsNullOrEmpty(series.AirTime))
{
builder.Append("<Airs_Time>" + SecurityElement.Escape(series.AirTime) + "</Airs_Time>");
}
if (series.AirDays.Count == 7)
{
builder.Append("<Airs_DayOfWeek>" + SecurityElement.Escape("Daily") + "</Airs_DayOfWeek>");
}
else if (series.AirDays.Count > 0)
{
builder.Append("<Airs_DayOfWeek>" + SecurityElement.Escape(series.AirDays[0].ToString()) + "</Airs_DayOfWeek>");
}
XmlHelpers.AddCommonNodes(item, builder);
builder.Append("</Series>");
var xmlFilePath = GetSavePath(item);
XmlHelpers.Save(builder, xmlFilePath);
// Set last refreshed so that the provider doesn't trigger after the file save
SeriesProviderFromXml.Current.SetLastRefreshed(item, DateTime.UtcNow);
}
/// <summary>
/// Gets the save path.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>System.String.</returns>
public string GetSavePath(BaseItem item)
{
return Path.Combine(item.Path, "series.xml");
}
}
}

346
MediaBrowser.Providers/Savers/XmlHelpers.cs Normal file
View File

@ -0,0 +1,346 @@
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Model.Entities;
using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Xml;
namespace MediaBrowser.Providers.Savers
{
/// <summary>
/// Class XmlHelpers
/// </summary>
public static class XmlHelpers
{
/// <summary>
/// The us culture
/// </summary>
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
/// <summary>
/// Saves the specified XML.
/// </summary>
/// <param name="xml">The XML.</param>
/// <param name="path">The path.</param>
public static void Save(StringBuilder xml, string path)
{
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xml.ToString());
//Add the new node to the document.
xmlDocument.InsertBefore(xmlDocument.CreateXmlDeclaration("1.0", "UTF-8", "yes"), xmlDocument.DocumentElement);
using (var streamWriter = new StreamWriter(path, false, Encoding.UTF8))
{
xmlDocument.Save(streamWriter);
}
}
/// <summary>
/// Adds the common nodes.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="builder">The builder.</param>
public static void AddCommonNodes(BaseItem item, StringBuilder builder)
{
if (!string.IsNullOrEmpty(item.OfficialRating))
{
builder.Append("<ContentRating>" + SecurityElement.Escape(item.OfficialRating) + "</ContentRating>");
builder.Append("<MPAARating>" + SecurityElement.Escape(item.OfficialRating) + "</MPAARating>");
builder.Append("<certification>" + SecurityElement.Escape(item.OfficialRating) + "</certification>");
}
if (item.People.Count > 0)
{
builder.Append("<Persons>");
foreach (var person in item.People)
{
builder.Append("<Person>");
builder.Append("<Name>" + SecurityElement.Escape(person.Name) + "</Name>");
builder.Append("<Type>" + SecurityElement.Escape(person.Type) + "</Type>");
builder.Append("<Role>" + SecurityElement.Escape(person.Role) + "</Role>");
builder.Append("</Person>");
}
builder.Append("</Persons>");
}
if (!string.IsNullOrEmpty(item.DisplayMediaType))
{
builder.Append("<Type>" + SecurityElement.Escape(item.DisplayMediaType) + "</Type>");
}
if (!string.IsNullOrEmpty(item.Overview))
{
builder.Append("<Overview><![CDATA[" + item.Overview + "]]></Overview>");
}
if (!string.IsNullOrEmpty(item.CustomRating))
{
builder.Append("<CustomRating>" + SecurityElement.Escape(item.CustomRating) + "</CustomRating>");
}
if (!string.IsNullOrEmpty(item.Name) && !(item is Episode))
{
builder.Append("<LocalTitle>" + SecurityElement.Escape(item.Name) + "</LocalTitle>");
}
if (!string.IsNullOrEmpty(item.ForcedSortName))
{
builder.Append("<SortTitle>" + SecurityElement.Escape(item.ForcedSortName) + "</SortTitle>");
}
if (item.Budget.HasValue)
{
builder.Append("<Budget>" + SecurityElement.Escape(item.Budget.Value.ToString(UsCulture)) + "</Budget>");
}
if (item.Revenue.HasValue)
{
builder.Append("<Revenue>" + SecurityElement.Escape(item.Revenue.Value.ToString(UsCulture)) + "</Revenue>");
}
if (item.CommunityRating.HasValue)
{
builder.Append("<Rating>" + SecurityElement.Escape(item.CommunityRating.Value.ToString(UsCulture)) + "</Rating>");
}
if (item.ProductionYear.HasValue)
{
builder.Append("<ProductionYear>" + SecurityElement.Escape(item.ProductionYear.Value.ToString(UsCulture)) + "</ProductionYear>");
}
if (!string.IsNullOrEmpty(item.HomePageUrl))
{
builder.Append("<Website>" + SecurityElement.Escape(item.HomePageUrl) + "</Website>");
}
if (!string.IsNullOrEmpty(item.AspectRatio))
{
builder.Append("<AspectRatio>" + SecurityElement.Escape(item.AspectRatio) + "</AspectRatio>");
}
if (!string.IsNullOrEmpty(item.Language))
{
builder.Append("<Language>" + SecurityElement.Escape(item.Language) + "</Language>");
}
if (item.RunTimeTicks.HasValue)
{
var timespan = TimeSpan.FromTicks(item.RunTimeTicks.Value);
builder.Append("<RunningTime>" + Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture) + "</RunningTime>");
builder.Append("<Runtime>" + Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture) + "</Runtime>");
}
if (item.Taglines.Count > 0)
{
builder.Append("<TagLine>" + SecurityElement.Escape(item.Taglines[0]) + "</TagLine>");
builder.Append("<TagLines>");
foreach (var tagline in item.Taglines)
{
builder.Append("<Tagline>" + SecurityElement.Escape(tagline) + "</Tagline>");
}
builder.Append("</TagLines>");
}
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
builder.Append("<IMDB_ID>" + SecurityElement.Escape(imdb) + "</IMDB_ID>");
builder.Append("<IMDB>" + SecurityElement.Escape(imdb) + "</IMDB>");
builder.Append("<IMDbId>" + SecurityElement.Escape(imdb) + "</IMDbId>");
}
var tmdb = item.GetProviderId(MetadataProviders.Tmdb);
if (!string.IsNullOrEmpty(tmdb))
{
builder.Append("<TMDbId>" + SecurityElement.Escape(tmdb) + "</TMDbId>");
}
var tvcom = item.GetProviderId(MetadataProviders.Tvcom);
if (!string.IsNullOrEmpty(tvcom))
{
builder.Append("<TVcomId>" + SecurityElement.Escape(tvcom) + "</TVcomId>");
}
var rt = item.GetProviderId(MetadataProviders.RottenTomatoes);
if (!string.IsNullOrEmpty(rt))
{
builder.Append("<RottenTomatoesId>" + SecurityElement.Escape(rt) + "</RottenTomatoesId>");
}
var tmdbCollection = item.GetProviderId(MetadataProviders.TmdbCollection);
if (!string.IsNullOrEmpty(tmdbCollection))
{
builder.Append("<CollectionNumber>" + SecurityElement.Escape(tmdbCollection) + "</CollectionNumber>");
}
if (item.Genres.Count > 0)
{
builder.Append("<Genres>");
foreach (var genre in item.Genres)
{
builder.Append("<Genre>" + SecurityElement.Escape(genre) + "</Genre>");
}
builder.Append("</Genres>");
}
if (item.Studios.Count > 0)
{
builder.Append("<Studios>");
foreach (var studio in item.Studios)
{
builder.Append("<Studio>" + SecurityElement.Escape(studio) + "</Studio>");
}
builder.Append("</Studios>");
}
builder.Append("<Added>" + SecurityElement.Escape(item.DateCreated.ToString(UsCulture)) + "</Added>");
}
/// <summary>
/// Appends the media info.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="item">The item.</param>
/// <param name="builder">The builder.</param>
public static void AppendMediaInfo<T>(T item, StringBuilder builder)
where T : BaseItem, IHasMediaStreams
{
builder.Append("<MediaInfo>");
foreach (var stream in item.MediaStreams)
{
if (stream.Type == MediaStreamType.Video)
{
builder.Append("<Video>");
if (!string.IsNullOrEmpty(stream.Codec))
{
builder.Append("<Codec>" + SecurityElement.Escape(stream.Codec) + "</Codec>");
builder.Append("<FFCodec>" + SecurityElement.Escape(stream.Codec) + "</FFCodec>");
}
if (stream.BitRate.HasValue)
{
builder.Append("<BitRate>" + stream.BitRate.Value.ToString(UsCulture) + "</BitRate>");
}
if (stream.Width.HasValue)
{
builder.Append("<Width>" + stream.Width.Value.ToString(UsCulture) + "</Width>");
}
if (stream.Height.HasValue)
{
builder.Append("<Height>" + stream.Height.Value.ToString(UsCulture) + "</Height>");
}
if (!string.IsNullOrEmpty(stream.AspectRatio))
{
builder.Append("<AspectRatio>" + SecurityElement.Escape(stream.AspectRatio) + "</AspectRatio>");
}
var framerate = stream.AverageFrameRate ?? stream.RealFrameRate;
if (framerate.HasValue)
{
builder.Append("<FrameRate>" + framerate.Value.ToString(UsCulture) + "</FrameRate>");
}
if (!string.IsNullOrEmpty(stream.Language))
{
builder.Append("<Language>" + SecurityElement.Escape(stream.Language) + "</Language>");
}
if (!string.IsNullOrEmpty(stream.ScanType))
{
builder.Append("<ScanType>" + SecurityElement.Escape(stream.ScanType) + "</ScanType>");
}
if (item.RunTimeTicks.HasValue)
{
var timespan = TimeSpan.FromTicks(item.RunTimeTicks.Value);
builder.Append("<Duration>" + Convert.ToInt32(timespan.TotalMinutes).ToString(UsCulture) + "</Duration>");
builder.Append("<DurationSeconds>" + Convert.ToInt32(timespan.TotalSeconds).ToString(UsCulture) + "</DurationSeconds>");
}
builder.Append("<Default>" + SecurityElement.Escape(stream.IsDefault.ToString()) + "</Default>");
builder.Append("<Forced>" + SecurityElement.Escape(stream.IsForced.ToString()) + "</Forced>");
builder.Append("</Video>");
}
else if (stream.Type == MediaStreamType.Audio)
{
builder.Append("<Audio>");
if (!string.IsNullOrEmpty(stream.Codec))
{
builder.Append("<Codec>" + SecurityElement.Escape(stream.Codec) + "</Codec>");
builder.Append("<FFCodec>" + SecurityElement.Escape(stream.Codec) + "</FFCodec>");
}
if (stream.Channels.HasValue)
{
builder.Append("<Channels>" + stream.Channels.Value.ToString(UsCulture) + "</Channels>");
}
if (stream.BitRate.HasValue)
{
builder.Append("<BitRate>" + stream.BitRate.Value.ToString(UsCulture) + "</BitRate>");
}
if (stream.SampleRate.HasValue)
{
builder.Append("<SamplingRate>" + stream.SampleRate.Value.ToString(UsCulture) + "</SamplingRate>");
}
if (!string.IsNullOrEmpty(stream.Language))
{
builder.Append("<Language>" + SecurityElement.Escape(stream.Language) + "</Language>");
}
builder.Append("<Default>" + SecurityElement.Escape(stream.IsDefault.ToString()) + "</Default>");
builder.Append("<Forced>" + SecurityElement.Escape(stream.IsForced.ToString()) + "</Forced>");
builder.Append("</Audio>");
}
else if (stream.Type == MediaStreamType.Subtitle)
{
builder.Append("<Subtitle>");
if (!string.IsNullOrEmpty(stream.Language))
{
builder.Append("<Language>" + SecurityElement.Escape(stream.Language) + "</Language>");
}
builder.Append("<Default>" + SecurityElement.Escape(stream.IsDefault.ToString()) + "</Default>");
builder.Append("<Forced>" + SecurityElement.Escape(stream.IsForced.ToString()) + "</Forced>");
builder.Append("</Subtitle>");
}
}
builder.Append("</MediaInfo>");
}
}
}

3
MediaBrowser.Providers/TV/EpisodeProviderFromXml.cs
View File

@ -16,9 +16,12 @@ namespace MediaBrowser.Providers.TV
/// </summary>
public class EpisodeProviderFromXml : BaseMetadataProvider
{
internal static EpisodeProviderFromXml Current { get; private set; }
public EpisodeProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager)
: base(logManager, configurationManager)
{
Current = this;
}
/// <summary>

6
MediaBrowser.Providers/TV/SeriesProviderFromXml.cs
View File

@ -16,8 +16,12 @@ namespace MediaBrowser.Providers.TV
/// </summary>
public class SeriesProviderFromXml : BaseMetadataProvider
{
public SeriesProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager) : base(logManager, configurationManager)
internal static SeriesProviderFromXml Current { get; private set; }
public SeriesProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager)
: base(logManager, configurationManager)
{
Current = this;
}
/// <summary>

35
MediaBrowser.Server.Implementations/Library/LibraryManager.cs
View File

@ -73,12 +73,6 @@ namespace MediaBrowser.Server.Implementations.Library
/// <value>The comparers.</value>
private IEnumerable<IBaseItemComparer> Comparers { get; set; }
/// <summary>
/// Gets or sets the savers.
/// </summary>
/// <value>The savers.</value>
private IEnumerable<IMetadataSaver> Savers { get; set; }
/// <summary>
/// Gets the active item repository
/// </summary>
@ -197,15 +191,13 @@ namespace MediaBrowser.Server.Implementations.Library
/// <param name="itemComparers">The item comparers.</param>
/// <param name="prescanTasks">The prescan tasks.</param>
/// <param name="postscanTasks">The postscan tasks.</param>
/// <param name="savers">The savers.</param>
public void AddParts(IEnumerable<IResolverIgnoreRule> rules,
IEnumerable<IVirtualFolderCreator> pluginFolders,
IEnumerable<IItemResolver> resolvers,
IEnumerable<IIntroProvider> introProviders,
IEnumerable<IBaseItemComparer> itemComparers,
IEnumerable<ILibraryPrescanTask> prescanTasks,
IEnumerable<ILibraryPostScanTask> postscanTasks,
IEnumerable<IMetadataSaver> savers)
IEnumerable<ILibraryPostScanTask> postscanTasks)
{
EntityResolutionIgnoreRules = rules;
PluginFolderCreators = pluginFolders;
@ -214,7 +206,6 @@ namespace MediaBrowser.Server.Implementations.Library
Comparers = itemComparers;
PrescanTasks = prescanTasks;
PostscanTasks = postscanTasks;
Savers = savers;
}
/// <summary>
@ -1301,11 +1292,7 @@ namespace MediaBrowser.Server.Implementations.Library
foreach (var item in list)
{
UpdateItemInLibraryCache(item);
}
foreach (var item in list)
{
await OnItemUpdated(item, CancellationToken.None).ConfigureAwait(false);
OnItemUpdated(item);
}
}
@ -1354,25 +1341,9 @@ namespace MediaBrowser.Server.Implementations.Library
/// Called when [item updated].
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task OnItemUpdated(BaseItem item, CancellationToken cancellationToken)
private void OnItemUpdated(BaseItem item)
{
if (ConfigurationManager.Configuration.SaveLocalMeta && item.LocationType == LocationType.FileSystem)
{
foreach (var saver in Savers.Where(i => i.Supports(item)))
{
try
{
await saver.Save(item, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.ErrorException("Error in metadata saver", ex);
}
}
}
if (ItemUpdated != null)
{
try

43
MediaBrowser.Server.Implementations/Providers/ProviderManager.cs
View File

@ -3,7 +3,9 @@ using MediaBrowser.Common.Net;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using System;
using System.Collections.Concurrent;
@ -58,6 +60,8 @@ namespace MediaBrowser.Server.Implementations.Providers
/// <value>The metadata providers enumerable.</value>
private BaseMetadataProvider[] MetadataProviders { get; set; }
private IEnumerable<IMetadataSaver> _savers;
/// <summary>
/// Initializes a new instance of the <see cref="ProviderManager" /> class.
/// </summary>
@ -65,7 +69,8 @@ namespace MediaBrowser.Server.Implementations.Providers
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="directoryWatchers">The directory watchers.</param>
/// <param name="logManager">The log manager.</param>
public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, IDirectoryWatchers directoryWatchers, ILogManager logManager)
/// <param name="libraryManager">The library manager.</param>
public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, IDirectoryWatchers directoryWatchers, ILogManager logManager, ILibraryManager libraryManager)
{
_logger = logManager.GetLogger("ProviderManager");
_httpClient = httpClient;
@ -74,6 +79,37 @@ namespace MediaBrowser.Server.Implementations.Providers
_remoteImageCache = new FileSystemRepository(configurationManager.ApplicationPaths.DownloadedImagesDataPath);
configurationManager.ConfigurationUpdated += configurationManager_ConfigurationUpdated;
libraryManager.ItemUpdated += libraryManager_ItemUpdated;
}
void libraryManager_ItemUpdated(object sender, ItemChangeEventArgs e)
{
var item = e.Item;
if (ConfigurationManager.Configuration.SaveLocalMeta && item.LocationType == LocationType.FileSystem)
{
foreach (var saver in _savers.Where(i => i.Supports(item)))
{
var path = saver.GetSavePath(item);
_directoryWatchers.TemporarilyIgnore(path);
try
{
saver.Save(item, CancellationToken.None);
}
catch (Exception ex)
{
_logger.ErrorException("Error in metadata saver", ex);
}
finally
{
_directoryWatchers.RemoveTempIgnore(path);
}
}
}
}
/// <summary>
@ -91,9 +127,12 @@ namespace MediaBrowser.Server.Implementations.Providers
/// Adds the metadata providers.
/// </summary>
/// <param name="providers">The providers.</param>
public void AddMetadataProviders(IEnumerable<BaseMetadataProvider> providers)
/// <param name="savers">The savers.</param>
public void AddParts(IEnumerable<BaseMetadataProvider> providers,
IEnumerable<IMetadataSaver> savers)
{
MetadataProviders = providers.OrderBy(e => e.Priority).ToArray();
_savers = savers;
}
/// <summary>

8
MediaBrowser.ServerApplication/ApplicationHost.cs
View File

@ -271,7 +271,7 @@ namespace MediaBrowser.ServerApplication
DirectoryWatchers = new DirectoryWatchers(LogManager, TaskManager, LibraryManager, ServerConfigurationManager);
RegisterSingleInstance(DirectoryWatchers);
ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, DirectoryWatchers, LogManager);
ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, DirectoryWatchers, LogManager, LibraryManager);
RegisterSingleInstance(ProviderManager);
RegisterSingleInstance<ILibrarySearchEngine>(() => new LuceneSearchEngine(ApplicationPaths, LogManager, LibraryManager));
@ -397,10 +397,10 @@ namespace MediaBrowser.ServerApplication
GetExports<IIntroProvider>(),
GetExports<IBaseItemComparer>(),
GetExports<ILibraryPrescanTask>(),
GetExports<ILibraryPostScanTask>(),
GetExports<IMetadataSaver>());
GetExports<ILibraryPostScanTask>());
ProviderManager.AddMetadataProviders(GetExports<BaseMetadataProvider>().ToArray());
ProviderManager.AddParts(GetExports<BaseMetadataProvider>().ToArray(),
GetExports<IMetadataSaver>());
}
/// <summary>