2014-01-22 05:22:09 +00:00
|
|
|
|
using System;
|
2014-01-26 07:14:55 +00:00
|
|
|
|
using System.Collections.Generic;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Text;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
using System.Text.RegularExpressions;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
using System.Xml;
|
|
|
|
|
using System.Xml.Linq;
|
|
|
|
|
using NLog;
|
|
|
|
|
using NzbDrone.Common;
|
2014-01-27 00:09:44 +00:00
|
|
|
|
using NzbDrone.Common.Disk;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
using NzbDrone.Core.MediaCover;
|
|
|
|
|
using NzbDrone.Core.MediaFiles;
|
|
|
|
|
using NzbDrone.Core.Messaging.Events;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
using NzbDrone.Core.Metadata.Files;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
using NzbDrone.Core.Tv;
|
|
|
|
|
|
|
|
|
|
namespace NzbDrone.Core.Metadata.Consumers.Xbmc
|
|
|
|
|
{
|
2014-01-24 16:17:56 +00:00
|
|
|
|
public class XbmcMetadata : MetadataBase<XbmcMetadataSettings>
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
|
|
|
|
private readonly IEventAggregator _eventAggregator;
|
|
|
|
|
private readonly IMapCoversToLocal _mediaCoverService;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
private readonly IMediaFileService _mediaFileService;
|
|
|
|
|
private readonly IMetadataFileService _metadataFileService;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
private readonly IDiskProvider _diskProvider;
|
|
|
|
|
private readonly IHttpProvider _httpProvider;
|
2014-02-19 04:51:37 +00:00
|
|
|
|
private readonly IEpisodeService _episodeService;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
private readonly Logger _logger;
|
|
|
|
|
|
|
|
|
|
public XbmcMetadata(IEventAggregator eventAggregator,
|
|
|
|
|
IMapCoversToLocal mediaCoverService,
|
2014-01-24 16:17:56 +00:00
|
|
|
|
IMediaFileService mediaFileService,
|
|
|
|
|
IMetadataFileService metadataFileService,
|
2014-01-22 05:22:09 +00:00
|
|
|
|
IDiskProvider diskProvider,
|
|
|
|
|
IHttpProvider httpProvider,
|
2014-02-19 04:51:37 +00:00
|
|
|
|
IEpisodeService episodeService,
|
2014-01-22 05:22:09 +00:00
|
|
|
|
Logger logger)
|
|
|
|
|
: base(diskProvider, httpProvider, logger)
|
|
|
|
|
{
|
|
|
|
|
_eventAggregator = eventAggregator;
|
|
|
|
|
_mediaCoverService = mediaCoverService;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
_mediaFileService = mediaFileService;
|
|
|
|
|
_metadataFileService = metadataFileService;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
_diskProvider = diskProvider;
|
|
|
|
|
_httpProvider = httpProvider;
|
2014-02-19 04:51:37 +00:00
|
|
|
|
_episodeService = episodeService;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
_logger = logger;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-24 16:17:56 +00:00
|
|
|
|
private static readonly Regex SeriesImagesRegex = new Regex(@"^(?<type>poster|banner|fanart)\.(?:png|jpg)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
|
|
|
private static readonly Regex SeasonImagesRegex = new Regex(@"^season(?<season>\d{2,}|-all|-specials)-(?<type>poster|banner|fanart)\.(?:png|jpg)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
|
|
|
private static readonly Regex EpisodeImageRegex = new Regex(@"-thumb\.(?:png|jpg)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
public override void OnSeriesUpdated(Series series, List<MetadataFile> existingMetadataFiles, List<EpisodeFile> episodeFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadataFiles = new List<MetadataFile>();
|
|
|
|
|
|
2014-02-19 04:51:37 +00:00
|
|
|
|
if (!_diskProvider.FolderExists(series.Path))
|
|
|
|
|
{
|
|
|
|
|
_logger.Info("Series folder does not exist, skipping metadata creation");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-22 05:22:09 +00:00
|
|
|
|
if (Settings.SeriesMetadata)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
metadataFiles.Add(WriteTvShowNfo(series, existingMetadataFiles));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (Settings.SeriesImages)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
metadataFiles.AddRange(WriteSeriesImages(series, existingMetadataFiles));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (Settings.SeasonImages)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
metadataFiles.AddRange(WriteSeasonImages(series, existingMetadataFiles));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
2014-02-19 04:51:37 +00:00
|
|
|
|
|
|
|
|
|
foreach (var episodeFile in episodeFiles)
|
|
|
|
|
{
|
|
|
|
|
if (Settings.EpisodeMetadata)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
metadataFiles.Add(WriteEpisodeNfo(series, episodeFile, existingMetadataFiles));
|
2014-02-19 04:51:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
foreach (var episodeFile in episodeFiles)
|
|
|
|
|
{
|
|
|
|
|
if (Settings.EpisodeImages)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadataFile = WriteEpisodeImages(series, episodeFile, existingMetadataFiles);
|
|
|
|
|
|
|
|
|
|
if (metadataFile != null)
|
|
|
|
|
{
|
|
|
|
|
metadataFiles.Add(metadataFile);
|
|
|
|
|
}
|
2014-02-19 04:51:37 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-02-22 22:03:23 +00:00
|
|
|
|
|
|
|
|
|
_eventAggregator.PublishEvent(new MetadataFilesUpdated(metadataFiles));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override void OnEpisodeImport(Series series, EpisodeFile episodeFile, bool newDownload)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadataFiles = new List<MetadataFile>();
|
|
|
|
|
|
2014-01-22 05:22:09 +00:00
|
|
|
|
if (Settings.EpisodeMetadata)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
metadataFiles.Add(WriteEpisodeNfo(series, episodeFile, new List<MetadataFile>()));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (Settings.EpisodeImages)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadataFile = WriteEpisodeImages(series, episodeFile, new List<MetadataFile>());
|
|
|
|
|
|
|
|
|
|
if (metadataFile != null)
|
|
|
|
|
{
|
|
|
|
|
metadataFiles.Add(metadataFile);
|
|
|
|
|
}
|
2014-02-19 04:51:37 +00:00
|
|
|
|
WriteEpisodeImages(series, episodeFile, new List<MetadataFile>());
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
2014-02-22 22:03:23 +00:00
|
|
|
|
|
|
|
|
|
_eventAggregator.PublishEvent(new MetadataFilesUpdated(metadataFiles));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
public override void AfterRename(Series series, List<MetadataFile> existingMetadataFiles, List<EpisodeFile> episodeFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var episodeFilesMetadata = existingMetadataFiles.Where(c => c.EpisodeFileId > 0).ToList();
|
|
|
|
|
var updatedMetadataFiles = new List<MetadataFile>();
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
|
|
|
|
foreach (var episodeFile in episodeFiles)
|
|
|
|
|
{
|
|
|
|
|
var metadataFiles = episodeFilesMetadata.Where(m => m.EpisodeFileId == episodeFile.Id).ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var metadataFile in metadataFiles)
|
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
string newFilename;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
if (metadataFile.Type == MetadataType.EpisodeImage)
|
2014-01-24 16:17:56 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
newFilename = GetEpisodeImageFilename(episodeFile.Path);
|
|
|
|
|
}
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
else if (metadataFile.Type == MetadataType.EpisodeMetadata)
|
|
|
|
|
{
|
|
|
|
|
newFilename = GetEpisodeNfoFilename(episodeFile.Path);
|
|
|
|
|
}
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2014-03-13 20:12:42 +00:00
|
|
|
|
_logger.Debug("Unknown episode file metadata: {0}", metadataFile.RelativePath);
|
2014-02-22 22:03:23 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var existingFilename = Path.Combine(series.Path, metadataFile.RelativePath);
|
|
|
|
|
|
|
|
|
|
if (!newFilename.PathEquals(existingFilename))
|
|
|
|
|
{
|
|
|
|
|
_diskProvider.MoveFile(existingFilename, newFilename);
|
|
|
|
|
metadataFile.RelativePath = DiskProviderBase.GetRelativePath(series.Path, newFilename);
|
|
|
|
|
|
|
|
|
|
updatedMetadataFiles.Add(metadataFile);
|
2014-01-24 16:17:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-02-22 22:03:23 +00:00
|
|
|
|
|
|
|
|
|
_eventAggregator.PublishEvent(new MetadataFilesUpdated(updatedMetadataFiles));
|
2014-01-24 16:17:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override MetadataFile FindMetadataFile(Series series, string path)
|
|
|
|
|
{
|
|
|
|
|
var filename = Path.GetFileName(path);
|
|
|
|
|
|
|
|
|
|
if (filename == null) return null;
|
|
|
|
|
|
|
|
|
|
var metadata = new MetadataFile
|
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
Consumer = GetType().Name,
|
2014-01-27 00:09:44 +00:00
|
|
|
|
RelativePath = DiskProviderBase.GetRelativePath(series.Path, path)
|
2014-01-24 16:17:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if (SeriesImagesRegex.IsMatch(filename))
|
|
|
|
|
{
|
|
|
|
|
metadata.Type = MetadataType.SeriesImage;
|
|
|
|
|
return metadata;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var seasonMatch = SeasonImagesRegex.Match(filename);
|
|
|
|
|
|
|
|
|
|
if (seasonMatch.Success)
|
|
|
|
|
{
|
|
|
|
|
metadata.Type = MetadataType.SeasonImage;
|
|
|
|
|
|
2014-04-08 19:14:35 +00:00
|
|
|
|
var seasonNumberMatch = seasonMatch.Groups["season"].Value;
|
|
|
|
|
int seasonNumber;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-04-08 19:14:35 +00:00
|
|
|
|
if (seasonNumberMatch.Contains("specials"))
|
2014-01-24 16:17:56 +00:00
|
|
|
|
{
|
|
|
|
|
metadata.SeasonNumber = 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-08 19:14:35 +00:00
|
|
|
|
else if (Int32.TryParse(seasonNumberMatch, out seasonNumber))
|
|
|
|
|
{
|
|
|
|
|
metadata.SeasonNumber = seasonNumber;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-24 16:17:56 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2014-04-08 19:14:35 +00:00
|
|
|
|
return null;
|
2014-01-24 16:17:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return metadata;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (EpisodeImageRegex.IsMatch(filename))
|
|
|
|
|
{
|
|
|
|
|
metadata.Type = MetadataType.EpisodeImage;
|
|
|
|
|
return metadata;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (filename.Equals("tvshow.nfo", StringComparison.InvariantCultureIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
metadata.Type = MetadataType.SeriesMetadata;
|
|
|
|
|
return metadata;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var parseResult = Parser.Parser.ParseTitle(filename);
|
|
|
|
|
|
|
|
|
|
if (parseResult != null &&
|
|
|
|
|
!parseResult.FullSeason &&
|
|
|
|
|
Path.GetExtension(filename) == ".nfo")
|
|
|
|
|
{
|
|
|
|
|
metadata.Type = MetadataType.EpisodeMetadata;
|
|
|
|
|
return metadata;
|
|
|
|
|
}
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
2014-01-24 16:17:56 +00:00
|
|
|
|
return null;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private MetadataFile WriteTvShowNfo(Series series, List<MetadataFile> existingMetadataFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
2014-03-13 20:12:42 +00:00
|
|
|
|
_logger.Debug("Generating tvshow.nfo for: {0}", series.Title);
|
2014-01-22 05:22:09 +00:00
|
|
|
|
var sb = new StringBuilder();
|
|
|
|
|
var xws = new XmlWriterSettings();
|
|
|
|
|
xws.OmitXmlDeclaration = true;
|
|
|
|
|
xws.Indent = false;
|
|
|
|
|
|
2014-04-26 16:01:03 +00:00
|
|
|
|
var episodeGuideUrl = String.Format("http://www.thetvdb.com/api/1D62F2F90030C444/series/{0}/all/en.zip", series.TvdbId);
|
|
|
|
|
|
2014-01-22 05:22:09 +00:00
|
|
|
|
using (var xw = XmlWriter.Create(sb, xws))
|
|
|
|
|
{
|
|
|
|
|
var tvShow = new XElement("tvshow");
|
|
|
|
|
|
|
|
|
|
tvShow.Add(new XElement("title", series.Title));
|
2014-02-20 07:06:44 +00:00
|
|
|
|
tvShow.Add(new XElement("rating", (decimal)series.Ratings.Percentage/10));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
tvShow.Add(new XElement("plot", series.Overview));
|
2014-04-26 16:01:03 +00:00
|
|
|
|
tvShow.Add(new XElement("episodeguide", new XElement("url", episodeGuideUrl)));
|
|
|
|
|
tvShow.Add(new XElement("episodeguideurl", episodeGuideUrl));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
tvShow.Add(new XElement("mpaa", series.Certification));
|
|
|
|
|
tvShow.Add(new XElement("id", series.TvdbId));
|
|
|
|
|
|
|
|
|
|
foreach (var genre in series.Genres)
|
|
|
|
|
{
|
|
|
|
|
tvShow.Add(new XElement("genre", genre));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (series.FirstAired.HasValue)
|
|
|
|
|
{
|
|
|
|
|
tvShow.Add(new XElement("premiered", series.FirstAired.Value.ToString("yyyy-MM-dd")));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tvShow.Add(new XElement("studio", series.Network));
|
|
|
|
|
|
|
|
|
|
foreach (var actor in series.Actors)
|
|
|
|
|
{
|
|
|
|
|
tvShow.Add(new XElement("actor",
|
|
|
|
|
new XElement("name", actor.Name),
|
|
|
|
|
new XElement("role", actor.Character),
|
2014-02-17 06:41:13 +00:00
|
|
|
|
new XElement("thumb", actor.Images.First().Url)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var doc = new XDocument(tvShow);
|
|
|
|
|
doc.Save(xw);
|
|
|
|
|
|
|
|
|
|
_logger.Debug("Saving tvshow.nfo for {0}", series.Title);
|
|
|
|
|
|
|
|
|
|
var path = Path.Combine(series.Path, "tvshow.nfo");
|
|
|
|
|
|
|
|
|
|
_diskProvider.WriteAllText(path, doc.ToString());
|
|
|
|
|
|
2014-01-26 07:14:55 +00:00
|
|
|
|
var metadata = existingMetadataFiles.SingleOrDefault(c => c.Type == MetadataType.SeriesMetadata) ??
|
|
|
|
|
new MetadataFile
|
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
Consumer = GetType().Name,
|
|
|
|
|
Type = MetadataType.SeriesMetadata,
|
2014-01-27 00:09:44 +00:00
|
|
|
|
RelativePath = DiskProviderBase.GetRelativePath(series.Path, path)
|
2014-01-26 07:14:55 +00:00
|
|
|
|
};
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
return metadata;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private IEnumerable<MetadataFile> WriteSeriesImages(Series series, List<MetadataFile> existingMetadataFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
|
|
|
|
foreach (var image in series.Images)
|
|
|
|
|
{
|
|
|
|
|
var source = _mediaCoverService.GetCoverPath(series.Id, image.CoverType);
|
|
|
|
|
var destination = Path.Combine(series.Path, image.CoverType.ToString().ToLowerInvariant() + Path.GetExtension(source));
|
|
|
|
|
|
|
|
|
|
//TODO: Do we want to overwrite the file if it exists?
|
|
|
|
|
if (_diskProvider.FileExists(destination))
|
|
|
|
|
{
|
2014-03-13 20:12:42 +00:00
|
|
|
|
_logger.Debug("Series image: {0} already exists.", image.CoverType);
|
2014-01-22 05:22:09 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_diskProvider.CopyFile(source, destination, false);
|
2014-04-02 14:26:18 +00:00
|
|
|
|
var relativePath = DiskProviderBase.GetRelativePath(series.Path, destination);
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-04-02 14:26:18 +00:00
|
|
|
|
var metadata = existingMetadataFiles.SingleOrDefault(c => c.Type == MetadataType.SeriesImage &&
|
|
|
|
|
c.RelativePath == relativePath) ??
|
2014-01-26 07:14:55 +00:00
|
|
|
|
new MetadataFile
|
2014-01-24 16:17:56 +00:00
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
Consumer = GetType().Name,
|
|
|
|
|
Type = MetadataType.SeriesImage,
|
2014-04-02 14:26:18 +00:00
|
|
|
|
RelativePath = relativePath
|
2014-01-24 16:17:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
yield return metadata;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private IEnumerable<MetadataFile> WriteSeasonImages(Series series, List<MetadataFile> existingMetadataFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
|
|
|
|
foreach (var season in series.Seasons)
|
|
|
|
|
{
|
|
|
|
|
foreach (var image in season.Images)
|
|
|
|
|
{
|
|
|
|
|
var filename = String.Format("season{0:00}-{1}.jpg", season.SeasonNumber, image.CoverType.ToString().ToLower());
|
|
|
|
|
|
|
|
|
|
if (season.SeasonNumber == 0)
|
|
|
|
|
{
|
|
|
|
|
filename = String.Format("season-specials-{0}.jpg", image.CoverType.ToString().ToLower());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var path = Path.Combine(series.Path, filename);
|
2014-04-02 14:26:18 +00:00
|
|
|
|
var relativePath = DiskProviderBase.GetRelativePath(series.Path, path);
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-04-02 14:26:18 +00:00
|
|
|
|
DownloadImage(series, image.Url, path);
|
|
|
|
|
|
2014-01-26 07:14:55 +00:00
|
|
|
|
var metadata = existingMetadataFiles.SingleOrDefault(c => c.Type == MetadataType.SeasonImage &&
|
2014-04-02 14:26:18 +00:00
|
|
|
|
c.SeasonNumber == season.SeasonNumber &&
|
|
|
|
|
c.RelativePath == relativePath) ??
|
2014-01-26 07:14:55 +00:00
|
|
|
|
new MetadataFile
|
2014-01-24 16:17:56 +00:00
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
SeasonNumber = season.SeasonNumber,
|
|
|
|
|
Consumer = GetType().Name,
|
2014-02-17 06:41:13 +00:00
|
|
|
|
Type = MetadataType.SeasonImage,
|
2014-04-02 14:26:18 +00:00
|
|
|
|
RelativePath = relativePath
|
2014-01-24 16:17:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
yield return metadata;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private MetadataFile WriteEpisodeNfo(Series series, EpisodeFile episodeFile, List<MetadataFile> existingMetadataFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var filename = GetEpisodeNfoFilename(episodeFile.Path);
|
|
|
|
|
var relativePath = DiskProviderBase.GetRelativePath(series.Path, filename);
|
|
|
|
|
|
|
|
|
|
var existingMetadata = existingMetadataFiles.SingleOrDefault(c => c.Type == MetadataType.EpisodeMetadata &&
|
|
|
|
|
c.EpisodeFileId == episodeFile.Id);
|
|
|
|
|
|
|
|
|
|
if (existingMetadata != null)
|
|
|
|
|
{
|
|
|
|
|
var fullPath = Path.Combine(series.Path, existingMetadata.RelativePath);
|
|
|
|
|
if (!filename.PathEquals(fullPath))
|
|
|
|
|
{
|
|
|
|
|
_diskProvider.MoveFile(fullPath, filename);
|
|
|
|
|
existingMetadata.RelativePath = relativePath;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
|
|
|
|
_logger.Debug("Generating {0} for: {1}", filename, episodeFile.Path);
|
|
|
|
|
|
|
|
|
|
var xmlResult = String.Empty;
|
|
|
|
|
foreach (var episode in episodeFile.Episodes.Value)
|
|
|
|
|
{
|
|
|
|
|
var sb = new StringBuilder();
|
|
|
|
|
var xws = new XmlWriterSettings();
|
|
|
|
|
xws.OmitXmlDeclaration = true;
|
|
|
|
|
xws.Indent = false;
|
|
|
|
|
|
|
|
|
|
using (var xw = XmlWriter.Create(sb, xws))
|
|
|
|
|
{
|
|
|
|
|
var doc = new XDocument();
|
2014-02-19 04:51:37 +00:00
|
|
|
|
var image = episode.Images.SingleOrDefault(i => i.CoverType == MediaCoverTypes.Screenshot);
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
|
|
|
|
var details = new XElement("episodedetails");
|
|
|
|
|
details.Add(new XElement("title", episode.Title));
|
|
|
|
|
details.Add(new XElement("season", episode.SeasonNumber));
|
|
|
|
|
details.Add(new XElement("episode", episode.EpisodeNumber));
|
|
|
|
|
details.Add(new XElement("aired", episode.AirDate));
|
|
|
|
|
details.Add(new XElement("plot", episode.Overview));
|
2014-02-18 04:15:25 +00:00
|
|
|
|
|
|
|
|
|
//If trakt ever gets airs before information for specials we should add set it
|
|
|
|
|
details.Add(new XElement("displayseason"));
|
|
|
|
|
details.Add(new XElement("displayepisode"));
|
2014-02-19 04:51:37 +00:00
|
|
|
|
|
|
|
|
|
if (image == null)
|
|
|
|
|
{
|
|
|
|
|
details.Add(new XElement("thumb"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
details.Add(new XElement("thumb", image.Url));
|
|
|
|
|
}
|
2014-02-18 04:15:25 +00:00
|
|
|
|
|
2014-01-22 05:22:09 +00:00
|
|
|
|
details.Add(new XElement("watched", "false"));
|
2014-02-20 07:06:44 +00:00
|
|
|
|
details.Add(new XElement("rating", (decimal)episode.Ratings.Percentage/10));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
2014-01-26 07:14:55 +00:00
|
|
|
|
//Todo: get guest stars, writer and director
|
|
|
|
|
//details.Add(new XElement("credits", tvdbEpisode.Writer.FirstOrDefault()));
|
|
|
|
|
//details.Add(new XElement("director", tvdbEpisode.Directors.FirstOrDefault()));
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
|
|
|
|
doc.Add(details);
|
|
|
|
|
doc.Save(xw);
|
|
|
|
|
|
|
|
|
|
xmlResult += doc.ToString();
|
|
|
|
|
xmlResult += Environment.NewLine;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_logger.Debug("Saving episodedetails to: {0}", filename);
|
|
|
|
|
_diskProvider.WriteAllText(filename, xmlResult.Trim(Environment.NewLine.ToCharArray()));
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadata = existingMetadata ??
|
2014-02-19 04:51:37 +00:00
|
|
|
|
new MetadataFile
|
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
EpisodeFileId = episodeFile.Id,
|
|
|
|
|
Consumer = GetType().Name,
|
|
|
|
|
Type = MetadataType.EpisodeMetadata,
|
|
|
|
|
RelativePath = DiskProviderBase.GetRelativePath(series.Path, filename)
|
|
|
|
|
};
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
return metadata;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private MetadataFile WriteEpisodeImages(Series series, EpisodeFile episodeFile, List<MetadataFile> existingMetadataFiles)
|
2014-01-22 05:22:09 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var screenshot = episodeFile.Episodes.Value.First().Images.SingleOrDefault(i => i.CoverType == MediaCoverTypes.Screenshot);
|
|
|
|
|
|
|
|
|
|
if (screenshot == null)
|
|
|
|
|
{
|
2014-03-13 20:12:42 +00:00
|
|
|
|
_logger.Debug("Episode screenshot not available");
|
2014-02-22 22:03:23 +00:00
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var filename = GetEpisodeImageFilename(episodeFile.Path);
|
|
|
|
|
var relativePath = DiskProviderBase.GetRelativePath(series.Path, filename);
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-04-08 19:14:35 +00:00
|
|
|
|
var existingMetadata = existingMetadataFiles.FirstOrDefault(c => c.Type == MetadataType.EpisodeImage &&
|
2014-02-22 22:03:23 +00:00
|
|
|
|
c.EpisodeFileId == episodeFile.Id);
|
|
|
|
|
|
|
|
|
|
if (existingMetadata != null)
|
|
|
|
|
{
|
|
|
|
|
var fullPath = Path.Combine(series.Path, existingMetadata.RelativePath);
|
|
|
|
|
if (!filename.PathEquals(fullPath))
|
|
|
|
|
{
|
|
|
|
|
_diskProvider.MoveFile(fullPath, filename);
|
|
|
|
|
existingMetadata.RelativePath = relativePath;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-01-22 05:22:09 +00:00
|
|
|
|
|
|
|
|
|
DownloadImage(series, screenshot.Url, filename);
|
2014-01-24 16:17:56 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
var metadata = existingMetadata ??
|
2014-02-19 04:51:37 +00:00
|
|
|
|
new MetadataFile
|
2014-01-24 16:17:56 +00:00
|
|
|
|
{
|
|
|
|
|
SeriesId = series.Id,
|
|
|
|
|
EpisodeFileId = episodeFile.Id,
|
|
|
|
|
Consumer = GetType().Name,
|
2014-02-19 04:51:37 +00:00
|
|
|
|
Type = MetadataType.EpisodeImage,
|
2014-01-27 00:09:44 +00:00
|
|
|
|
RelativePath = DiskProviderBase.GetRelativePath(series.Path, filename)
|
2014-01-24 16:17:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
return metadata;
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
2014-02-19 04:51:37 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private string GetEpisodeNfoFilename(string episodeFilePath)
|
2014-02-19 04:51:37 +00:00
|
|
|
|
{
|
2014-02-22 22:03:23 +00:00
|
|
|
|
return Path.ChangeExtension(episodeFilePath, "nfo");
|
|
|
|
|
}
|
2014-02-19 04:51:37 +00:00
|
|
|
|
|
2014-02-22 22:03:23 +00:00
|
|
|
|
private string GetEpisodeImageFilename(string episodeFilePath)
|
|
|
|
|
{
|
|
|
|
|
return Path.ChangeExtension(episodeFilePath, "").Trim('.') + "-thumb.jpg";
|
2014-02-19 04:51:37 +00:00
|
|
|
|
}
|
2014-01-22 05:22:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|