The move!

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/EmbyRecentlyAddedNewsletter.cs

@@ -0,0 +1,454 @@
+#region Copyright
+
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: RecentlyAddedModel.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Newtonsoft.Json;
+using NLog;
+using Ombi.Api;
+using Ombi.Api.Interfaces;
+using Ombi.Api.Models.Emby;
+using Ombi.Core;
+using Ombi.Core.SettingModels;
+using Ombi.Services.Jobs.Templates;
+using Ombi.Store.Models;
+using Ombi.Store.Models.Emby;
+using Ombi.Store.Repository;
+using TMDbLib.Objects.Exceptions;
+using EmbyMediaType = Ombi.Store.Models.Plex.EmbyMediaType;
+using Polly;
+
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public class EmbyAddedNewsletter : HtmlTemplateGenerator, IEmbyAddedNewsletter
+    {
+        public EmbyAddedNewsletter(IEmbyApi api, ISettingsService<EmbySettings> embySettings,
+            ISettingsService<EmailNotificationSettings> email,
+               ISettingsService<NewletterSettings> newsletter, IRepository<RecentlyAddedLog> log,
+            IRepository<EmbyContent> embyContent, IRepository<EmbyEpisodes> episodes)
+        {
+            Api = api;
+            EmbySettings = embySettings;
+            EmailSettings = email;
+            NewsletterSettings = newsletter;
+            Content = embyContent;
+            MovieApi = new TheMovieDbApi();
+            TvApi = new TvMazeApi();
+            Episodes = episodes;
+            RecentlyAddedLog = log;
+        }
+
+        private IEmbyApi Api { get; }
+        private TheMovieDbApi MovieApi { get; }
+        private TvMazeApi TvApi { get; }
+        private ISettingsService<EmbySettings> EmbySettings { get; }
+        private ISettingsService<EmailNotificationSettings> EmailSettings { get; }
+        private ISettingsService<NewletterSettings> NewsletterSettings { get; }
+        private IRepository<EmbyContent> Content { get; }
+        private IRepository<EmbyEpisodes> Episodes { get; }
+        private IRepository<RecentlyAddedLog> RecentlyAddedLog { get; }
+
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+        public Newsletter GetNewsletter(bool test)
+        {
+            try
+            {
+                return GetHtml(test);
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+                return null;
+            }
+        }
+
+        private class EmbyRecentlyAddedModel
+        {
+            public EmbyInformation EmbyInformation { get; set; }
+            public EmbyContent EmbyContent { get; set; }
+            public List<EmbyEpisodeInformation> EpisodeInformation { get; set; }
+        }
+
+        private Newsletter GetHtml(bool test)
+        {
+            var sb = new StringBuilder();
+            var newsletter = new Newsletter();
+
+            var embySettings = EmbySettings.GetSettings();
+            var embyContent = Content.GetAll().ToList();
+
+            var series = embyContent.Where(x => x.Type == EmbyMediaType.Series).ToList();
+            var episodes = Episodes.GetAll().ToList();
+            var movie = embyContent.Where(x => x.Type == EmbyMediaType.Movie).ToList();
+
+            var recentlyAdded = RecentlyAddedLog.GetAll().ToList();
+
+            var firstRun = !recentlyAdded.Any();
+
+            var filteredMovies = movie.Where(m => recentlyAdded.All(x => x.ProviderId != m.EmbyId)).ToList();
+            var filteredEp = episodes.Where(m => recentlyAdded.All(x => x.ProviderId != m.EmbyId)).ToList();
+            var filteredSeries = series.Where(m => recentlyAdded.All(x => x.ProviderId != m.EmbyId)).ToList();
+
+            var info = new List<EmbyRecentlyAddedModel>();
+            foreach (var m in filteredMovies.OrderByDescending(x => x.AddedAt))
+            {
+                var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) =>
+                    Log.Error(exception, "Exception thrown when processing an emby movie for the newsletter, Retrying {0}", timespan));
+                var result = policy.Execute(() =>
+                {
+                    var i = Api.GetInformation(m.EmbyId, Ombi.Api.Models.Emby.EmbyMediaType.Movie,
+                        embySettings.ApiKey, embySettings.AdministratorId, embySettings.FullUri);
+
+                    return new EmbyRecentlyAddedModel
+                    {
+                        EmbyInformation = i,
+                        EmbyContent = m
+                    };
+                });
+                info.Add(result);
+            }
+            GenerateMovieHtml(info, sb);
+            newsletter.MovieCount = info.Count;
+
+            info.Clear();
+
+            // Check if there are any epiosdes, then get the series info.
+            // Otherwise then just add the series to the newsletter
+            if (test && !filteredEp.Any() && episodes.Any())
+            {
+                // if this is a test make sure we show something
+                filteredEp = episodes.Take(5).ToList();
+            }
+            if (filteredEp.Any())
+            {
+                var recentlyAddedModel = new List<EmbyRecentlyAddedModel>();
+                foreach (var embyEpisodes in filteredEp)
+                {
+                    try
+                    {
+                        var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) =>
+                            Log.Error(exception, "Exception thrown when processing an emby episode for the newsletter, Retrying {0}", timespan));
+
+                        policy.Execute(() =>
+                        {
+                            // Find related series item
+                            var relatedSeries = series.FirstOrDefault(x => x.EmbyId == embyEpisodes.ParentId);
+
+                            if (relatedSeries == null)
+                            {
+                                return;
+                            }
+
+                            // Get series information
+                            var i = Api.GetInformation(relatedSeries.EmbyId, Ombi.Api.Models.Emby.EmbyMediaType.Series,
+                                    embySettings.ApiKey, embySettings.AdministratorId, embySettings.FullUri);
+
+                            Thread.Sleep(200);
+                            var episodeInfo = Api.GetInformation(embyEpisodes.EmbyId,
+                                Ombi.Api.Models.Emby.EmbyMediaType.Episode,
+                                embySettings.ApiKey, embySettings.AdministratorId, embySettings.FullUri);
+
+                            // Check if we already have this series
+                            var existingSeries = recentlyAddedModel.FirstOrDefault(x =>
+                                    x.EmbyInformation.SeriesInformation.Id.Equals(i.SeriesInformation.Id,
+                                        StringComparison.CurrentCultureIgnoreCase));
+
+                            if (existingSeries != null)
+                            {
+                                existingSeries.EpisodeInformation.Add(episodeInfo.EpisodeInformation);
+                            }
+                            else
+                            {
+                                recentlyAddedModel.Add(new EmbyRecentlyAddedModel
+                                {
+                                    EmbyInformation = i,
+                                    EpisodeInformation = new List<EmbyEpisodeInformation>() { episodeInfo.EpisodeInformation },
+                                    EmbyContent = relatedSeries
+                                });
+                            }
+                        });
+
+                    }
+                    catch (JsonReaderException)
+                    {
+                        Log.Error("Failed getting information from Emby, we may have overloaded Emby's api... Waiting and we will skip this one and go to the next");
+                        Thread.Sleep(1000);
+                    }
+                }
+
+                info.AddRange(recentlyAddedModel);
+            }
+            else
+            {
+                foreach (var t in filteredSeries.OrderByDescending(x => x.AddedAt))
+                {
+
+
+                    var policy = RetryHandler.RetryAndWaitPolicy((exception, timespan) =>
+                        Log.Error(exception, "Exception thrown when processing an emby series for the newsletter, Retrying {0}", timespan));
+                    var item = policy.Execute(() =>
+                    {
+                        var i = Api.GetInformation(t.EmbyId, Ombi.Api.Models.Emby.EmbyMediaType.Series,
+                            embySettings.ApiKey, embySettings.AdministratorId, embySettings.FullUri);
+                        var model = new EmbyRecentlyAddedModel
+                        {
+                            EmbyContent = t,
+                            EmbyInformation = i,
+                        };
+                        return model;
+                    });
+                    info.Add(item);
+                }
+            }
+            GenerateTvHtml(info, sb);
+            newsletter.TvCount = info.Count;
+
+
+            var template = new RecentlyAddedTemplate();
+            var html = template.LoadTemplate(sb.ToString());
+            Log.Debug("Loaded the template");
+
+            if (!test || firstRun)
+            {
+                foreach (var a in filteredMovies)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = a.EmbyId,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+                foreach (var a in filteredEp)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = a.EmbyId,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+                foreach (var s in filteredSeries)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = s.EmbyId,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+            }
+
+
+            var escapedHtml = new string(html.Where(c => !char.IsControl(c)).ToArray());
+            Log.Debug(escapedHtml);
+            newsletter.Html = escapedHtml;
+            return newsletter;
+
+        }
+
+        private void GenerateMovieHtml(IEnumerable<EmbyRecentlyAddedModel> recentlyAddedMovies, StringBuilder sb)
+        {
+            var movies = recentlyAddedMovies?.ToList() ?? new List<EmbyRecentlyAddedModel>();
+            if (!movies.Any())
+            {
+                return;
+            }
+            var orderedMovies = movies.OrderByDescending(x => x.EmbyContent.AddedAt).Select(x => x.EmbyInformation.MovieInformation).ToList();
+            sb.Append("<h1>New Movies:</h1><br /><br />");
+            sb.Append(
+                "<table border=\"0\" cellpadding=\"0\"  align=\"center\" cellspacing=\"0\" style=\"border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; width: 100%;\" width=\"100%\">");
+            foreach (var movie in orderedMovies)
+            {
+                // We have a try within a try so we can catch the rate limit without ending the loop (finally block)
+                try
+                {
+                    try
+                    {
+
+                        var imdbId = movie.ProviderIds.Imdb;
+                        var info = MovieApi.GetMovieInformation(imdbId).Result;
+                        if (info == null)
+                        {
+                            throw new Exception($"Movie with Imdb id {imdbId} returned null from the MovieApi");
+                        }
+                        AddImageInsideTable(sb, $"https://image.tmdb.org/t/p/w500{info.BackdropPath}");
+
+                        sb.Append("<tr>");
+                        sb.Append(
+                            "<td align=\"center\" style=\"font-family: sans-serif; font-size: 14px; vertical-align: top;\" valign=\"top\">");
+
+                        Href(sb, $"https://www.imdb.com/title/{info.ImdbId}/");
+                        Header(sb, 3, $"{info.Title} {info.ReleaseDate?.ToString("yyyy") ?? string.Empty}");
+                        EndTag(sb, "a");
+
+                        if (info.Genres.Any())
+                        {
+                            AddParagraph(sb,
+                                $"Genre: {string.Join(", ", info.Genres.Select(x => x.Name.ToString()).ToArray())}");
+                        }
+
+                        AddParagraph(sb, info.Overview);
+                    }
+                    catch (Exception limit)
+                    {
+                        // We have hit a limit, we need to now wait.
+                        Thread.Sleep(TimeSpan.FromSeconds(10));
+                        Log.Info(limit);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                    Log.Error("Error for movie with IMDB Id = {0}", movie.ProviderIds.Imdb);
+                }
+                finally
+                {
+                    EndLoopHtml(sb);
+                }
+
+            }
+            sb.Append("</table><br /><br />");
+        }
+
+        private class TvModel
+        {
+            public EmbySeriesInformation Series { get; set; }
+            public List<EmbyEpisodeInformation> Episodes { get; set; }
+        }
+        private void GenerateTvHtml(IEnumerable<EmbyRecentlyAddedModel> recenetlyAddedTv, StringBuilder sb)
+        {
+            var tv = recenetlyAddedTv?.ToList() ?? new List<EmbyRecentlyAddedModel>();
+
+            if (!tv.Any())
+            {
+                return;
+            }
+            var orderedTv = tv.OrderByDescending(x => x.EmbyContent.AddedAt).ToList();
+
+            // TV
+            sb.Append("<h1>New Episodes:</h1><br /><br />");
+            sb.Append(
+                "<table border=\"0\" cellpadding=\"0\"  align=\"center\" cellspacing=\"0\" style=\"border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; width: 100%;\" width=\"100%\">");
+            foreach (var t in orderedTv)
+            {
+                var seriesItem = t.EmbyInformation.SeriesInformation;
+                var relatedEpisodes = t.EpisodeInformation;
+                var endLoop = false;
+
+                try
+                {
+                    var info = TvApi.ShowLookupByTheTvDbId(int.Parse(seriesItem.ProviderIds.Tvdb));
+                    if (info == null) continue;
+
+                    var banner = info.image?.original;
+                    if (!string.IsNullOrEmpty(banner))
+                    {
+                        banner = banner.Replace("http", "https"); // Always use the Https banners
+                    }
+                    AddImageInsideTable(sb, banner);
+
+                    sb.Append("<tr>");
+                    sb.Append(
+                        "<td align=\"center\" style=\"font-family: sans-serif; font-size: 14px; vertical-align: top;\" valign=\"top\">");
+
+                    var title = $"{seriesItem.Name} {seriesItem.PremiereDate.Year}";
+
+                    Href(sb, $"https://www.imdb.com/title/{info.externals.imdb}/");
+                    Header(sb, 3, title);
+                    EndTag(sb, "a");
+
+                    if (relatedEpisodes != null)
+                    {
+                        var results = relatedEpisodes.GroupBy(p => p.ParentIndexNumber,
+                            (key, g) => new
+                            {
+                                ParentIndexNumber = key,
+                                IndexNumber = g.ToList()
+                            }
+                        );
+                        // Group the episodes
+                        foreach (var embyEpisodeInformation in results.OrderBy(x => x.ParentIndexNumber))
+                        {
+                            var epSb = new StringBuilder();
+                            var orderedEpisodes = embyEpisodeInformation.IndexNumber.OrderBy(x => x.IndexNumber).ToList();
+                            for (var i = 0; i < orderedEpisodes.Count; i++)
+                            {
+                                var ep = orderedEpisodes[i];
+                                if (i < embyEpisodeInformation.IndexNumber.Count - 1)
+                                {
+                                    epSb.Append($"{ep.IndexNumber},");
+                                }
+                                else
+                                {
+                                    epSb.Append(ep.IndexNumber);
+                                }
+                            }
+                            AddParagraph(sb, $"Season: {embyEpisodeInformation.ParentIndexNumber}, Episode: {epSb}");
+                        }
+                    }
+
+                    if (info.genres.Any())
+                    {
+                        AddParagraph(sb, $"Genre: {string.Join(", ", info.genres.Select(x => x.ToString()).ToArray())}");
+                    }
+
+                    AddParagraph(sb, string.IsNullOrEmpty(seriesItem.Overview) ? info.summary : seriesItem.Overview);
+                    endLoop = true;
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+                finally
+                {
+                    if (endLoop)
+                        EndLoopHtml(sb);
+                }
+            }
+            sb.Append("</table><br /><br />");
+        }
+
+
+
+
+        private void EndLoopHtml(StringBuilder sb)
+        {
+            //NOTE: BR have to be in TD's as per html spec or it will be put outside of the table...
+            //Source: http://stackoverflow.com/questions/6588638/phantom-br-tag-rendered-by-browsers-prior-to-table-tag
+            sb.Append("<hr />");
+            sb.Append("<br />");
+            sb.Append("<br />");
+            sb.Append("</td>");
+            sb.Append("</tr>");
+        }
+
+    }
+}

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/IEmbyAddedNewsletter.cs

@@ -0,0 +1,7 @@
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public interface IEmbyAddedNewsletter
+    {
+        Newsletter GetNewsletter(bool test);
+    }
+}

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/IPlexNewsletter.cs

@@ -0,0 +1,7 @@
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public interface IPlexNewsletter
+    {
+        Newsletter GetNewsletter(bool test);
+    }
+}

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/Newsletter.cs

@@ -0,0 +1,37 @@
+#region Copyright
+// /************************************************************************
+//    Copyright (c) 2017 Jamie Rees
+//    File: Newsletter.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+#endregion
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public class Newsletter
+    {
+        public string Html { get; set; }
+        public int MovieCount { get; set; }
+        public int TvCount { get; set; }
+
+        public bool Send => MovieCount > 0 || TvCount > 0;
+    }
+}

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/PlexRecentlyAddedNewsletter.cs

@@ -0,0 +1,425 @@
+#region Copyright
+
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: RecentlyAddedModel.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using NLog;
+using Ombi.Api;
+using Ombi.Api.Interfaces;
+using Ombi.Api.Models.Emby;
+using Ombi.Api.Models.Plex;
+using Ombi.Core;
+using Ombi.Core.SettingModels;
+using Ombi.Helpers;
+using Ombi.Services.Jobs.Templates;
+using Ombi.Store.Models;
+using Ombi.Store.Models.Plex;
+using Ombi.Store.Repository;
+using TMDbLib.Objects.Exceptions;
+using PlexMediaType = Ombi.Store.Models.Plex.PlexMediaType;
+
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public class
+        PlexRecentlyAddedNewsletter : HtmlTemplateGenerator, IPlexNewsletter
+    {
+        public PlexRecentlyAddedNewsletter(IPlexApi api, ISettingsService<PlexSettings> plexSettings,
+            ISettingsService<EmailNotificationSettings> email,
+               ISettingsService<NewletterSettings> newsletter, IRepository<RecentlyAddedLog> log,
+            IRepository<PlexContent> embyContent, IRepository<PlexEpisodes> episodes)
+        {
+            Api = api;
+            PlexSettings = plexSettings;
+            EmailSettings = email;
+            NewsletterSettings = newsletter;
+            Content = embyContent;
+            MovieApi = new TheMovieDbApi();
+            TvApi = new TvMazeApi();
+            Episodes = episodes;
+            RecentlyAddedLog = log;
+        }
+
+        private IPlexApi Api { get; }
+        private TheMovieDbApi MovieApi { get; }
+        private TvMazeApi TvApi { get; }
+        private ISettingsService<PlexSettings> PlexSettings { get; }
+        private ISettingsService<EmailNotificationSettings> EmailSettings { get; }
+        private ISettingsService<NewletterSettings> NewsletterSettings { get; }
+        private IRepository<PlexContent> Content { get; }
+        private IRepository<PlexEpisodes> Episodes { get; }
+        private IRepository<RecentlyAddedLog> RecentlyAddedLog { get; }
+
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+        public Newsletter GetNewsletter(bool test)
+        {
+            try
+            {
+                return GetHtml(test);
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+                return null;
+            }
+        }
+
+        private class PlexRecentlyAddedModel
+        {
+            public PlexMetadata Metadata { get; set; }
+            public PlexContent Content { get; set; }
+            public List<PlexEpisodeMetadata> EpisodeMetadata { get; set; }
+        }
+
+        private Newsletter GetHtml(bool test)
+        {
+            var sb = new StringBuilder();
+            var newsletter = new Newsletter();
+            var plexSettings = PlexSettings.GetSettings();
+
+            var plexContent = Content.GetAll().ToList();
+
+            var series = plexContent.Where(x => x.Type == PlexMediaType.Show).ToList();
+            var episodes = Episodes.GetAll().ToList();
+            var movie = plexContent.Where(x => x.Type == PlexMediaType.Movie).ToList();
+
+            var recentlyAdded = RecentlyAddedLog.GetAll().ToList();
+
+            var firstRun = !recentlyAdded.Any();
+
+            var filteredMovies = movie.Where(m => recentlyAdded.All(x => x.ProviderId != m.ProviderId)).ToList();
+            var filteredEp = episodes.Where(m => recentlyAdded.All(x => x.ProviderId != m.RatingKey)).ToList();
+            var filteredSeries = series.Where(x => recentlyAdded.All(c => c.ProviderId != x.ProviderId)).ToList();
+
+            var info = new List<PlexRecentlyAddedModel>();
+
+            if (test && !filteredMovies.Any())
+            {
+                // if this is a test make sure we show something
+                filteredMovies = movie.Take(5).ToList();
+            }
+            foreach (var m in filteredMovies.OrderByDescending(x => x.AddedAt))
+            {
+                var i = Api.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri, m.ItemId);
+                if (i.Video == null)
+                {
+                    continue;
+                }
+                info.Add(new PlexRecentlyAddedModel
+                {
+                    Metadata = i,
+                    Content = m
+                });
+            }
+            GenerateMovieHtml(info, sb);
+            newsletter.MovieCount = info.Count;
+
+            info.Clear();
+            if (test && !filteredEp.Any() && episodes.Any())
+            {
+                // if this is a test make sure we show something
+                filteredEp = episodes.Take(5).ToList();
+            }
+            if (filteredEp.Any())
+            {
+                var recentlyAddedModel = new List<PlexRecentlyAddedModel>();
+                foreach (var plexEpisodes in filteredEp)
+                {
+                    // Find related series item
+                    var relatedSeries = series.FirstOrDefault(x => x.ProviderId == plexEpisodes.ProviderId);
+
+                    if (relatedSeries == null)
+                    {
+                        continue;
+                    }
+
+                    // Get series information
+                    var i = Api.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri, relatedSeries.ItemId);
+
+                    var episodeInfo = Api.GetEpisodeMetaData(plexSettings.PlexAuthToken, plexSettings.FullUri, plexEpisodes.RatingKey);
+                    // Check if we already have this series
+                    var existingSeries = recentlyAddedModel.FirstOrDefault(x =>
+                        x.Metadata.Directory.RatingKey == i.Directory.RatingKey);
+
+                    if (existingSeries != null)
+                    {
+                        existingSeries.EpisodeMetadata.Add(episodeInfo);
+                    }
+                    else
+                    {
+                        recentlyAddedModel.Add(new PlexRecentlyAddedModel
+                        {
+                            Metadata = i,
+                            EpisodeMetadata = new List<PlexEpisodeMetadata>() { episodeInfo },
+                            Content = relatedSeries
+                        });
+                    }
+                }
+
+                info.AddRange(recentlyAddedModel);
+            }
+            else
+            {
+                if (test && !filteredSeries.Any())
+                {
+                    // if this is a test make sure we show something
+                    filteredSeries = series.Take(5).ToList();
+                }
+                foreach (var t in filteredSeries.OrderByDescending(x => x.AddedAt))
+                {
+                    var i = Api.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri, t.ItemId);
+                    if (i.Directory == null)
+                    {
+                        continue;
+
+                    }
+
+                    info.Add(new PlexRecentlyAddedModel
+                    {
+                        Metadata = i,
+                        Content = t
+                    });
+                }
+            }
+            GenerateTvHtml(info, sb);
+            newsletter.TvCount = info.Count;
+
+            var template = new RecentlyAddedTemplate();
+            var html = template.LoadTemplate(sb.ToString());
+            Log.Debug("Loaded the template");
+
+            if (!test || firstRun)
+            {
+                foreach (var a in filteredMovies)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = a.ProviderId,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+                foreach (var a in filteredEp)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = a.RatingKey,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+                foreach (var a in filteredSeries)
+                {
+                    RecentlyAddedLog.Insert(new RecentlyAddedLog
+                    {
+                        ProviderId = a.ProviderId,
+                        AddedAt = DateTime.UtcNow
+                    });
+                }
+            }
+
+            var escapedHtml = new string(html.Where(c => !char.IsControl(c)).ToArray());
+            Log.Debug(escapedHtml);
+            newsletter.Html = escapedHtml;
+            return newsletter;
+        }
+
+        private void GenerateMovieHtml(IEnumerable<PlexRecentlyAddedModel> recentlyAddedMovies, StringBuilder sb)
+        {
+            var movies = recentlyAddedMovies?.ToList() ?? new List<PlexRecentlyAddedModel>();
+            if (!movies.Any())
+            {
+                return;
+            }
+            var orderedMovies = movies.OrderByDescending(x => x.Content.AddedAt).ToList();
+            sb.Append("<h1>New Movies:</h1><br /><br />");
+            sb.Append(
+                "<table border=\"0\" cellpadding=\"0\"  align=\"center\" cellspacing=\"0\" style=\"border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; width: 100%;\" width=\"100%\">");
+            foreach (var movie in orderedMovies)
+            {
+                // We have a try within a try so we can catch the rate limit without ending the loop (finally block)
+                try
+                {
+                    try
+                    {
+
+                        var imdbId = PlexHelper.GetProviderIdFromPlexGuid(movie.Metadata.Video.Guid);
+                        var info = MovieApi.GetMovieInformation(imdbId).Result;
+                        if (info == null)
+                        {
+                            throw new Exception($"Movie with Imdb id {imdbId} returned null from the MovieApi");
+                        }
+                        AddImageInsideTable(sb, $"https://image.tmdb.org/t/p/w500{info.BackdropPath}");
+
+                        sb.Append("<tr>");
+                        sb.Append(
+                            "<td align=\"center\" style=\"font-family: sans-serif; font-size: 14px; vertical-align: top;\" valign=\"top\">");
+
+                        Href(sb, $"https://www.imdb.com/title/{info.ImdbId}/");
+                        Header(sb, 3, $"{info.Title} {info.ReleaseDate?.ToString("yyyy") ?? string.Empty}");
+                        EndTag(sb, "a");
+
+                        if (info.Genres.Any())
+                        {
+                            AddParagraph(sb,
+                                $"Genre: {string.Join(", ", info.Genres.Select(x => x.Name.ToString()).ToArray())}");
+                        }
+
+                        AddParagraph(sb, info.Overview);
+                    }
+                    catch (RequestLimitExceededException limit)
+                    {
+                        // We have hit a limit, we need to now wait.
+                        Thread.Sleep(TimeSpan.FromSeconds(10));
+                        Log.Info(limit);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                    Log.Error("Error for movie with IMDB Id = {0}", movie.Metadata.Video.Guid);
+                }
+                finally
+                {
+                    EndLoopHtml(sb);
+                }
+
+            }
+            sb.Append("</table><br /><br />");
+        }
+
+        private class TvModel
+        {
+            public EmbySeriesInformation Series { get; set; }
+            public List<EmbyEpisodeInformation> Episodes { get; set; }
+        }
+        private void GenerateTvHtml(IEnumerable<PlexRecentlyAddedModel> recenetlyAddedTv, StringBuilder sb)
+        {
+            var tv = recenetlyAddedTv?.ToList() ?? new List<PlexRecentlyAddedModel>();
+
+            if (!tv.Any())
+            {
+                return;
+            }
+            var orderedTv = tv.OrderByDescending(x => x.Content.AddedAt).ToList();
+
+            // TV
+            sb.Append("<h1>New Episodes:</h1><br /><br />");
+            sb.Append(
+                "<table border=\"0\" cellpadding=\"0\"  align=\"center\" cellspacing=\"0\" style=\"border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; width: 100%;\" width=\"100%\">");
+            foreach (var t in orderedTv)
+            {
+                var relatedEpisodes = t.EpisodeMetadata ?? new List<PlexEpisodeMetadata>();
+
+                try
+                {
+                    var info = TvApi.ShowLookupByTheTvDbId(int.Parse(PlexHelper.GetProviderIdFromPlexGuid(t?.Metadata?.Directory?.Guid ?? string.Empty)));
+
+                    var banner = info.image?.original;
+                    if (!string.IsNullOrEmpty(banner))
+                    {
+                        banner = banner.Replace("http", "https"); // Always use the Https banners
+                    }
+                    AddImageInsideTable(sb, banner);
+
+                    sb.Append("<tr>");
+                    sb.Append(
+                        "<td align=\"center\" style=\"font-family: sans-serif; font-size: 14px; vertical-align: top;\" valign=\"top\">");
+
+                    var title = $"{t.Content.Title} {t.Content.ReleaseYear}";
+
+                    Href(sb, $"https://www.imdb.com/title/{info.externals.imdb}/");
+                    Header(sb, 3, title);
+                    EndTag(sb, "a");
+
+                    // Group by the ParentIndex (season number)
+                    var results = relatedEpisodes.GroupBy(p => p.Video.FirstOrDefault()?.ParentIndex,
+                        (key, g) => new
+                        {
+                            ParentIndexNumber = key,
+                            IndexNumber = g.ToList()
+                        }
+                    );
+                    // Group the episodes
+                    foreach (var epInformation in results.OrderBy(x => x.ParentIndexNumber))
+                    {
+                        var orderedEpisodes = epInformation.IndexNumber.OrderBy(x => Convert.ToInt32(x.Video.FirstOrDefault().Index)).ToList();
+                        var epSb = new StringBuilder();
+                        for (var i = 0; i < orderedEpisodes.Count; i++)
+                        {
+                            var ep = orderedEpisodes[i];
+                            if (i < orderedEpisodes.Count - 1)
+                            {
+                                epSb.Append($"{ep.Video.FirstOrDefault().Index},");
+                            }
+                            else
+                            {
+                                epSb.Append($"{ep.Video.FirstOrDefault().Index}");
+                            }
+
+                        }
+                        AddParagraph(sb, $"Season: {epInformation.ParentIndexNumber}, Episode: {epSb}");
+                    }
+
+                    if (info.genres.Any())
+                    {
+                        AddParagraph(sb, $"Genre: {string.Join(", ", info.genres.Select(x => x.ToString()).ToArray())}");
+                    }
+
+                    AddParagraph(sb, string.IsNullOrEmpty(t.Metadata.Directory.Summary) ? t.Metadata.Directory.Summary : info.summary);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+                finally
+                {
+                    EndLoopHtml(sb);
+                }
+            }
+            sb.Append("</table><br /><br />");
+        }
+
+
+
+
+        private void EndLoopHtml(StringBuilder sb)
+        {
+            //NOTE: BR have to be in TD's as per html spec or it will be put outside of the table...
+            //Source: http://stackoverflow.com/questions/6588638/phantom-br-tag-rendered-by-browsers-prior-to-table-tag
+            sb.Append("<hr />");
+            sb.Append("<br />");
+            sb.Append("<br />");
+            sb.Append("</td>");
+            sb.Append("</tr>");
+        }
+
+    }
+}

Old/Ombi.Services/Jobs/RecentlyAddedNewsletter/RecentlyAddedNewsletter.cs

@@ -0,0 +1,284 @@
+#region Copyright
+
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: RecentlyAddedModel.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MailKit.Net.Smtp;
+using MimeKit;
+using NLog;
+using Ombi.Api;
+using Ombi.Api.Interfaces;
+using Ombi.Api.Models.Plex;
+using Ombi.Core;
+using Ombi.Core.SettingModels;
+using Ombi.Core.Users;
+using Ombi.Helpers;
+using Ombi.Helpers.Permissions;
+using Ombi.Services.Interfaces;
+using Ombi.Services.Jobs.Templates;
+using Quartz;
+
+namespace Ombi.Services.Jobs.RecentlyAddedNewsletter
+{
+    public class RecentlyAddedNewsletter : HtmlTemplateGenerator, IJob, IRecentlyAdded, IMassEmail
+    {
+        public RecentlyAddedNewsletter(IPlexApi api, ISettingsService<PlexSettings> plexSettings,
+            ISettingsService<EmailNotificationSettings> email, IJobRecord rec,
+               ISettingsService<NewletterSettings> newsletter,
+             IUserHelper userHelper, IEmbyAddedNewsletter embyNews,
+            ISettingsService<EmbySettings> embyS,
+            IPlexNewsletter plex)
+        {
+            JobRecord = rec;
+            Api = api;
+            PlexSettings = plexSettings;
+            EmailSettings = email;
+            NewsletterSettings = newsletter;
+            UserHelper = userHelper;
+            EmbyNewsletter = embyNews;
+            EmbySettings = embyS;
+            PlexNewsletter = plex;
+        }
+
+        private IPlexApi Api { get; }
+        private TvMazeApi TvApi = new TvMazeApi();
+        private readonly TheMovieDbApi _movieApi = new TheMovieDbApi();
+        private ISettingsService<PlexSettings> PlexSettings { get; }
+        private ISettingsService<EmbySettings> EmbySettings { get; }
+        private ISettingsService<EmailNotificationSettings> EmailSettings { get; }
+        private ISettingsService<NewletterSettings> NewsletterSettings { get; }
+        private IJobRecord JobRecord { get; }
+        private IUserHelper UserHelper { get; }
+        private IEmbyAddedNewsletter EmbyNewsletter { get; }
+        private IPlexNewsletter PlexNewsletter { get; }
+
+        private static readonly Logger Log = LogManager.GetCurrentClassLogger();
+
+        public void StartNewsLetter()
+        {
+            try
+            {
+                var settings = NewsletterSettings.GetSettings();
+                if (!settings.SendRecentlyAddedEmail)
+                {
+                    return;
+                }
+                JobRecord.SetRunning(true, JobNames.RecentlyAddedEmail);
+                StartNewsLetter(settings);
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+            }
+            finally
+            {
+                JobRecord.Record(JobNames.RecentlyAddedEmail);
+                JobRecord.SetRunning(false, JobNames.RecentlyAddedEmail);
+            }
+        }
+        public void Execute(IJobExecutionContext context)
+        {
+            StartNewsLetter();
+        }
+
+        public void RecentlyAddedAdminTest()
+        {
+            Log.Debug("Starting Recently Added Newsletter Test");
+            var settings = NewsletterSettings.GetSettings();
+            StartNewsLetter(settings, true);
+        }
+
+        public void MassEmailAdminTest(string html, string subject)
+        {
+            Log.Debug("Starting Mass Email Test");
+            var template = new MassEmailTemplate();
+            var body = template.LoadTemplate(html);
+            SendMassEmail(body, subject, true);
+        }
+
+        public void SendMassEmail(string html, string subject)
+        {
+            Log.Debug("Starting Mass Email Test");
+            var template = new MassEmailTemplate();
+            var body = template.LoadTemplate(html);
+            SendMassEmail(body, subject, false);
+        }
+
+        private void StartNewsLetter(NewletterSettings newletterSettings, bool testEmail = false)
+        {
+            var embySettings = EmbySettings.GetSettings();
+            if (embySettings.Enable)
+            {
+                var letter = EmbyNewsletter.GetNewsletter(testEmail) ?? new Newsletter();
+                if (letter.Send || testEmail)
+                {
+                    SendNewsletter(newletterSettings, letter.Html, testEmail, "New Content On Emby!");
+                }
+                else
+                {
+                    Log.Warn("There is no new content to send the newsletter");
+                }
+            }
+            else
+            {
+                var plexSettings = PlexSettings.GetSettings();
+                if (plexSettings.Enable)
+                {
+                    var letter = PlexNewsletter.GetNewsletter(testEmail) ?? new Newsletter();
+                    if (letter.Send || testEmail)
+                    {
+                        SendNewsletter(newletterSettings, letter.Html, testEmail);
+                    }
+                }
+            }
+        }
+
+        private void SendMassEmail(string html, string subject, bool testEmail)
+        {
+            var settings = EmailSettings.GetSettings();
+
+            if (!settings.Enabled || string.IsNullOrEmpty(settings.EmailHost))
+            {
+                return;
+            }
+
+            var body = new BodyBuilder { HtmlBody = html, TextBody = "This email is only available on devices that support HTML." };
+
+            var message = new MimeMessage
+            {
+                Body = body.ToMessageBody(),
+                Subject = subject
+            };
+            Log.Debug("Created Plain/HTML MIME body");
+
+            if (!testEmail)
+            {
+                var users = UserHelper.GetUsers(); // Get all users
+                if (users != null)
+                {
+                    foreach (var user in users)
+                    {
+                        if (!string.IsNullOrEmpty(user.EmailAddress))
+                        {
+                            message.Bcc.Add(new MailboxAddress(user.Username, user.EmailAddress)); // BCC everyone
+                        }
+                    }
+                }
+            }
+            message.Bcc.Add(new MailboxAddress(settings.EmailUsername, settings.RecipientEmail)); // Include the admin
+
+            message.From.Add(new MailboxAddress(settings.EmailUsername, settings.EmailSender));
+            SendMail(settings, message);
+        }
+
+       
+        private void SendNewsletter(NewletterSettings newletterSettings, string html, bool testEmail = false, string subject = "New Content on Plex!")
+        {
+            Log.Debug("Entering SendNewsletter");
+            var settings = EmailSettings.GetSettings();
+
+            if (!settings.Enabled || string.IsNullOrEmpty(settings.EmailHost))
+            {
+                return;
+            }
+
+            var body = new BodyBuilder { HtmlBody = html, TextBody = "This email is only available on devices that support HTML." };
+
+            var message = new MimeMessage
+            {
+                Body = body.ToMessageBody(),
+                Subject = subject
+            };
+            Log.Debug("Created Plain/HTML MIME body");
+
+            if (!testEmail)
+            {
+                var users = UserHelper.GetUsersWithFeature(Features.Newsletter);
+                if (users != null)
+                {
+                    foreach (var user in users)
+                    {
+                        if (!string.IsNullOrEmpty(user.EmailAddress))
+                        {
+                            message.Bcc.Add(new MailboxAddress(user.Username, user.EmailAddress));
+                        }
+                    }
+                }
+
+                if (newletterSettings.CustomUsersEmailAddresses != null
+                        && newletterSettings.CustomUsersEmailAddresses.Any())
+                {
+                    foreach (var user in newletterSettings.CustomUsersEmailAddresses)
+                    {
+                        if (!string.IsNullOrEmpty(user))
+                        {
+                            message.Bcc.Add(new MailboxAddress(user, user));
+                        }
+                    }
+                }
+            }
+
+            message.Bcc.Add(new MailboxAddress(settings.EmailUsername, settings.RecipientEmail)); // Include the admin
+
+            message.From.Add(new MailboxAddress(settings.EmailUsername, settings.EmailSender));
+            SendMail(settings, message);
+        }
+
+        private void SendMail(EmailNotificationSettings settings, MimeMessage message)
+        {
+            try
+            {
+                using (var client = new SmtpClient())
+                {
+                    client.Connect(settings.EmailHost, settings.EmailPort); // Let MailKit figure out the correct SecureSocketOptions.
+
+                    // Note: since we don't have an OAuth2 token, disable
+                    // the XOAUTH2 authentication mechanism.
+                    client.AuthenticationMechanisms.Remove("XOAUTH2");
+
+                    if (settings.Authentication)
+                    {
+                        client.Authenticate(settings.EmailUsername, settings.EmailPassword);
+                    }
+                    Log.Info("sending message to {0} \r\n from: {1}\r\n Are we authenticated: {2}", message.To, message.From, client.IsAuthenticated);
+                    Log.Debug("Sending");
+                    client.Send(message);
+                    Log.Debug("Sent");
+                    client.Disconnect(true);
+                }
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+            }
+        }
+    }
+}