alteropen/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2026-07-16 03:03:40 +01:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

rework nfo savers

Browse Source
This commit is contained in:
Luke Pulverenti
2014-07-08 20:46:11 -04:00
parent c02e917f56
commit 651d483dec
33 changed files with 2143 additions and 1076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj
View File

@@ -56,13 +56,13 @@
<Compile Include="Providers\MovieNfoProvider.cs" />
<Compile Include="Providers\SeasonNfoProvider.cs" />
<Compile Include="Providers\SeriesNfoProvider.cs" />
<Compile Include="Savers\AlbumXmlSaver.cs" />
<Compile Include="Savers\ArtistXmlSaver.cs" />
<Compile Include="Savers\EpisodeXmlSaver.cs" />
<Compile Include="Savers\MovieXmlSaver.cs" />
<Compile Include="Savers\SeasonXmlSaver.cs" />
<Compile Include="Savers\SeriesXmlSaver.cs" />
<Compile Include="Savers\XmlSaverHelpers.cs" />
<Compile Include="Savers\AlbumNfoSaver.cs" />
<Compile Include="Savers\ArtistNfoSaver.cs" />
<Compile Include="Savers\BaseNfoSaver.cs" />
<Compile Include="Savers\EpisodeNfoSaver.cs" />
<Compile Include="Savers\MovieNfoSaver.cs" />
<Compile Include="Savers\SeasonNfoSaver.cs" />
<Compile Include="Savers\SeriesNfoSaver.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj">

9
MediaBrowser.XbmcMetadata/Parsers/BaseNfoParser.cs
View File

@@ -11,6 +11,7 @@ using System.Linq;
using System.Text;
using System.Threading;
using System.Xml;
using MediaBrowser.XbmcMetadata.Savers;
namespace MediaBrowser.XbmcMetadata.Parsers
{
@@ -63,8 +64,7 @@ namespace MediaBrowser.XbmcMetadata.Parsers
ValidationType = ValidationType.None
};
//Fetch(item, metadataFile, settings, Encoding.GetEncoding("ISO-8859-1"), cancellationToken);
Fetch(item, metadataFile, settings, Encoding.UTF8, cancellationToken);
Fetch(item, metadataFile, settings, cancellationToken);
}
/// <summary>
@@ -73,11 +73,10 @@ namespace MediaBrowser.XbmcMetadata.Parsers
/// <param name="item">The item.</param>
/// <param name="metadataFile">The metadata file.</param>
/// <param name="settings">The settings.</param>
/// <param name="encoding">The encoding.</param>
/// <param name="cancellationToken">The cancellation token.</param>
private void Fetch(T item, string metadataFile, XmlReaderSettings settings, Encoding encoding, CancellationToken cancellationToken)
private void Fetch(T item, string metadataFile, XmlReaderSettings settings, CancellationToken cancellationToken)
{
using (var streamReader = new StreamReader(metadataFile))
using (var streamReader = BaseNfoSaver.GetStreamReader(metadataFile))
{
// Use XmlReader for best performance
using (var reader = XmlReader.Create(streamReader, settings))

112
MediaBrowser.XbmcMetadata/Savers/AlbumNfoSaver.cs Normal file
View File

@@ -0,0 +1,112 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class AlbumNfoSaver : BaseNfoSaver
{
public AlbumNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
: base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
}
public override string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "album.nfo");
}
protected override string GetRootElementName(IHasMetadata item)
{
return "album";
}
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is MusicAlbum && updateType >= ItemUpdateType.MetadataDownload;
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var album = (MusicAlbum)item;
var tracks = album.Tracks
.ToList();
var artists = tracks
.SelectMany(i =>
{
var list = new List<string>();
if (!string.IsNullOrEmpty(i.AlbumArtist))
{
list.Add(i.AlbumArtist);
}
list.AddRange(i.Artists);
return list;
})
.Distinct(StringComparer.OrdinalIgnoreCase);
foreach (var artist in artists)
{
writer.WriteElementString("artist", artist);
}
AddTracks(tracks, writer);
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
private void AddTracks(IEnumerable<Audio> tracks, XmlWriter writer)
{
foreach (var track in tracks.OrderBy(i => i.ParentIndexNumber ?? 0).ThenBy(i => i.IndexNumber ?? 0))
{
writer.WriteStartElement("track");
if (track.IndexNumber.HasValue)
{
writer.WriteElementString("position", track.IndexNumber.Value.ToString(UsCulture));
}
if (!string.IsNullOrEmpty(track.Name))
{
writer.WriteElementString("title", track.Name);
}
if (track.RunTimeTicks.HasValue)
{
var time = TimeSpan.FromTicks(track.RunTimeTicks.Value).ToString(@"mm\:ss");
writer.WriteElementString("duration", time);
}
writer.WriteEndElement();
}
}
protected override List<string> GetTagsUsed()
{
var list = new List<string>
{
"track",
"artist"
};
return list;
}
}
}

134
MediaBrowser.XbmcMetadata/Savers/AlbumXmlSaver.cs
View File

@@ -1,134 +0,0 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Threading;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class AlbumXmlSaver : IMetadataFileSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
public AlbumXmlSaver(ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
{
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
_config = config;
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "album.nfo");
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var album = (MusicAlbum)item;
var builder = new StringBuilder();
builder.Append("<album>");
XmlSaverHelpers.AddCommonNodes(album, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
var tracks = album.Tracks
.ToList();
var artists = tracks
.SelectMany(i =>
{
var list = new List<string>();
if (!string.IsNullOrEmpty(i.AlbumArtist))
{
list.Add(i.AlbumArtist);
}
list.AddRange(i.Artists);
return list;
})
.Distinct(StringComparer.OrdinalIgnoreCase);
foreach (var artist in artists)
{
builder.Append("<artist>" + SecurityElement.Escape(artist) + "</artist>");
}
AddTracks(tracks, builder);
builder.Append("</album>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"track",
"artist"
});
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is MusicAlbum && updateType >= ItemUpdateType.MetadataDownload;
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
private void AddTracks(IEnumerable<Audio> tracks, StringBuilder builder)
{
foreach (var track in tracks.OrderBy(i => i.ParentIndexNumber ?? 0).ThenBy(i => i.IndexNumber ?? 0))
{
builder.Append("<track>");
if (track.IndexNumber.HasValue)
{
builder.Append("<position>" + SecurityElement.Escape(track.IndexNumber.Value.ToString(UsCulture)) + "</position>");
}
if (!string.IsNullOrEmpty(track.Name))
{
builder.Append("<title>" + SecurityElement.Escape(track.Name) + "</title>");
}
if (track.RunTimeTicks.HasValue)
{
var time = TimeSpan.FromTicks(track.RunTimeTicks.Value).ToString(@"mm\:ss");
builder.Append("<duration>" + SecurityElement.Escape(time) + "</duration>");
}
builder.Append("</track>");
}
}
}
}

94
MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs Normal file
View File

@@ -0,0 +1,94 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
using MediaBrowser.XbmcMetadata.Configuration;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class ArtistNfoSaver : BaseNfoSaver
{
public ArtistNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
: base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
}
public override string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "artist.nfo");
}
protected override string GetRootElementName(IHasMetadata item)
{
return "artist";
}
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is MusicArtist && updateType >= ItemUpdateType.MetadataDownload;
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var artist = (MusicArtist)item;
if (artist.EndDate.HasValue)
{
var formatString = ConfigurationManager.GetNfoConfiguration().ReleaseDateFormat;
writer.WriteElementString("disbanded", artist.EndDate.Value.ToString(formatString));
}
var albums = artist
.RecursiveChildren
.OfType<MusicAlbum>()
.ToList();
AddAlbums(albums, writer);
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
private void AddAlbums(IEnumerable<MusicAlbum> albums, XmlWriter writer)
{
foreach (var album in albums)
{
writer.WriteStartElement("album");
if (!string.IsNullOrEmpty(album.Name))
{
writer.WriteElementString("title", album.Name);
}
if (album.ProductionYear.HasValue)
{
writer.WriteElementString("year", album.ProductionYear.Value.ToString(UsCulture));
}
writer.WriteEndElement();
}
}
protected override List<string> GetTagsUsed()
{
var list = new List<string>
{
"album",
"disbanded"
};
return list;
}
}
}

116
MediaBrowser.XbmcMetadata/Savers/ArtistXmlSaver.cs
View File

@@ -1,116 +0,0 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using MediaBrowser.XbmcMetadata.Configuration;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using System.Threading;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class ArtistXmlSaver : IMetadataFileSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
public ArtistXmlSaver(ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
{
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
_config = config;
}
public string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "artist.nfo");
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var artist = (MusicArtist)item;
var builder = new StringBuilder();
builder.Append("<artist>");
XmlSaverHelpers.AddCommonNodes(artist, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
if (artist.EndDate.HasValue)
{
var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;
builder.Append("<disbanded>" + SecurityElement.Escape(artist.EndDate.Value.ToString(formatString)) + "</disbanded>");
}
var albums = artist
.RecursiveChildren
.OfType<MusicAlbum>()
.ToList();
AddAlbums(albums, builder);
builder.Append("</artist>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"album",
"disbanded"
});
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is MusicArtist && updateType >= ItemUpdateType.MetadataDownload;
}
private void AddAlbums(IEnumerable<MusicAlbum> albums, StringBuilder builder)
{
foreach (var album in albums)
{
builder.Append("<album>");
if (!string.IsNullOrEmpty(album.Name))
{
builder.Append("<title>" + SecurityElement.Escape(album.Name) + "</title>");
}
if (album.ProductionYear.HasValue)
{
builder.Append("<year>" + SecurityElement.Escape(album.ProductionYear.Value.ToString(UsCulture)) + "</year>");
}
builder.Append("</album>");
}
}
}
}

507
MediaBrowser.XbmcMetadata/Savers/XmlSaverHelpers.cs → MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs
View File

File diff suppressed because it is too large Load Diff

122
MediaBrowser.XbmcMetadata/Savers/EpisodeNfoSaver.cs Normal file
View File

@@ -0,0 +1,122 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.XbmcMetadata.Configuration;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class EpisodeNfoSaver : BaseNfoSaver
{
public EpisodeNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
: base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
}
public override string GetSavePath(IHasMetadata item)
{
return GetMovieSavePath(item);
}
public static string GetMovieSavePath(IHasMetadata item)
{
return Path.ChangeExtension(item.Path, ".nfo");
}
protected override string GetRootElementName(IHasMetadata item)
{
return "episodedetails";
}
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is Episode && updateType >= ItemUpdateType.MetadataDownload;
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var episode = (Episode)item;
if (episode.IndexNumber.HasValue)
{
writer.WriteElementString("episode", episode.IndexNumber.Value.ToString(UsCulture));
}
if (episode.IndexNumberEnd.HasValue)
{
writer.WriteElementString("episodenumberend", episode.IndexNumberEnd.Value.ToString(UsCulture));
}
if (episode.ParentIndexNumber.HasValue)
{
writer.WriteElementString("season", episode.ParentIndexNumber.Value.ToString(UsCulture));
}
if (episode.PremiereDate.HasValue)
{
var formatString = ConfigurationManager.GetNfoConfiguration().ReleaseDateFormat;
writer.WriteElementString("aired", episode.PremiereDate.Value.ToString(formatString));
}
if (episode.AirsAfterSeasonNumber.HasValue)
{
writer.WriteElementString("airsafter_season", episode.AirsAfterSeasonNumber.Value.ToString(UsCulture));
}
if (episode.AirsBeforeEpisodeNumber.HasValue)
{
writer.WriteElementString("airsbefore_episode", episode.AirsBeforeEpisodeNumber.Value.ToString(UsCulture));
}
if (episode.AirsBeforeSeasonNumber.HasValue)
{
writer.WriteElementString("airsbefore_season", episode.AirsBeforeSeasonNumber.Value.ToString(UsCulture));
}
if (episode.DvdEpisodeNumber.HasValue)
{
writer.WriteElementString("DVD_episodenumber", episode.DvdEpisodeNumber.Value.ToString(UsCulture));
}
if (episode.DvdSeasonNumber.HasValue)
{
writer.WriteElementString("DVD_season", episode.DvdSeasonNumber.Value.ToString(UsCulture));
}
if (episode.AbsoluteEpisodeNumber.HasValue)
{
writer.WriteElementString("absolute_number", episode.AbsoluteEpisodeNumber.Value.ToString(UsCulture));
}
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
protected override List<string> GetTagsUsed()
{
var list = new List<string>
{
"aired",
"season",
"episode",
"episodenumberend",
"airsafter_season",
"airsbefore_episode",
"airsbefore_season",
"DVD_episodenumber",
"DVD_season",
"absolute_number"
};
return list;
}
}
}

141
MediaBrowser.XbmcMetadata/Savers/EpisodeXmlSaver.cs
View File

@@ -1,141 +0,0 @@
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using MediaBrowser.XbmcMetadata.Configuration;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class EpisodeXmlSaver : IMetadataFileSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly CultureInfo _usCulture = new CultureInfo("en-US");
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
public EpisodeXmlSaver(ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
{
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
_config = config;
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public string GetSavePath(IHasMetadata item)
{
return Path.ChangeExtension(item.Path, ".nfo");
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var episode = (Episode)item;
var builder = new StringBuilder();
builder.Append("<episodedetails>");
XmlSaverHelpers.AddCommonNodes(episode, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
if (episode.IndexNumber.HasValue)
{
builder.Append("<episode>" + episode.IndexNumber.Value.ToString(_usCulture) + "</episode>");
}
if (episode.IndexNumberEnd.HasValue)
{
builder.Append("<episodenumberend>" + SecurityElement.Escape(episode.IndexNumberEnd.Value.ToString(_usCulture)) + "</episodenumberend>");
}
if (episode.ParentIndexNumber.HasValue)
{
builder.Append("<season>" + episode.ParentIndexNumber.Value.ToString(_usCulture) + "</season>");
}
if (episode.PremiereDate.HasValue)
{
var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;
builder.Append("<aired>" + SecurityElement.Escape(episode.PremiereDate.Value.ToString(formatString)) + "</aired>");
}
if (episode.AirsAfterSeasonNumber.HasValue)
{
builder.Append("<airsafter_season>" + SecurityElement.Escape(episode.AirsAfterSeasonNumber.Value.ToString(_usCulture)) + "</airsafter_season>");
}
if (episode.AirsBeforeEpisodeNumber.HasValue)
{
builder.Append("<airsbefore_episode>" + SecurityElement.Escape(episode.AirsBeforeEpisodeNumber.Value.ToString(_usCulture)) + "</airsbefore_episode>");
}
if (episode.AirsBeforeSeasonNumber.HasValue)
{
builder.Append("<airsbefore_season>" + SecurityElement.Escape(episode.AirsBeforeSeasonNumber.Value.ToString(_usCulture)) + "</airsbefore_season>");
}
if (episode.DvdEpisodeNumber.HasValue)
{
builder.Append("<DVD_episodenumber>" + SecurityElement.Escape(episode.DvdEpisodeNumber.Value.ToString(_usCulture)) + "</DVD_episodenumber>");
}
if (episode.DvdSeasonNumber.HasValue)
{
builder.Append("<DVD_season>" + SecurityElement.Escape(episode.DvdSeasonNumber.Value.ToString(_usCulture)) + "</DVD_season>");
}
if (episode.AbsoluteEpisodeNumber.HasValue)
{
builder.Append("<absolute_number>" + SecurityElement.Escape(episode.AbsoluteEpisodeNumber.Value.ToString(_usCulture)) + "</absolute_number>");
}
XmlSaverHelpers.AddMediaInfo((Episode)item, builder);
builder.Append("</episodedetails>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"aired",
"season",
"episode",
"episodenumberend",
"airsafter_season",
"airsbefore_episode",
"airsbefore_season",
"DVD_episodenumber",
"DVD_season",
"absolute_number"
});
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is Episode && updateType >= ItemUpdateType.MetadataDownload;
}
}
}

140
MediaBrowser.XbmcMetadata/Savers/MovieXmlSaver.cs → MediaBrowser.XbmcMetadata/Savers/MovieNfoSaver.cs
View File

@@ -6,40 +6,20 @@ using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class MovieXmlSaver : IMetadataFileSaver
public class MovieNfoSaver : BaseNfoSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
public MovieXmlSaver(ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
public MovieNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
: base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
_config = config;
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public string GetSavePath(IHasMetadata item)
public override string GetSavePath(IHasMetadata item)
{
return GetMovieSavePath(item);
}
@@ -58,65 +38,12 @@ namespace MediaBrowser.XbmcMetadata.Savers
return Path.ChangeExtension(item.Path, ".nfo");
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
protected override string GetRootElementName(IHasMetadata item)
{
var video = (Video)item;
var builder = new StringBuilder();
var tag = item is MusicVideo ? "musicvideo" : "movie";
builder.Append("<" + tag + ">");
XmlSaverHelpers.AddCommonNodes(video, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
builder.Append("<id>" + SecurityElement.Escape(imdb) + "</id>");
}
var musicVideo = item as MusicVideo;
if (musicVideo != null)
{
if (!string.IsNullOrEmpty(musicVideo.Artist))
{
builder.Append("<artist>" + SecurityElement.Escape(musicVideo.Artist) + "</artist>");
}
if (!string.IsNullOrEmpty(musicVideo.Album))
{
builder.Append("<album>" + SecurityElement.Escape(musicVideo.Album) + "</album>");
}
}
var movie = item as Movie;
if (movie != null)
{
if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
{
builder.Append("<set>" + SecurityElement.Escape(movie.TmdbCollectionName) + "</set>");
}
}
XmlSaverHelpers.AddMediaInfo((Video)item, builder);
builder.Append("</" + tag + ">");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"album",
"artist",
"set",
"id"
});
return item is MusicVideo ? "musicvideo" : "movie";
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
@@ -133,5 +60,54 @@ namespace MediaBrowser.XbmcMetadata.Savers
return false;
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var imdb = item.GetProviderId(MetadataProviders.Imdb);
if (!string.IsNullOrEmpty(imdb))
{
writer.WriteElementString("id", imdb);
}
var musicVideo = item as MusicVideo;
if (musicVideo != null)
{
if (!string.IsNullOrEmpty(musicVideo.Artist))
{
writer.WriteElementString("artist", musicVideo.Artist);
}
if (!string.IsNullOrEmpty(musicVideo.Album))
{
writer.WriteElementString("album", musicVideo.Album);
}
}
var movie = item as Movie;
if (movie != null)
{
if (!string.IsNullOrEmpty(movie.TmdbCollectionName))
{
writer.WriteElementString("set", movie.TmdbCollectionName);
}
}
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
protected override List<string> GetTagsUsed()
{
var list = new List<string>
{
"album",
"artist",
"set",
"id"
};
return list;
}
}
}

63
MediaBrowser.XbmcMetadata/Savers/SeasonNfoSaver.cs Normal file
View File

@@ -0,0 +1,63 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class SeasonNfoSaver : BaseNfoSaver
{
public SeasonNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager) : base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
}
public override string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "season.nfo");
}
protected override string GetRootElementName(IHasMetadata item)
{
return "season";
}
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
if (!(item is Season))
{
return false;
}
return updateType >= ItemUpdateType.MetadataDownload || (updateType >= ItemUpdateType.MetadataImport && File.Exists(GetSavePath(item)));
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var season = (Season)item;
if (season.IndexNumber.HasValue)
{
writer.WriteElementString("seasonnumber", season.IndexNumber.Value.ToString(CultureInfo.InvariantCulture));
}
}
protected override List<string> GetTagsUsed()
{
var list = base.GetTagsUsed();
list.Add("seasonnumber");
return list;
}
}
}

86
MediaBrowser.XbmcMetadata/Savers/SeasonXmlSaver.cs
View File

@@ -1,86 +0,0 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class SeasonXmlSaver : IMetadataFileSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
public SeasonXmlSaver(ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
{
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
_config = config;
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "season.nfo");
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var builder = new StringBuilder();
builder.Append("<season>");
var season = (Season)item;
if (season.IndexNumber.HasValue)
{
builder.Append("<seasonnumber>" + SecurityElement.Escape(season.IndexNumber.Value.ToString(CultureInfo.InvariantCulture)) + "</seasonnumber>");
}
XmlSaverHelpers.AddCommonNodes((Season)item, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
builder.Append("</season>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"seasonnumber"
});
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
if (!(item is Season))
{
return false;
}
return updateType >= ItemUpdateType.MetadataDownload || (updateType >= ItemUpdateType.MetadataImport && File.Exists(GetSavePath(item)));
}
}
}

113
MediaBrowser.XbmcMetadata/Savers/SeriesNfoSaver.cs Normal file
View File

@@ -0,0 +1,113 @@
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Xml;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class SeriesNfoSaver : BaseNfoSaver
{
public SeriesNfoSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager)
: base(fileSystem, configurationManager, libraryManager, userManager, userDataManager)
{
}
public override string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "tvshow.nfo");
}
protected override string GetRootElementName(IHasMetadata item)
{
return "tvshow";
}
public override bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is Series && updateType >= ItemUpdateType.MetadataDownload;
}
protected override void WriteCustomElements(IHasMetadata item, XmlWriter writer)
{
var series = (Series)item;
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
writer.WriteElementString("id", tvdb);
writer.WriteStartElement("episodeguide");
var language = item.GetPreferredMetadataLanguage();
language = string.IsNullOrEmpty(language)
? "en"
: language;
writer.WriteStartElement("url");
writer.WriteAttributeString("cache", string.Format("{0}.xml", tvdb));
writer.WriteString(string.Format("http://www.thetvdb.com/api/1D62F2F90030C444/series/{0}/all/{1}.zip", tvdb, language));
writer.WriteEndElement();
writer.WriteEndElement();
}
writer.WriteElementString("season", "-1");
writer.WriteElementString("episode", "-1");
if (series.Status.HasValue)
{
writer.WriteElementString("status", series.Status.Value.ToString());
}
if (!string.IsNullOrEmpty(series.AirTime))
{
writer.WriteElementString("airs_time", series.AirTime);
}
if (series.AirDays.Count == 7)
{
writer.WriteElementString("airs_dayofweek", "Daily");
}
else if (series.AirDays.Count > 0)
{
writer.WriteElementString("airs_dayofweek", series.AirDays[0].ToString());
}
if (series.AnimeSeriesIndex.HasValue)
{
writer.WriteElementString("animeseriesindex", series.AnimeSeriesIndex.Value.ToString(CultureInfo.InvariantCulture));
}
}
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
protected override List<string> GetTagsUsed()
{
var list = new List<string>
{
"id",
"episodeguide",
"season",
"episode",
"status",
"airs_time",
"airs_dayofweek",
"animeseriesindex"
};
return list;
}
}
}

122
MediaBrowser.XbmcMetadata/Savers/SeriesXmlSaver.cs
View File

@@ -1,122 +0,0 @@
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Security;
using System.Text;
using System.Threading;
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Entities;
namespace MediaBrowser.XbmcMetadata.Savers
{
public class SeriesXmlSaver : IMetadataFileSaver
{
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataRepo;
private readonly IFileSystem _fileSystem;
private readonly IServerConfigurationManager _config;
public SeriesXmlSaver(IServerConfigurationManager config, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem)
{
_config = config;
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepo = userDataRepo;
_fileSystem = fileSystem;
}
public string Name
{
get
{
return "Xbmc Nfo";
}
}
public string GetSavePath(IHasMetadata item)
{
return Path.Combine(item.Path, "tvshow.nfo");
}
public void Save(IHasMetadata item, CancellationToken cancellationToken)
{
var series = (Series)item;
var builder = new StringBuilder();
builder.Append("<tvshow>");
XmlSaverHelpers.AddCommonNodes(series, builder, _libraryManager, _userManager, _userDataRepo, _fileSystem, _config);
var tvdb = item.GetProviderId(MetadataProviders.Tvdb);
if (!string.IsNullOrEmpty(tvdb))
{
builder.Append("<id>" + SecurityElement.Escape(tvdb) + "</id>");
builder.AppendFormat("<episodeguide><url cache=\"{0}.xml\">http://www.thetvdb.com/api/1D62F2F90030C444/series/{0}/all/{1}.zip</url></episodeguide>",
tvdb,
string.IsNullOrEmpty(_config.Configuration.PreferredMetadataLanguage) ? "en" : _config.Configuration.PreferredMetadataLanguage);
}
builder.Append("<season>-1</season>");
builder.Append("<episode>-1</episode>");
if (series.Status.HasValue)
{
builder.Append("<status>" + SecurityElement.Escape(series.Status.Value.ToString()) + "</status>");
}
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>");
}
if (series.AnimeSeriesIndex.HasValue)
{
builder.Append("<animeseriesindex>" + SecurityElement.Escape(series.AnimeSeriesIndex.Value.ToString(CultureInfo.InvariantCulture)) + "</animeseriesindex>");
}
builder.Append("</tvshow>");
var xmlFilePath = GetSavePath(item);
XmlSaverHelpers.Save(builder, xmlFilePath, new List<string>
{
"id",
"episodeguide",
"season",
"episode",
"status",
"airs_time",
"airs_dayofweek",
"animeseriesindex"
});
}
public bool IsEnabledFor(IHasMetadata item, ItemUpdateType updateType)
{
if (!item.SupportsLocalMetadata)
{
return false;
}
return item is Series && updateType >= ItemUpdateType.MetadataDownload;
}
}
}