public override void OnDownload(DownloadMessage message)
{
const string header = "Radarr - Downloaded";
Notify(Settings, header, message.Message);
UpdateAndCleanMovie(message.Movie, message.OldMovieFiles.Any());
}
private void CheckForNewEvents()
{
Task.Run(async() =>
{
var downloadedEvents = await eventDownloader.GetMetagameEventsAsync();
var notifService = DependencyService.Resolve <INotificationService>();
DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
//this should not be on the start command unless we're implementing the time to wait BETWEEN the calls.
var notifiableEvent = CheckForWantedEvents(downloadedEvents);
//download the events to a json
if (notifiableEvent.event_type != "void")
{
//notify the user
var message = new DownloadMessage
{
NotifyingEvent = notifiableEvent
};
//MessagingCenter.Send(message, "Download");
string theTime = epoch.AddSeconds((double)notifiableEvent.timestamp).ToLocalTime().ToLongTimeString();
//await notifService.NotifyAsync("Alert started!", $"{notifiableEvent.eventName} on IMPLEMENT CONTINENT NAME at {theTime}",2);
await notifService.NotifyBigAsync("Alert started!", $"{notifiableEvent.eventName}", notifiableEvent, theTime);
}
});
}
public override void OnDownload(DownloadMessage message)
{
var movie = message.Movie;
var movieFile = message.MovieFile;
var sourcePath = message.SourcePath;
var environmentVariables = new StringDictionary();
environmentVariables.Add("Radarr_EventType", "Download");
environmentVariables.Add("Radarr_IsUpgrade", message.OldMovieFiles.Any().ToString());
environmentVariables.Add("Radarr_Movie_Id", movie.Id.ToString());
environmentVariables.Add("Radarr_Movie_Title", movie.Title);
environmentVariables.Add("Radarr_Movie_Year", movie.Year.ToString());
environmentVariables.Add("Radarr_Movie_Path", movie.Path);
environmentVariables.Add("Radarr_Movie_ImdbId", movie.ImdbId ?? string.Empty);
environmentVariables.Add("Radarr_Movie_TmdbId", movie.TmdbId.ToString());
environmentVariables.Add("Radarr_Movie_In_Cinemas_Date", movie.InCinemas.ToString() ?? string.Empty);
environmentVariables.Add("Radarr_Movie_Physical_Release_Date", movie.PhysicalRelease.ToString() ?? string.Empty);
environmentVariables.Add("Radarr_MovieFile_Id", movieFile.Id.ToString());
environmentVariables.Add("Radarr_MovieFile_RelativePath", movieFile.RelativePath);
environmentVariables.Add("Radarr_MovieFile_Path", Path.Combine(movie.Path, movieFile.RelativePath));
environmentVariables.Add("Radarr_MovieFile_Quality", movieFile.Quality.Quality.Name);
environmentVariables.Add("Radarr_MovieFile_QualityVersion", movieFile.Quality.Revision.Version.ToString());
environmentVariables.Add("Radarr_MovieFile_ReleaseGroup", movieFile.ReleaseGroup ?? string.Empty);
environmentVariables.Add("Radarr_MovieFile_SceneName", movieFile.SceneName ?? string.Empty);
environmentVariables.Add("Radarr_MovieFile_SourcePath", sourcePath);
environmentVariables.Add("Radarr_MovieFile_SourceFolder", Path.GetDirectoryName(sourcePath));
environmentVariables.Add("Radarr_Download_Id", message.DownloadId ?? string.Empty);
if (message.OldMovieFiles.Any())
{
environmentVariables.Add("Radarr_DeletedRelativePaths", string.Join("|", message.OldMovieFiles.Select(e => e.RelativePath)));
environmentVariables.Add("Radarr_DeletedPaths", string.Join("|", message.OldMovieFiles.Select(e => Path.Combine(movie.Path, e.RelativePath))));
}
ExecuteScript(environmentVariables);
}
/// <summary>
/// Function to receive download message
/// </summary>
/// <param name="downloadMessage">The message which has to be received</param>
private void ReceivedDownloadMessage(DownloadMessage downloadMessage)
{
if (downloadMessage.type.Equals(TypeCode.REQUEST))
{
string path = _path + @".hidden\" + downloadMessage.fromUuid + @"\" +
downloadMessage.fullFileName + @"\" + downloadMessage.filehash;
if (downloadMessage.statusCode == StatusCode.OK)
{
if (File.Exists(path))
{
downloadMessage.CreateReply();
downloadMessage.statusCode = StatusCode.ACCEPTED;
downloadMessage.Send(downloadMessage.port);
Console.WriteLine("Response send");
}
else
{
Console.WriteLine("File not found");
downloadMessage.CreateReply();
downloadMessage.statusCode = StatusCode.FILE_NOT_FOUND;
downloadMessage.Send(downloadMessage.port);
}
}
else if (downloadMessage.statusCode.Equals(StatusCode.ACCEPTED))
{
var sender = new ChunkSender(downloadMessage.fromIp, downloadMessage.port);
sender.Send(path);
DiskHelper.ConsoleWrite("File send " + downloadMessage.filehash);
}
}
}
public override void OnDownload(DownloadMessage message)
{
var series = message.Series;
var episodeFile = message.EpisodeFile;
var sourcePath = message.SourcePath;
var environmentVariables = new StringDictionary();
environmentVariables.Add("Sonarr_EventType", "Download");
environmentVariables.Add("Sonarr_Series_Id", series.Id.ToString());
environmentVariables.Add("Sonarr_Series_Title", series.Title);
environmentVariables.Add("Sonarr_Series_Path", series.Path);
environmentVariables.Add("Sonarr_Series_TvdbId", series.TvdbId.ToString());
environmentVariables.Add("Sonarr_Series_Type", series.SeriesType.ToString());
environmentVariables.Add("Sonarr_EpisodeFile_Id", episodeFile.Id.ToString());
environmentVariables.Add("Sonarr_EpisodeFile_RelativePath", episodeFile.RelativePath);
environmentVariables.Add("Sonarr_EpisodeFile_Path", Path.Combine(series.Path, episodeFile.RelativePath));
environmentVariables.Add("Sonarr_EpisodeFile_SeasonNumber", episodeFile.SeasonNumber.ToString());
environmentVariables.Add("Sonarr_EpisodeFile_EpisodeNumbers", string.Join(",", episodeFile.Episodes.Value.Select(e => e.EpisodeNumber)));
environmentVariables.Add("Sonarr_EpisodeFile_EpisodeAirDates", string.Join(",", episodeFile.Episodes.Value.Select(e => e.AirDate)));
environmentVariables.Add("Sonarr_EpisodeFile_EpisodeAirDatesUtc", string.Join(",", episodeFile.Episodes.Value.Select(e => e.AirDateUtc)));
environmentVariables.Add("Sonarr_EpisodeFile_Quality", episodeFile.Quality.Quality.Name);
environmentVariables.Add("Sonarr_EpisodeFile_QualityVersion", episodeFile.Quality.Revision.Version.ToString());
environmentVariables.Add("Sonarr_EpisodeFile_ReleaseGroup", episodeFile.ReleaseGroup ?? string.Empty);
environmentVariables.Add("Sonarr_EpisodeFile_SceneName", episodeFile.SceneName ?? string.Empty);
environmentVariables.Add("Sonarr_EpisodeFile_SourcePath", sourcePath);
environmentVariables.Add("Sonarr_EpisodeFile_SourceFolder", Path.GetDirectoryName(sourcePath));
ExecuteScript(environmentVariables);
}
private async Task DownloadPodcastFileAsync(RssEpisode episode)
{
try
{
episode.PlayPauseDownloadIcon = IconFont.Clock;
//save download status to the database
var resultSave = await DataStore.SaveEpisodeItemAsync(episode, true); //returns the number of items changed
if (resultSave != 1)
{
Debug.WriteLine("DownloadService.DownloadPodcastFile Could not Update episode");
}
//download the file to storage
var filePath = FileHelper.GetPodcastPath(episode.PodcastFileName);
var message = new DownloadMessage
{
Id = episode.Id.Value, //needed to update RssEpisode when done
Url = episode.EnclosureLink,
FilePath = filePath,
QueueType = QueueType.PodcastFile
};
MessagingCenter.Send(message, "Download"); //goes to Android project Service, returns thru DownloadFinishedMessage
}
catch (Exception ex)
{
Debug.WriteLine("DownloadService.DownloadPodcastFile Error " + ex.Message);
}
}
public DownloadProgressViewModel(string url)
{
Title = "Downloading File";
var file = new DownloadMessage
{
Url = url
};
Message = string.Format("Downloading file from {0}", url);
MessagingCenter.Send(file, "Download");
MessagingCenter.Unsubscribe <DownloadProgressMessage>(Application.Current, "DownloadProgressMessage");
MessagingCenter.Subscribe <DownloadProgressMessage>(Application.Current, "DownloadProgressMessage", message =>
{
Device.BeginInvokeOnMainThread(() =>
{
Percentage = message.Percentage;
});
});
MessagingCenter.Unsubscribe <DownloadFinishedMessage>(Application.Current, "DownloadFinishedMessage");
MessagingCenter.Subscribe <DownloadFinishedMessage>(Application.Current, "DownloadFinishedMessage", message =>
{
Device.BeginInvokeOnMainThread(async() =>
{
var msj = string.Format("The file was saved in {0}", message.FilePath);
await Application.Current.MainPage.DisplayAlert("Message", msj, "OK");
await Application.Current.MainPage.Navigation.PopModalAsync(true);
});
});
}
public override void OnDownload(DownloadMessage message)
{
const string header = "Sonarr - Downloaded";
Notify(Settings, header, message.Message);
UpdateAndClean(message.Series, message.OldFiles.Any());
}
public override void OnDownload(DownloadMessage message)
{
var movieFile = message.MovieFile;
var payload = new WebhookImportPayload
{
EventType = WebhookEventType.Download,
Movie = new WebhookMovie(message.Movie),
RemoteMovie = new WebhookRemoteMovie(message.Movie),
MovieFile = new WebhookMovieFile(movieFile),
IsUpgrade = message.OldMovieFiles.Any(),
DownloadClient = message.DownloadClientInfo?.Name,
DownloadClientType = message.DownloadClientInfo?.Type,
DownloadId = message.DownloadId
};
if (message.OldMovieFiles.Any())
{
payload.DeletedFiles = message.OldMovieFiles.ConvertAll(x =>
new WebhookMovieFile(x)
{
Path = Path.Combine(message.Movie.Path, x.RelativePath)
});
}
_proxy.SendWebhook(payload, Settings);
}
public override void OnDownload(DownloadMessage message)
{
var movie = message.Movie;
var movieFile = message.MovieFile;
var sourcePath = message.SourcePath;
var environmentVariables = new StringDictionary();
environmentVariables.Add("Radarr_EventType", "Download");
environmentVariables.Add("Radarr_Movie_Id", movie.Id.ToString());
environmentVariables.Add("Radarr_Movie_Title", movie.Title);
environmentVariables.Add("Radarr_Movie_Path", movie.Path);
environmentVariables.Add("Radarr_Movie_ImdbId", movie.ImdbId);
environmentVariables.Add("Radarr_Movie_TmdbId", movie.TmdbId.ToString());
environmentVariables.Add("Radarr_MovieFile_Id", movieFile.Id.ToString());
environmentVariables.Add("Radarr_MovieFile_RelativePath", movieFile.RelativePath);
environmentVariables.Add("Radarr_MovieFile_Path", Path.Combine(movie.Path, movieFile.RelativePath));
environmentVariables.Add("Radarr_MovieFile_Quality", movieFile.Quality.Quality.Name);
environmentVariables.Add("Radarr_MovieFile_QualityVersion", movieFile.Quality.Revision.Version.ToString());
environmentVariables.Add("Radarr_MovieFile_ReleaseGroup", movieFile.ReleaseGroup ?? string.Empty);
environmentVariables.Add("Radarr_MovieFile_SceneName", movieFile.SceneName ?? string.Empty);
environmentVariables.Add("Radarr_MovieFile_SourcePath", sourcePath);
environmentVariables.Add("Radarr_MovieFile_SourceFolder", Path.GetDirectoryName(sourcePath));
ExecuteScript(environmentVariables);
}
public override void OnDownload(DownloadMessage message)
{
const string subject = "NzbDrone [TV] - Downloaded";
var body = String.Format("{0} Downloaded and sorted.", message.Message);
_emailService.SendEmail(Settings, subject, body);
}
public override void OnDownload(DownloadMessage message)
{
var episodeFile = message.EpisodeFile;
var payload = new WebhookImportPayload
{
EventType = WebhookEventType.Download,
Series = new WebhookSeries(message.Series),
Episodes = episodeFile.Episodes.Value.ConvertAll(x => new WebhookEpisode(x)),
EpisodeFile = new WebhookEpisodeFile(episodeFile),
IsUpgrade = message.OldFiles.Any(),
DownloadClient = message.DownloadClient,
DownloadId = message.DownloadId
};
if (message.OldFiles.Any())
{
payload.DeletedFiles = message.OldFiles.ConvertAll(x => new WebhookEpisodeFile(x)
{
Path = Path.Combine(message.Series.Path,
x.RelativePath)
}
);
}
_proxy.SendWebhook(payload, Settings);
}
void Download(object sender, EventArgs e)
{
this.catImage.Source = null;
var message = new DownloadMessage {
Url = "https://xamarinuniversity.blob.core.windows.net/ios210/huge_monkey.png"
};
MessagingCenter.Send(message, "Download");
}
protected override void ProcessRecord()
{
LogErrors(() =>
{
if (!CheckSessionCanDoInteractiveAction())
{
return;
}
AssertDefaultSize(700, 140);
DownloadMessage message = null;
if (Item != null)
{
if (!Item.Paths.IsMediaItem)
{
WriteVerbose($"Skipping item {Item.ID} because it is not a media item.");
return;
}
if (Item.InheritsFrom(TemplateIDs.MediaFolder))
{
WriteVerbose($"Skipping item {Item.ID} because it inherits from Media Folder.");
return;
}
message = new DownloadMessage(Item);
}
else if (!string.IsNullOrEmpty(Path))
{
var file = FileUtil.MapPath(Path);
if (!File.Exists(file))
{
PutMessage(
new AlertMessage($"You cannot download:\n{Path}\n\n The file could not be found."));
return;
}
message = new DownloadMessage(file);
}
if (message != null)
{
message.NoDialog = NoDialog;
message.Message = Message;
message.Title = Title;
message.ShowFullPath = ShowFullPath;
message.Width = Width == 0 ? "600" : WidthString;
message.Height = Height == 0 ? "200" : HeightString;
PutMessage(message);
var result = message.GetResult().ToString();
WriteObject(result);
}
});
}
public override void OnDownload(DownloadMessage message)
{
const string header = "NzbDrone [TV] - Downloaded";
if (Settings.Notify)
{
_xbmcProvider.Notify(Settings, header, message.Message);
}
UpdateAndClean(message.Series, message.OldFiles.Any());
}
public override void OnDownload(DownloadMessage message)
{
if (message.OldMovieFiles.Any())
{
_proxy.SendNotification(MOVIE_UPGRADED_TITLE, message.Message, Settings);
}
else
{
_proxy.SendNotification(MOVIE_DOWNLOADED_TITLE, message.Message, Settings);
}
}
public override void OnDownload(DownloadMessage message)
{
if (Settings.Notify)
{
_mediaBrowserService.Notify(Settings, EPISODE_DOWNLOADED_TITLE_BRANDED, message.Message);
}
if (Settings.UpdateLibrary)
{
_mediaBrowserService.Update(Settings, message.Series, "Created");
}
}
internal HttpMultiThreadDownloader createMTDO(DownloadMessage MSG)
{
var finalFolder = Properties.Settings.Default.SaveFolder;
var tempFolder = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
tempFolder = Path.Combine(tempFolder, "AltoDownloadAccelerator");
var dorg = new HttpMultiThreadDownloader(MSG.Url, finalFolder, "", tempFolder, Properties.Settings.Default.NofThread);
dorg.Id = Guid.NewGuid().ToString("N");
dorg.DownloadRequestMessage = MSG;
return(dorg);
}
/// <summary>
/// Handler for a resource download request from server (your DownloadVersion mismatches)
/// </summary>
/// <param name="Message"></param>
protected override void HandleDownloadMessage(DownloadMessage Message)
{
base.HandleDownloadMessage(Message);
// tell user about mismatching resources version
MessageBox.Show(RESVERSIONMISMATCH);
// close connection, we're not going to download the proposed new resource files
ServerConnection.Disconnect();
// reset logincontrol
MainForm.LoginControl.ConnectedState = false;
}
public void SendMessage(DownloadMessage msg)
{
if (tracker == null)
{
// Attempt to create a tracker
tracker = new SingleInstanceTracker("SingleInstanceSample", new SingleInstanceEnforcerRetriever(GetSingleInstanceEnforcer));
}
if (msg != null)
{
var json = JsonConvert.SerializeObject(msg);
tracker.SendMessageToFirstInstance(json);
}
}
public override void OnDownload(DownloadMessage message)
{
const string title = "Radarr - Movie Downloaded";
if (Settings.Notify)
{
_mediaBrowserService.Notify(Settings, title, message.Message);
}
if (Settings.UpdateLibrary)
{
_mediaBrowserService.UpdateMovies(Settings, message.Movie, "Created");
}
}
/// <summary>
/// Adds a new download task
/// </summary>
/// <param name="msg"></param>
protected override void NewDownload(DownloadMessage msg)
{
try
{
DownloadingItems.Add(new DownloadItemView {
DataContext = new DownloadItemViewModel(msg.Url)
});
}
catch (Exception ex)
{
DialogService.ShowMessageBox(ex.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="Message"></param>
protected override void HandleDownloadMessage(DownloadMessage Message)
{
base.HandleDownloadMessage(Message);
// server proposed different resources version
// adjust resourceversion in configuration.xml
// close connection and exit
ServerConnection.Disconnect();
IsRunning = false;
Log("ERROR", LOG_WRONGRESVERSION);
Thread.Sleep(SLEEPAFTERERROR);
}
public override void OnDownload(DownloadMessage message)
{
const string title = "Sonarr - Downloaded";
if (Settings.Notify)
{
_mediaBrowserService.Notify(Settings, title, message.Message);
}
if (Settings.UpdateLibrary)
{
_mediaBrowserService.Update(Settings, message.Series);
}
}
public override void OnDownload(DownloadMessage message)
{
var movieFile = message.MovieFile;
var payload = new WebhookImportPayload
{
EventType = "Download",
Movie = new WebhookMovie(message.Movie),
RemoteMovie = new WebhookRemoteMovie(message.Movie),
MovieFile = new WebhookMovieFile(movieFile),
IsUpgrade = message.OldMovieFiles.Any()
};
_proxy.SendWebhook(payload, Settings);
}
void showForm(DownloaderForm f, DownloadMessage req, bool directStart)
{
if (f != null && f.Visible)
{
return;
}
else
{
removeForm(req.FileName, req.Url);
var a = new DownloaderForm(f.dorg, directStart);
a.FormClosed += a_FormClosed;
formlist.Add(a);
a.Shown += a_Shown;
a.Show();
}
}
public override void OnDownload(DownloadMessage message)
{
var embeds = new List <Embed>
{
new Embed
{
Description = message.Message,
Title = message.Series.Title,
Text = message.Message,
Color = (int)DiscordColors.Success
}
};
var payload = CreatePayload($"Imported: {message.Message}", embeds);
_proxy.SendPayload(payload, Settings);
}
public override void OnDownload(DownloadMessage message)
{
var attachments = new List <Attachment>
{
new Attachment
{
Fallback = message.Message,
Title = message.Movie.Title,
Text = message.Message,
Color = "good"
}
};
var payload = CreatePayload($"Imported: {message.Message}", attachments);
_proxy.SendPayload(payload, Settings);
}
public override void OnDownload(DownloadMessage message)
{
if (Settings.UpdateLibrary)
{
foreach (var oldFile in message.OldMovieFiles)
{
var fullPath = Path.Combine(message.Movie.Path, oldFile.RelativePath);
_indexerProxy.DeleteFile(fullPath);
}
{
var fullPath = Path.Combine(message.Movie.Path, message.MovieFile.RelativePath);
_indexerProxy.AddFile(fullPath);
}
}
}
protected override void ProcessRecord()
{
LogErrors(() =>
{
if (!CheckSessionCanDoInteractiveAction())
{
return;
}
AssertDefaultSize(700, 140);
DownloadMessage message = null;
if (Item != null)
{
message = new DownloadMessage(Item);
}
else if (!string.IsNullOrEmpty(Path))
{
var file = FileUtil.MapPath(Path);
if (!File.Exists(file))
{
PutMessage(
new AlertMessage("You cannot download:\n" + Path + "\n\n The file could not be found."));
return;
}
message = new DownloadMessage(file);
}
if (message != null)
{
message.NoDialog = NoDialog;
message.Message = Message;
message.Title = Title;
message.ShowFullPath = ShowFullPath;
message.Width = Width == 0 ? "600" : WidthString;
message.Height = Height == 0 ? "200" : HeightString;
PutMessage(message);
var result = message.GetResult().ToString();
WriteObject(result);
}
});
}
private Task<bool> RunSyncItem(Manifest.SyncItem f,
bool verify, bool simulate,
DownloadProgressChanged dpc, DownloadEnd de, DownloadMessage dm,
CancellationTokenSource cts,
string overrideDestination = null)
{
switch (f.type)
{
case "rsync":
RSyncDownloader dd = new RSyncDownloader(this);
dd.appPath = AppPath;
dd.tmpPath = TmpPath;
dd.VerifyChecksums = verify;
dd.Simulate = simulate;
return dd.Download(LatestManifest.rsyncUrl + "/" + f.name, f, RootPath,
dpc, de, dm, cts, overrideDestination);
case "delete":
return Task<bool>.Run(() =>
{
if (f.name.EndsWith("/") && Directory.Exists(RootPath + "/" + f.name)) {
dm.Invoke("Deleting directory " + f.name);
Directory.Delete(RootPath + "/" + f.name, true);
} else if (File.Exists(RootPath + "/" + f.name)) {
dm.Invoke("Deleting file " + f.name);
File.Delete(RootPath + "/" + f.name);
}
return true;
});
default:
return null;
}
}
