private Response SaveCouchPotato()
{
var couchPotatoSettings = this.Bind <CouchPotatoSettings>();
var valid = this.Validate(couchPotatoSettings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
var watcherSettings = WatcherSettings.GetSettings();
if (watcherSettings.Enabled)
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Cannot have Watcher and CouchPotato both enabled."
}));
}
couchPotatoSettings.ApiKey = couchPotatoSettings.ApiKey.Trim();
var result = CpService.SaveSettings(couchPotatoSettings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for CouchPotato!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
public WatcherViewModel(WatcherService service, WatcherSettings settings)
{
this.Service = service;
this.Settings = settings;
this.Settings.PropertyChanged += this.OnSettingsChanged;
this.ApplySettings();
}
private void DoWork(WatcherSettings watcher, double newPrice)
{
var message = new MimeMessage();
AppSettings.Current.MailSettings.Targets.ForEach(currentMailTarget =>
{
if (!string.IsNullOrEmpty(currentMailTarget))
{
message.From.Add(new MailboxAddress(currentMailTarget));
}
});
message.Subject = $"Change of price on item [{watcher.Name}]";
message.Body = new TextPart("plain")
{
Text = $@"Hello,
Price of item '{watcher.Name}' just changed from '{watcher.LastPrice}' to '{newPrice}').
Url : {watcher.Url}
Bye."
};
using (var client = new SmtpClient())
{
// Accept all SSL certificates (in case the server supports STARTTLS)
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(AppSettings.Current.MailSettings.HostName, AppSettings.Current.MailSettings.Port, AppSettings.Current.MailSettings.EnableSsl);
client.Authenticate(AppSettings.Current.MailSettings.Login, AppSettings.Current.MailSettings.Password);
client.Send(message);
client.Disconnect(true);
}
}
public static IObservable <FileSystemEventArgs> FileChanges(WatcherSettings watcherSettings)
{
return(Observable.Create <FileSystemEventArgs>(observer => {
var disp = new CompositeDisposable();
var watcher = new FileSystemWatcher(watcherSettings.Directory)
{
NotifyFilter = watcherSettings.NotifyFilters,
Filter = watcherSettings.SearchPattern,
IncludeSubdirectories = watcherSettings.SearchOption == SearchOption.AllDirectories
};
disp.Add(watcher);
disp.Add(Observable.Merge(
Observable.FromEventPattern <RenamedEventHandler, FileSystemEventArgs>(x => watcher.Renamed += x,
x => watcher.Renamed -= x),
Observable.FromEventPattern <FileSystemEventHandler, FileSystemEventArgs>(x => watcher.Changed += x,
x => watcher.Changed -= x),
Observable.FromEventPattern <FileSystemEventHandler, FileSystemEventArgs>(x => watcher.Created += x,
x => watcher.Created -= x),
Observable.FromEventPattern <FileSystemEventHandler, FileSystemEventArgs>(x => watcher.Deleted += x,
x => watcher.Deleted -= x))
.Select(x => x.EventArgs)
.Synchronize(observer)
.Subscribe(observer));
watcher.EnableRaisingEvents = true;
return disp;
}).Publish().RefCount());
}
public async Task <MovieSenderResult> Send(RequestedModel model, string qualityId = "")
{
var cpSettings = await CouchPotatoSettings.GetSettingsAsync();
var watcherSettings = await WatcherSettings.GetSettingsAsync();
var radarrSettings = await RadarrSettings.GetSettingsAsync();
if (cpSettings.Enabled)
{
return(SendToCp(model, cpSettings, string.IsNullOrEmpty(qualityId) ? cpSettings.ProfileId : qualityId));
}
if (watcherSettings.Enabled)
{
return(SendToWatcher(model, watcherSettings));
}
if (radarrSettings.Enabled)
{
return(SendToRadarr(model, radarrSettings));
}
return(new MovieSenderResult {
Result = false, MovieSendingEnabled = false
});
}
private async Task <Response> SaveWatcher()
{
var settings = this.Bind <WatcherSettings>();
var valid = this.Validate(settings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
var cpSettings = await CpSettings.GetSettingsAsync().ConfigureAwait(false);
if (cpSettings.Enabled)
{
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Cannot have Watcher and CouchPotato both enabled."
}));
}
settings.ApiKey = settings.ApiKey.Trim();
var result = await WatcherSettings.SaveSettingsAsync(settings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for Watcher!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
public void Queued()
{
Log.Trace("Getting the settings");
var watcherSettings = WatcherSettings.GetSettings();
Job.SetRunning(true, JobNames.WatcherCacher);
try
{
if (watcherSettings.Enabled)
{
var movies = WatcherApi.ListMovies(watcherSettings.ApiKey, watcherSettings.FullUri);
if (movies.Error)
{
Log.Error("Error when trying to get Watchers movies");
Log.Error(movies.ErrorMessage);
}
var wantedMovies =
movies?.Movies?.Where(x => x.status.Equals("Wanted", StringComparison.CurrentCultureIgnoreCase));
if (wantedMovies != null && wantedMovies.Any())
{
Cache.Set(CacheKeys.WatcherQueued, movies.Movies.Select(x => x.imdbid).ToArray(), CacheKeys.TimeFrameMinutes.SchedulerCaching);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
finally
{
Job.Record(JobNames.WatcherCacher);
Job.SetRunning(false, JobNames.WatcherCacher);
}
}
public void Execute(PerformContext context, WatcherSettings watcher, double newPrice)
{
lock (Lock)
{
_context = context;
DoWork(watcher, newPrice);
};
}
public static IEnumerable <FileReference> GetCurrentFiles(WatcherSettings watcherSettings)
{
return(Directory
.GetFiles(watcherSettings.Directory, watcherSettings.SearchPattern, watcherSettings.SearchOption)
.Select(fullPath => new FileReference {
FullPath = fullPath
}));
}
public Watcher(
string dir,
Action <string> directoryCreated,
Action <string> directoryDeleted,
Action <string> fileCreated,
Action <string> fileChanged,
Action <string> fileDeleted)
{
_dir = dir;
_cache = new Cache(_dir, () => _exit);
_settings = SettingsReader.GetSettings();
_directoryCreated = directoryCreated;
_directoryDeleted = directoryDeleted;
_fileCreated = fileCreated;
_fileChanged = fileChanged;
_fileDeleted = fileDeleted;
}
public static IObservable <IList <FileReference> > TrackDirectory(WatcherSettings watcherSettings)
{
return(Observable.Create <IList <FileReference> >(observer => {
var initialFiles = GetCurrentFiles(watcherSettings).ToImmutableList();
var disposable = FileChanges(watcherSettings)
.Scan(initialFiles, (fileList, fileEvent) => {
var file = new FileReference {
FullPath = fileEvent.FullPath
};
if (fileEvent.ChangeType == WatcherChangeTypes.Created)
{
fileList = fileList.Add(file);
}
else if (fileEvent.ChangeType == WatcherChangeTypes.Renamed)
{
var renameEvent = (RenamedEventArgs)fileEvent;
var oldFile = new FileReference {
FullPath = renameEvent.OldFullPath
};
fileList = fileList.Remove(oldFile);
fileList = fileList.Add(file);
}
else if (fileEvent.ChangeType == WatcherChangeTypes.Deleted)
{
fileList = fileList.Remove(file);
}
fileList = fileList.Sort();
return fileList;
})
.Select(fileList => fileList as IList <FileReference>)
.Synchronize(observer)
.Subscribe(observer);
observer.OnNext(initialFiles);
return disposable;
}).Replay(1).RefCount());
}
private async Task <Response> SaveRadarr()
{
var radarrSettings = this.Bind <RadarrSettings>();
//Check Watcher and CP make sure they are not enabled
var watcher = await WatcherSettings.GetSettingsAsync();
if (watcher.Enabled)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Watcher is enabled, we cannot enable Watcher and Radarr"
}));
}
var cp = await CpSettings.GetSettingsAsync();
if (cp.Enabled)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "CouchPotato is enabled, we cannot enable Watcher and CouchPotato"
}));
}
var valid = this.Validate(radarrSettings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
radarrSettings.ApiKey = radarrSettings.ApiKey.Trim();
var result = await RadarrSettings.SaveSettingsAsync(radarrSettings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for Radarr!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
private MovieSenderResult SendToWatcher(RequestedModel model, WatcherSettings settings)
{
var result = WatcherApi.AddMovie(model.ImdbId, settings.ApiKey, settings.FullUri);
if (result.Error)
{
Log.Error(result.ErrorMessage);
return(new MovieSenderResult {
Result = false
});
}
if (result.response)
{
return(new MovieSenderResult {
Result = true, MovieSendingEnabled = true
});
}
Log.Error(result.message);
return(new MovieSenderResult {
Result = false, MovieSendingEnabled = true
});
}
// we do not want to set here...
public string[] QueuedIds()
{
try
{
var watcherSettings = WatcherSettings.GetSettings();
if (watcherSettings.Enabled)
{
var movies = Cache.Get <string[]>(CacheKeys.WatcherQueued);
if (movies != null)
{
return(movies);
}
return(new string[] {});
}
}
catch (Exception e)
{
Log.Error(e);
return(new string[] { });
}
return(new string[] {});
}
private async Task <Negotiator> Watcher()
{
var settings = await WatcherSettings.GetSettingsAsync();
return(View["Watcher", settings]);
}
