/// <summary>
/// This function download a resource string, it also copy content on disk on a
/// local copy of the resource file. If the configuration service is down or it
/// does not answer correctly the client does not touch file. This imply that if
/// the client was able to download the file the first time, if the configuration
/// service went down the local version still remain the same.
/// </summary>
/// <param name="resourceName">Name of the resource you want to download</param>
/// <param name="localResourceFileName">Name of the local file, it can be omitted and the
/// client will use the same value of <paramref name="resourceName"/></param>
/// <param name="monitorForChange">true if you want configuration client to poll configuration service
/// for change and update local file accordingly.</param>
/// <returns>true if the configuration service respond correctly, false otherwise.</returns>
public Boolean DownloadResource(
string resourceName,
String localResourceFileName = null,
Boolean monitorForChange = false)
{
String valueOfFile = GetResource(resourceName);
if (String.IsNullOrEmpty(valueOfFile))
{
this.LogError("Configuration server return null content for resource " + resourceName, null);
return(false);
}
var savedFileName = Path.Combine(_environment.GetCurrentPath(), localResourceFileName ?? resourceName);
_environment.SaveFile(savedFileName, valueOfFile, false);
if (monitorForChange)
{
var monitoredFile = new MonitoredFile()
{
Content = valueOfFile,
LocalFileName = savedFileName,
};
_resourceToMonitor.AddOrUpdate(resourceName, monitoredFile, (r, h) => monitoredFile);
}
return(true);
}
TrackedFile GetTrackedFile(EpisodeTrackerDBContext db, MonitoredFile mon)
{
TrackedFile file = null;
if(mon.TrackedFileID.HasValue) return db.TrackedFile.Single(f => f.ID == mon.TrackedFileID.Value);
if(file == null) {
file = db.TrackedFile.SingleOrDefault(f => f.FileName == mon.FileName);
}
if(file == null && mon.Episodes != null) {
var episodeIDs = mon.Episodes.Select(e => e.ID);
file = db.TrackedFile
.FirstOrDefault(f => f.Episodes.Any() && f.Episodes.All(te => episodeIDs.Contains(te.Episode.ID)));
}
if(file == null && mon.TvMatch != null) {
file = db.TrackedFile
.FirstOrDefault(f =>
f.Episodes.Any()
&& f.Episodes.All(te =>
te.Episode.Series.Name == mon.TvMatch.Name
&& te.Episode.Season == mon.TvMatch.Season
&& (
!mon.TvMatch.ToEpisode.HasValue && te.Episode.Number == mon.TvMatch.Episode
|| mon.TvMatch.ToEpisode.HasValue && te.Episode.Number >= mon.TvMatch.Episode && te.Episode.Number <= mon.TvMatch.ToEpisode.Value
)
)
);
}
if(file != null) mon.TrackedFileID = file.ID;
return file;
}
TrackedFile NewTrackedFile(EpisodeTrackerDBContext db, MonitoredFile mon)
{
var tracked = new TrackedFile {
FileName = mon.FileName,
Start = DateTime.Now,
Stop = DateTime.Now,
LengthSeconds = mon.Length.TotalSeconds
};
db.TrackedFile.Add(tracked);
if(mon.TvMatch != null) {
var seriesQuery = db.Series.Include(s => s.Episodes);
Series series = null;
if(mon.Series != null) {
series = db.Series.SingleOrDefault(s => s.ID == mon.Series.ID);
} else {
// Series is only null when no TVDB match was found
series = seriesQuery.SingleOrDefault(s => s.Name == mon.TvMatch.Name);
}
if(series == null) {
series = new Series {
Name = mon.TvMatch.Name,
Added = DateTime.Now
};
db.Series.Add(series);
}
IEnumerable<Episode> episodes = null;
if(mon.Episodes != null) {
var ids = mon.Episodes.Select(e => e.ID);
episodes = series.Episodes
.Where(ep => ids.Contains(ep.ID));
foreach(var ep in episodes) {
tracked.Episodes.Add(new TrackedEpisode {
Episode = ep,
Added = DateTime.Now,
Updated = DateTime.Now
});
}
} else {
// Check for loose reference
episodes = series.Episodes
.Where(ep =>
ep.Season == mon.TvMatch.Season
&& (
!mon.TvMatch.ToEpisode.HasValue && ep.Number == mon.TvMatch.Episode
|| mon.TvMatch.ToEpisode.HasValue && ep.Number >= mon.TvMatch.Episode && ep.Number <= mon.TvMatch.ToEpisode.Value
)
);
for(var i = mon.TvMatch.Episode; i < (mon.TvMatch.ToEpisode ?? mon.TvMatch.Episode); i++) {
var episode = series.Episodes.SingleOrDefault(ep => ep.Season == mon.TvMatch.Season && ep.Number == i);
if(episode == null) {
episode = new Episode {
Season = mon.TvMatch.Season ?? 0,
Number = i,
Added = DateTime.Now
};
series.Episodes.Add(episode);
}
episode.Updated = DateTime.Now;
tracked.Episodes.Add(new TrackedEpisode {
Episode = episode,
Added = DateTime.Now,
Updated = DateTime.Now
});
}
series.Updated = DateTime.Now;
}
mon.Series = series;
mon.Episodes = tracked.Episodes.Select(te => te.Episode);
}
db.SaveChanges();
return tracked;
}
void CheckUnmonitoredFile(string fileName)
{
Logger.Debug("File is not monitored: " + fileName);
var mon = new MonitoredFile {
FileName = fileName,
Start = DateTime.Now
};
using(var info = new MediaInfo(fileName)) {
mon.Length = info.Length;
}
var name = Path.GetFileName(fileName);
var match = new TvMatcher().Match(name);
if(match != null) {
Logger.Debug("Found episode info: " + match.ToString());
mon.TvMatch = match;
// Try and look it up
// TODO: movies
Series series;
using(var db = new EpisodeTrackerDBContext()) {
series = db.Series.SingleOrDefault(s => s.Name == match.Name || s.Aliases.Any(a => a.Name == match.Name));
int? tvdbid = null;
if(series == null) {
var results = new TVDBRequest().Search(match.Name);
var first = results.FirstOrDefault();
if(first != null) {
Logger.Debug("Found TVDB result: " + first.Name);
series = db.Series.SingleOrDefault(s => s.TVDBID == first.ID || s.Name == first.Name || s.Aliases.Any(a => a.Name == first.Name));
tvdbid = first.ID;
}
}else {
tvdbid = series.TVDBID;
}
if(tvdbid.HasValue) {
if(series == null || series.Updated <= DateTime.Now.AddDays(-7)) {
var syncer = new TVDBSeriesSyncer {
TVDBID = tvdbid.Value,
Name = match.Name,
DownloadBannersAsync = true
};
syncer.Sync();
}
// Pull out series again as it might have been updated
series = db.Series
.Include(s => s.Episodes)
.Single(s => s.TVDBID == tvdbid.Value);
mon.Series = series;
if(match.Season.HasValue) {
var eps = series.Episodes.Where(ep => ep.Season == match.Season.Value);
if(match.ToEpisode.HasValue) {
mon.Episodes = eps.Where(ep => ep.Number >= match.Episode && ep.Number <= match.ToEpisode.Value);
} else {
mon.Episodes = eps.Where(ep => ep.Number == match.Episode);
}
} else {
mon.Episodes = series.Episodes.Where(ep => ep.AbsoluteNumber == match.Episode);
}
if(mon.Episodes != null) {
Logger.Debug("Found TVDB episodes: " + String.Join(" + ", mon.Episodes.Select(e => e.Name)));
}
}
}
}
monitored.Add(mon);
}
void CheckMonitoredFile(MonitoredFile mon)
{
Logger.Trace("File is monitored");
if(!mon.Watched) {
using(var db = new EpisodeTrackerDBContext()) {
Logger.Trace("Seconds since started monitoring: " + DateTime.Now.Subtract(mon.Start).TotalSeconds);
// check if it's been monitored for a while before doing anything with file
if(mon.Start <= DateTime.Now.AddMinutes(-.0)) {
var tracked = GetTrackedFile(db, mon);
if(!mon.Tracking) {
Logger.Debug("Begin tracking file: " + mon.FileName);
if(tracked == null) {
Logger.Debug("Recording file/episode as tracked");
tracked = NewTrackedFile(db, mon);
} else {
Logger.Debug("This file has been tracked before");
mon.PreviousTrackedSeconds = tracked.TrackedSeconds;
}
mon.Tracking = true;
Logger.Info("Tracking file: " + mon.FileName);
if(FileAdded != null) {
FileAdded(this, new MonitoredFileEventArgs {
Filename = mon.FileName,
FriendlyName = mon.FriendlyName
});
}
}
tracked.TrackedSeconds = (int)DateTime.Now.Subtract(mon.Start).TotalSeconds + mon.PreviousTrackedSeconds;
tracked.Stop = DateTime.Now;
foreach(var te in tracked.Episodes) te.Updated = DateTime.Now;
db.SaveChanges();
}
}
}
}
protected override LocalisableString GenerateItemText(MonitoredFile <T> item)
{
return(item.Name);
}
protected override LocalisableString GenerateItemText(MonitoredFile <Theme> item) => item.Name.Humanize(LetterCasing.Title);
public void Setup() => _file = new MonitoredFile();
