Webhook improvements

New: Include Path/Relative Path for on download Webhooks
New: IsUpgrade flag for on download Webhooks

src/NzbDrone.Core/Notifications/Webhook/Webhook.cs

@@ -1,35 +1,77 @@
-
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Linq;
 using FluentValidation.Results;
 using NzbDrone.Core.Tv;
 using NzbDrone.Common.Extensions;
+using NzbDrone.Core.Validation;
 
 namespace NzbDrone.Core.Notifications.Webhook
 {
     public class Webhook : NotificationBase<WebhookSettings>
     {
-        private readonly IWebhookService _service;
+        private readonly IWebhookProxy _proxy;
 
-        public Webhook(IWebhookService service)
+        public Webhook(IWebhookProxy proxy)
         {
-            _service = service;
+            _proxy = proxy;
         }
 
         public override string Link => "https://github.com/Sonarr/Sonarr/wiki/Webhook";
 
         public override void OnGrab(GrabMessage message)
         {
-            _service.OnGrab(message.Series, message.Episode, message.Quality, Settings);
+            var remoteEpisode = message.Episode;
+            var quality = message.Quality;
+
+            var payload = new WebhookGrabPayload
+            {
+                EventType = "Grab",
+                Series = new WebhookSeries(message.Series),
+                Episodes = remoteEpisode.Episodes.ConvertAll(x => new WebhookEpisode(x)
+                {
+                    // TODO: Stop passing these parameters inside an episode v3
+                    Quality = quality.Quality.Name,
+                    QualityVersion = quality.Revision.Version,
+                    ReleaseGroup = remoteEpisode.ParsedEpisodeInfo.ReleaseGroup
+                }),
+                Release = new WebhookRelease(quality, remoteEpisode)
+            };
+
+            _proxy.SendWebhook(payload, Settings);
         }
 
         public override void OnDownload(DownloadMessage message)
         {
-            _service.OnDownload(message.Series, message.EpisodeFile, Settings);
+            var episodeFile = message.EpisodeFile;
+
+            var payload = new WebhookImportPayload
+            {
+                EventType = "Download",
+                Series = new WebhookSeries(message.Series),
+                Episodes = episodeFile.Episodes.Value.ConvertAll(x => new WebhookEpisode(x)
+                {
+                    // TODO: Stop passing these parameters inside an episode v3
+                    Quality = episodeFile.Quality.Quality.Name,
+                    QualityVersion = episodeFile.Quality.Revision.Version,
+                    ReleaseGroup = episodeFile.ReleaseGroup,
+                    SceneName = episodeFile.SceneName
+                }),
+                EpisodeFile = new WebhookEpisodeFile(episodeFile),
+                IsUpgrade = message.OldFiles.Any()
+            };
+
+            _proxy.SendWebhook(payload, Settings);
         }
 
         public override void OnRename(Series series)
         {
-            _service.OnRename(series, Settings);
+            var payload = new WebhookPayload
+            {
+                EventType = "Rename",
+                Series = new WebhookSeries(series)
+            };
+
+            _proxy.SendWebhook(payload, Settings);
         }
 
         public override string Name => "Webhook";
@@ -38,9 +80,44 @@ public override ValidationResult Test()
         {
             var failures = new List<ValidationFailure>();
 
-            failures.AddIfNotNull(_service.Test(Settings));
+            failures.AddIfNotNull(SendWebhookTest());
 
             return new ValidationResult(failures);
         }
+
+        private ValidationFailure SendWebhookTest()
+        {
+            try
+            {
+                var payload = new WebhookGrabPayload
+                    {
+                        EventType = "Test",
+                        Series = new WebhookSeries()
+                        {
+                            Id = 1,
+                            Title = "Test Title",
+                            Path = "C:\\testpath",
+                            TvdbId = 1234
+                        },
+                        Episodes = new List<WebhookEpisode>() {
+                            new WebhookEpisode()
+                            {
+                                Id = 123,
+                                EpisodeNumber = 1,
+                                SeasonNumber = 1,
+                                Title = "Test title"
+                            }
+                        }
+                    };
+
+                _proxy.SendWebhook(payload, Settings);
+            }
+            catch (WebhookException ex)
+            {
+                return new NzbDroneValidationFailure("Url", ex.Message);
+            }
+
+            return null;
+        }
     }
 }

src/NzbDrone.Core/Notifications/Webhook/WebhookEpisodeFile.cs

@@ -0,0 +1,28 @@
+using NzbDrone.Core.MediaFiles;
+
+namespace NzbDrone.Core.Notifications.Webhook
+{
+    public class WebhookEpisodeFile
+    {
+        public WebhookEpisodeFile() { }
+
+        public WebhookEpisodeFile(EpisodeFile episodeFile)
+        {
+            Id = episodeFile.Id;
+            RelativePath = episodeFile.RelativePath;
+            Path = episodeFile.Path;
+            Quality = episodeFile.Quality.Quality.Name;
+            QualityVersion = episodeFile.Quality.Revision.Version;
+            ReleaseGroup = episodeFile.ReleaseGroup;
+            SceneName = episodeFile.SceneName;
+        }
+
+        public int Id { get; set; }
+        public string RelativePath { get; set; }
+        public string Path { get; set; }
+        public string Quality { get; set; }
+        public int QualityVersion { get; set; }
+        public string ReleaseGroup { get; set; }
+        public string SceneName { get; set; }
+    }
+}

src/NzbDrone.Core/Notifications/Webhook/WebhookGrabPayload.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace NzbDrone.Core.Notifications.Webhook
+{
+    public class WebhookGrabPayload : WebhookPayload
+    {
+        public List<WebhookEpisode> Episodes { get; set; }
+        public WebhookRelease Release { get; set; }
+    }
+}

src/NzbDrone.Core/Notifications/Webhook/WebhookImportPayload.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace NzbDrone.Core.Notifications.Webhook
+{
+    public class WebhookImportPayload : WebhookPayload
+    {
+        public List<WebhookEpisode> Episodes { get; set; }
+        public WebhookEpisodeFile EpisodeFile { get; set; }
+        public bool IsUpgrade { get; set; }
+    }
+}

src/NzbDrone.Core/Notifications/Webhook/WebhookMethod.cs

@@ -1,8 +1,10 @@
-namespace NzbDrone.Core.Notifications.Webhook
+using NzbDrone.Common.Http;
+
+namespace NzbDrone.Core.Notifications.Webhook
 {
     public enum WebhookMethod
     {
-        POST = RestSharp.Method.POST,
-        PUT = RestSharp.Method.PUT
+        POST = HttpMethod.POST,
+        PUT = HttpMethod.PUT
     }
 }

src/NzbDrone.Core/Notifications/Webhook/WebhookPayload.cs

@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-
-namespace NzbDrone.Core.Notifications.Webhook
+namespace NzbDrone.Core.Notifications.Webhook
 {
     public class WebhookPayload
     {
         public string EventType { get; set; }
         public WebhookSeries Series { get; set; }
-        public List<WebhookEpisode> Episodes { get; set; }
     }
 }

src/NzbDrone.Core/Notifications/Webhook/WebhookProxy.cs

@@ -0,0 +1,41 @@
+using NzbDrone.Common.Http;
+using NzbDrone.Common.Serializer;
+using NzbDrone.Core.Rest;
+
+namespace NzbDrone.Core.Notifications.Webhook
+{
+    public interface IWebhookProxy
+    {
+        void SendWebhook(WebhookPayload payload, WebhookSettings settings);
+    }
+
+    public class WebhookProxy : IWebhookProxy
+    {
+        private readonly IHttpClient _httpClient;
+
+        public WebhookProxy(IHttpClient httpClient)
+        {
+            _httpClient = httpClient;
+        }
+
+        public void SendWebhook(WebhookPayload body, WebhookSettings settings)
+        {
+            try
+            {
+                var request = new HttpRequestBuilder(settings.Url)
+                    .Accept(HttpAccept.Json)
+                    .Build();
+
+                request.Method = (HttpMethod)settings.Method;
+                request.Headers.ContentType = "application/json";
+                request.SetContent(body.ToJson());
+
+                _httpClient.Execute(request);
+            }
+            catch (RestException ex)
+            {
+                throw new WebhookException("Unable to post to webhook: {0}", ex, ex.Message);
+            }
+        }
+    }
+}

src/NzbDrone.Core/Notifications/Webhook/WebhookRelease.cs

@@ -0,0 +1,27 @@
+using NzbDrone.Core.Parser.Model;
+using NzbDrone.Core.Qualities;
+
+namespace NzbDrone.Core.Notifications.Webhook
+{
+    public class WebhookRelease
+    {
+        public WebhookRelease() { }
+
+        public WebhookRelease(QualityModel quality, RemoteEpisode remoteEpisode)
+        {
+            Quality = quality.Quality.Name;
+            QualityVersion = quality.Revision.Version;
+            ReleaseGroup = remoteEpisode.ParsedEpisodeInfo.ReleaseGroup;
+            ReleaseTitle = remoteEpisode.Release.Title;
+            Indexer = remoteEpisode.Release.Indexer;
+            Size = remoteEpisode.Release.Size;
+        }
+
+        public string Quality { get; set; }
+        public int QualityVersion { get; set; }
+        public string ReleaseGroup { get; set; }
+        public string ReleaseTitle { get; set; }
+        public string Indexer { get; set; }
+        public long Size { get; set; }
+    }
+}