diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index 8b96a6c32..21dadcafa 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,4 +1,24 @@
 
+<<<<<<< HEAD
+=======
+
+
+
+!! Version 2.X is not supported anymore. Pleas don't open a issue for the 2.x version.
+See https://github.com/tidusjar/Ombi/issues/1455 for more information.
+
+
+
+
+
+
+
+
+
+
+
+
+>>>>>>> origin/master
 <!--- 
 
 !! Please use the Support / bug report template, otherwise we will close the Github issue !!
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..2b5a39113
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at tidusjar@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/Ombi.Core.Migration/Migrations/Version2210.cs b/Ombi.Core.Migration/Migrations/Version2210.cs
new file mode 100644
index 000000000..94592174a
--- /dev/null
+++ b/Ombi.Core.Migration/Migrations/Version2210.cs
@@ -0,0 +1,134 @@
+#region Copyright
+
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: Version1100.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.Data;
+using NLog;
+using Ombi.Core.SettingModels;
+using Ombi.Store;
+using Ombi.Store.Models;
+using Ombi.Store.Models.Emby;
+using Ombi.Store.Models.Plex;
+using Ombi.Store.Repository;
+using Quartz.Collection;
+
+namespace Ombi.Core.Migration.Migrations
+{
+    [Migration(22100, "v2.21.0.0")]
+    public class Version2210 : BaseMigration, IMigration
+    {
+        public Version2210(IRepository<RecentlyAddedLog> log,
+            IRepository<PlexContent> content, IRepository<PlexEpisodes> plexEp, IRepository<EmbyContent> embyContent, IRepository<EmbyEpisodes> embyEp)
+        {
+            Log = log;
+            PlexContent = content;
+            PlexEpisodes = plexEp;
+            EmbyContent = embyContent;
+            EmbyEpisodes = embyEp;
+        }
+
+        public int Version => 22100;
+        private IRepository<RecentlyAddedLog> Log { get; }
+        private IRepository<PlexContent> PlexContent { get; }
+        private IRepository<PlexEpisodes> PlexEpisodes { get; }
+        private IRepository<EmbyContent> EmbyContent { get; }
+        private IRepository<EmbyEpisodes> EmbyEpisodes { get; }
+        
+        public void Start(IDbConnection con)
+        {
+            UpdateRecentlyAdded(con);
+            UpdateSchema(con, Version);
+
+        }
+
+        private void UpdateRecentlyAdded(IDbConnection con)
+        {
+
+            //Delete the recently added table, lets start again
+            Log.DeleteAll("RecentlyAddedLog");
+
+
+
+            // Plex 
+            var plexAllContent = PlexContent.GetAll();
+            var content = new HashSet<RecentlyAddedLog>();
+            foreach (var plexContent in plexAllContent)
+            {
+                if(plexContent.Type == PlexMediaType.Artist) continue;
+                content.Add(new RecentlyAddedLog
+                {
+                    AddedAt = DateTime.UtcNow,
+                    ProviderId = plexContent.ProviderId
+                });
+            }
+            Log.BatchInsert(content, "RecentlyAddedLog");
+
+            var plexEpisodeses = PlexEpisodes.GetAll();
+            content.Clear();
+            foreach (var ep in plexEpisodeses)
+            {
+                content.Add(new RecentlyAddedLog
+                {
+                    AddedAt = DateTime.UtcNow,
+                    ProviderId = ep.RatingKey
+                });
+            }
+            Log.BatchInsert(content, "RecentlyAddedLog");
+
+            // Emby 
+            content.Clear();
+            var embyContent = EmbyContent.GetAll();
+            foreach (var plexContent in embyContent)
+            {
+                content.Add(new RecentlyAddedLog
+                {
+                    AddedAt = DateTime.UtcNow,
+                    ProviderId = plexContent.EmbyId
+                });
+            }
+            Log.BatchInsert(content, "RecentlyAddedLog");
+
+            var embyEpisodes = EmbyEpisodes.GetAll();
+            content.Clear();
+            foreach (var ep in embyEpisodes)
+            {
+                content.Add(new RecentlyAddedLog
+                {
+                    AddedAt = DateTime.UtcNow,
+                    ProviderId = ep.EmbyId
+                });
+            }
+            Log.BatchInsert(content, "RecentlyAddedLog");
+
+
+        }
+
+     
+    }
+}
diff --git a/Ombi.Services/Jobs/PlexContentCacher.cs b/Ombi.Services/Jobs/PlexContentCacher.cs
new file mode 100644
index 000000000..d4f872fc2
--- /dev/null
+++ b/Ombi.Services/Jobs/PlexContentCacher.cs
@@ -0,0 +1,438 @@
+#region Copyright
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: PlexAvailabilityChecker.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 Dapper;
+using NLog;
+using Ombi.Api.Interfaces;
+using Ombi.Api.Models.Plex;
+using Ombi.Core;
+using Ombi.Core.SettingModels;
+using Ombi.Helpers;
+using Ombi.Services.Interfaces;
+using Ombi.Services.Models;
+using Ombi.Store.Models;
+using Ombi.Store.Models.Plex;
+using Ombi.Store.Repository;
+using Quartz;
+using PlexMediaType = Ombi.Api.Models.Plex.PlexMediaType;
+
+namespace Ombi.Services.Jobs
+{
+    public class PlexContentCacher : IJob, IPlexContentCacher
+    {
+        public PlexContentCacher(ISettingsService<PlexSettings> plexSettings, IRequestService request, IPlexApi plex, ICacheProvider cache,
+            INotificationService notify, IJobRecord rec, IRepository<UsersToNotify> users, IRepository<PlexEpisodes> repo, IPlexNotificationEngine e, IRepository<PlexContent> content)
+        {
+            Plex = plexSettings;
+            RequestService = request;
+            PlexApi = plex;
+            Cache = cache;
+            Notification = notify;
+            Job = rec;
+            UserNotifyRepo = users;
+            EpisodeRepo = repo;
+            NotificationEngine = e;
+            PlexContent = content;
+        }
+
+        private ISettingsService<PlexSettings> Plex { get; }
+        private IRepository<PlexEpisodes> EpisodeRepo { get; }
+        private IRequestService RequestService { get; }
+        private static Logger Log = LogManager.GetCurrentClassLogger();
+        private IPlexApi PlexApi { get; }
+        private ICacheProvider Cache { get; }
+        private INotificationService Notification { get; }
+        private IJobRecord Job { get; }
+        private IRepository<UsersToNotify> UserNotifyRepo { get; }
+        private INotificationEngine NotificationEngine { get; }
+        private IRepository<PlexContent> PlexContent { get; }
+
+        public void CacheContent()
+        {
+            var plexSettings = Plex.GetSettings();
+            if (!plexSettings.Enable)
+            {
+                return;
+            }
+            if (!ValidateSettings(plexSettings))
+            {
+                Log.Debug("Validation of the plex settings failed.");
+                return;
+            }
+            var libraries = CachedLibraries(plexSettings); 
+
+            if (libraries == null || !libraries.Any())
+            {
+                Log.Debug("Did not find any libraries in Plex.");
+                return;
+            }
+        }
+
+
+        public List<PlexMovie> GetPlexMovies(List<PlexSearch> libs)
+        {
+            var settings = Plex.GetSettings();
+            var movies = new List<PlexMovie>();
+            if (libs != null)
+            {
+                var movieLibs = libs.Where(x =>
+                        x.Video.Any(y =>
+                            y.Type.Equals(PlexMediaType.Movie.ToString(), StringComparison.CurrentCultureIgnoreCase)
+                        )
+                    ).ToArray();
+
+                foreach (var lib in movieLibs)
+                {
+                    movies.AddRange(lib.Video.Select(video => new PlexMovie
+                    {
+                        ReleaseYear = video.Year,
+                        Title = video.Title,
+                        ProviderId = video.ProviderId,
+                        Url = PlexHelper.GetPlexMediaUrl(settings.MachineIdentifier, video.RatingKey),
+                        ItemId =  video.RatingKey
+                    }));
+                }
+            }
+            return movies;
+        }
+
+        public List<PlexTvShow> GetPlexTvShows(List<PlexSearch> libs)
+        {
+            var settings = Plex.GetSettings();
+            var shows = new List<PlexTvShow>();
+            if (libs != null)
+            {
+                var withDir = libs.Where(x => x.Directory != null);
+                var tvLibs = withDir.Where(x =>
+                        x.Directory.Any(y =>
+                            y.Type.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase)
+                        )
+                    ).ToArray();
+
+                foreach (var lib in tvLibs)
+                {
+
+                    shows.AddRange(lib.Directory.Select(x => new PlexTvShow // shows are in the directory list
+                    {
+                        Title = x.Title,
+                        ReleaseYear = x.Year,
+                        ProviderId = x.ProviderId,
+                        Seasons = x.Seasons?.Select(d => PlexHelper.GetSeasonNumberFromTitle(d.Title)).ToArray(),
+                        Url = PlexHelper.GetPlexMediaUrl(settings.MachineIdentifier, x.RatingKey),
+                        ItemId= x.RatingKey
+
+                    }));
+                }
+            }
+            return shows;
+        }
+
+        
+
+
+        public List<PlexAlbum> GetPlexAlbums(List<PlexSearch> libs)
+        {
+            var settings = Plex.GetSettings();
+            var albums = new List<PlexAlbum>();
+            if (libs != null)
+            {
+                var albumLibs = libs.Where(x =>
+                        x.Directory.Any(y =>
+                            y.Type.Equals(PlexMediaType.Artist.ToString(), StringComparison.CurrentCultureIgnoreCase)
+                        )
+                    ).ToArray();
+
+                foreach (var lib in albumLibs)
+                {
+                    albums.AddRange(lib.Directory.Select(x => new PlexAlbum()
+                    {
+                        Title = x.Title,
+                        ProviderId = x.ProviderId,
+                        ReleaseYear = x.Year,
+                        Artist = x.ParentTitle,
+                        Url = PlexHelper.GetPlexMediaUrl(settings.MachineIdentifier, x.RatingKey)
+                    }));
+                }
+            }
+            return albums;
+        }
+
+
+
+        private List<PlexSearch> CachedLibraries(PlexSettings plexSettings)
+        {
+            var results = new List<PlexSearch>();
+
+            if (!ValidateSettings(plexSettings))
+            {
+                Log.Warn("The settings are not configured");
+                return results; // don't error out here, just let it go! let it goo!!!
+            }
+
+            try
+            {
+                results = GetLibraries(plexSettings);
+                if (plexSettings.AdvancedSearch)
+                {
+                    Log.Debug("Going through all the items now");
+                    Log.Debug($"Item count {results.Count}");
+                    foreach (PlexSearch t in results)
+                    {
+                        foreach (Directory1 t1 in t.Directory)
+                        {
+                            var currentItem = t1;
+                            var metaData = PlexApi.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri,
+                                currentItem.RatingKey);
+
+                            // Get the seasons for each show
+                            if (currentItem.Type.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase))
+                            {
+                                var seasons = PlexApi.GetSeasons(plexSettings.PlexAuthToken, plexSettings.FullUri,
+                                    currentItem.RatingKey);
+
+                                // We do not want "all episodes" this as a season
+                                var filtered = seasons.Directory.Where(x => !x.Title.Equals("All episodes", StringComparison.CurrentCultureIgnoreCase));
+
+                                t1.Seasons.AddRange(filtered);
+                            }
+
+                            var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Directory.Guid);
+                            t1.ProviderId = providerId;
+                        }
+                        foreach (Video t1 in t.Video)
+                        {
+                            var currentItem = t1;
+                            var metaData = PlexApi.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri,
+                                currentItem.RatingKey);
+                            var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Video.Guid);
+                            t1.ProviderId = providerId;
+                        }
+                    }
+                }
+                if (results != null)
+                {
+                    Log.Debug("done all that, moving onto the DB now");
+                    var movies = GetPlexMovies(results);
+
+                    // Time to destroy the plex movies from the DB
+                    PlexContent.Custom(connection =>
+                    {
+                        connection.Open();
+                        connection.Query("delete from PlexContent where type = @type", new { type = 0 });
+                        return new List<PlexContent>();
+                    });
+
+                    foreach (var m in movies)
+                    {
+                        if (string.IsNullOrEmpty(m.ProviderId))
+                        {
+                            Log.Error("Provider Id on movie {0} is null",m.Title);
+                            continue;
+                        }
+
+                        // Check if it exists
+                        var item = PlexContent.Custom(connection =>
+                        {
+                            connection.Open();
+                            var media =  connection.QueryFirstOrDefault<PlexContent>("select * from PlexContent where ProviderId = @ProviderId and type = @type", new { m.ProviderId, type = 0 });
+                            connection.Dispose();
+                            return media;
+                        });
+
+                        if (item == null && !string.IsNullOrEmpty(m.ItemId))
+                        { 
+                            // Doesn't exist, insert it
+                            PlexContent.Insert(new PlexContent
+                            {
+                                ProviderId = m.ProviderId,
+                                ReleaseYear = m.ReleaseYear ?? string.Empty,
+                                Title = m.Title,
+                                Type = Store.Models.Plex.PlexMediaType.Movie,
+                                Url = m.Url,
+                                ItemId = m.ItemId,
+                                AddedAt = DateTime.UtcNow,
+                            });
+                        }
+                    }
+
+                    Log.Debug("Done movies");
+                    var tv = GetPlexTvShows(results);
+                    // Time to destroy the plex tv from the DB
+                    PlexContent.Custom(connection =>
+                    {
+                        connection.Open();
+                        connection.Query("delete from PlexContent where type = @type", new { type = 1 });
+                        return new List<PlexContent>();
+                    });
+                    foreach (var t in tv)
+                    {
+                        if (string.IsNullOrEmpty(t.ProviderId))
+                        {
+                            Log.Error("Provider Id on tv {0} is null", t.Title);
+                            continue;
+                        }
+
+
+                        // Check if it exists
+                        var item = PlexContent.Custom(connection =>
+                        {
+                            connection.Open();
+                            var media = connection.QueryFirstOrDefault<PlexContent>("select * from PlexContent where ProviderId = @ProviderId and type = @type", new { t.ProviderId, type = 1 });
+                            connection.Dispose();
+                            return media;
+                        });
+
+                        if (item == null && !string.IsNullOrEmpty(t.ItemId))
+                        {
+                            PlexContent.Insert(new PlexContent
+                            {
+                                ProviderId = t.ProviderId,
+                                ReleaseYear = t.ReleaseYear ?? string.Empty,
+                                Title = t.Title,
+                                Type = Store.Models.Plex.PlexMediaType.Show,
+                                Url = t.Url,
+                                Seasons = ByteConverterHelper.ReturnBytes(t.Seasons),
+                                ItemId = t.ItemId,
+                                AddedAt = DateTime.UtcNow,
+                            });
+                        }
+                    }
+                    Log.Debug("Done TV");
+                    var albums = GetPlexAlbums(results);
+                    // Time to destroy the plex movies from the DB
+                    PlexContent.Custom(connection =>
+                    {
+                        connection.Open();
+                        connection.Query("delete from PlexContent where type = @type", new { type = 2 });
+                        return new List<PlexContent>();
+                    });
+
+                    foreach (var a in albums)
+                    {
+                        if (string.IsNullOrEmpty(a.ProviderId))
+                        {
+                            Log.Error("Provider Id on album {0} is null", a.Title);
+                            continue;
+                        }
+
+
+                        // Check if it exists
+                        var item = PlexContent.Custom(connection =>
+                        {
+                            connection.Open();
+                            var media = connection.QueryFirstOrDefault<PlexContent>("select * from PlexContent where ProviderId = @ProviderId and type = @type", new { a.ProviderId, type = 2 });
+                            connection.Dispose();
+                            return media;
+                        });
+
+                        if (item == null)
+                        {
+
+                            PlexContent.Insert(new PlexContent
+                            {
+                                ProviderId = a.ProviderId,
+                                ReleaseYear = a.ReleaseYear ?? string.Empty,
+                                Title = a.Title,
+                                Type = Store.Models.Plex.PlexMediaType.Artist,
+                                Url = a.Url,
+                                ItemId = "album",
+                                AddedAt = DateTime.UtcNow,
+                            });
+                        }
+                    }
+                    Log.Debug("Done albums");
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Debug("Exception:");
+                Log.Debug(ex);
+                Log.Error(ex, "Failed to obtain Plex libraries");
+            }
+
+            return results;
+        }
+
+        private List<PlexSearch> GetLibraries(PlexSettings plexSettings)
+        {
+            Log.Debug("Getting Lib sections");
+            var sections = PlexApi.GetLibrarySections(plexSettings.PlexAuthToken, plexSettings.FullUri);
+            
+            Log.Debug("Going through sections now");
+            var libs = new List<PlexSearch>();
+            if (sections != null)
+            {
+                foreach (var dir in sections.Directories ?? new List<Directory>())
+                {
+                    var lib = PlexApi.GetLibrary(plexSettings.PlexAuthToken, plexSettings.FullUri, dir.Key);
+                    if (lib != null)
+                    {
+                        Log.Debug("adding lib");
+                        libs.Add(lib);
+                    }
+                }
+            }
+
+            return libs;
+        }
+
+        private bool ValidateSettings(PlexSettings plex)
+        {
+            if (plex.Enable)
+            {
+                if (plex?.Ip == null || plex?.PlexAuthToken == null)
+                {
+                    Log.Warn("A setting is null, Ensure Plex is configured correctly, and we have a Plex Auth token.");
+                    return false;
+                }
+            }
+            return plex.Enable;
+        }
+
+        public void Execute(IJobExecutionContext context)
+        {
+
+            Job.SetRunning(true, JobNames.PlexCacher);
+            try
+            {
+                CacheContent();
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+            }
+            finally
+            {
+                Job.Record(JobNames.PlexCacher);
+                Job.SetRunning(false, JobNames.PlexCacher);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ombi.Services/Jobs/RecentlyAddedNewsletter/EmbyRecentlyAddedNewsletter.cs b/Ombi.Services/Jobs/RecentlyAddedNewsletter/EmbyRecentlyAddedNewsletter.cs
new file mode 100644
index 000000000..158d77f0d
--- /dev/null
+++ b/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>");
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Ombi.Services/Jobs/RecentlyAddedNewsletter/PlexRecentlyAddedNewsletter.cs b/Ombi.Services/Jobs/RecentlyAddedNewsletter/PlexRecentlyAddedNewsletter.cs
new file mode 100644
index 000000000..ca88b4c2b
--- /dev/null
+++ b/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>");
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/Ombi.UI/Views/About/About.cshtml b/Ombi.UI/Views/About/About.cshtml
new file mode 100644
index 000000000..ad65912c0
--- /dev/null
+++ b/Ombi.UI/Views/About/About.cshtml
@@ -0,0 +1,227 @@
+@using Ombi.UI.Helpers
+@inherits Nancy.ViewEngines.Razor.NancyRazorViewBase<Ombi.UI.Models.AboutAdminViewModel>
+@Html.Partial("Shared/Partial/_Sidebar")
+@Html.LoadAsset("/Content/helpers/bootbox.min.js", true)
+<div id="lightbox" style="display:none"></div>
+<div class="col-sm-8 col-sm-push-1">
+    <fieldset>
+        <legend>About</legend>
+        <hr />
+        <table class="table table-condensed">
+            <tr>
+                <td>
+                    Application Version:
+                </td>
+                <td>
+                    @Model.ApplicationVersion
+                </td>
+            </tr>
+
+            <tr>
+                <td>
+                    OS:
+                </td>
+                <td>
+                    @Model.Os
+                </td>
+            </tr>
+
+            <tr>
+                <td>
+                    System Version:
+                </td>
+                <td>
+                    @Model.SystemVersion
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Branch:
+                </td>
+                <td>
+                    @Model.Branch
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Log Level:
+                </td>
+                <td>
+                    @Model.LogLevel
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Database Location:
+                </td>
+                <td>
+                    @Model.DbLocation
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Running Directory:
+                </td>
+                <td>
+                    @Model.RunningDir
+                </td>
+            </tr>
+
+        </table>
+        <hr />
+        <table class="table table-condensed">
+            <tr>
+                <td>
+                    Github
+                </td>
+                <td>
+                    <a href="https://github.com/tidusjar/Ombi" target="_blank">https://github.com/tidusjar/Ombi</a>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Forums
+                </td>
+                <td>
+                    <a href="https://forums.ombi.io/" target="_blank">https://forums.ombi.io/</a>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Wiki
+                </td>
+                <td>
+                    <a href="https://github.com/tidusjar/Ombi/wiki" target="_blank">https://github.com/tidusjar/Ombi/wiki</a>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Issues
+                </td>
+                <td>
+                    <a href="https://github.com/tidusjar/Ombi/issues" target="_blank">https://github.com/tidusjar/Ombi/issues</a>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Chat
+                </td>
+                <td>
+                    <a href="https://gitter.im/tidusjar/Ombi" target="_blank">https://gitter.im/tidusjar/Ombi</a>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    Feature Requests
+                </td>
+                <td>
+                    <a href="https://feathub.com/tidusjar/Ombi" target="_blank">https://feathub.com/tidusjar/Ombi</a>
+                </td>
+            </tr>
+        </table>
+        <hr />
+        @if (Model.OAuthEnabled)
+            {
+            <div class="form-group">
+                <div>
+                    <button id="save" type="submit" class="btn btn-danger-outline">Report a bug</button>
+                </div>
+            </div>
+
+        }
+        else
+        {
+            <div class="form-group">
+                <div>
+                    <button id="oAuth" type="submit" class="btn btn-primary-outline">Log in via Github to Report an Issue</button>
+                </div>
+            </div>
+        }
+   
+
+    </fieldset>
+</div>
+
+<script>
+
+    var issueTitle = "";
+
+    var baseUrl = '@Html.GetBaseUrl()';
+
+    $('#save').click(function () {
+        startBug();
+    });
+
+    $('#oAuth').click(function () {
+        var url = "/admin/oauth";
+        url = createBaseUrl(baseUrl, url);
+        $.ajax({
+            type: "get",
+            url: url,
+            dataType: "json",
+            success: function (response) {
+                window.location.href = response.uri;
+            },
+            error: function (e) {
+                console.log(e);
+                generateNotify("Something went wrong!", "danger");
+            }
+        });
+    });
+
+    function startBug() {
+        bootbox.prompt({
+            size: "small",
+            title: "What is the title of the issue?",
+            inputType: 'textarea',
+            callback: mainContent
+        });
+    }
+
+
+    function mainContent(userTitle) {
+        if (!userTitle) {
+            generateNotify("Please provide a valid title", "danger");
+            return startBug();
+        }
+        issueTitle = userTitle;
+        bootbox.prompt({
+            title: "Please provide details of the issue including any logs and reproduction steps",
+            inputType: 'textarea',
+            callback: reportBug
+        });
+
+
+    }
+
+    function reportBug(additionalInfo) {
+
+        if (!additionalInfo) {
+            generateNotify("Please provide some information", "danger");
+            return mainContent();
+        }
+
+
+        var url = "/admin/about";
+        url = createBaseUrl(baseUrl, url);
+        $.ajax({
+            type: "post",
+            url: url,
+            data: { title: issueTitle, body: additionalInfo },
+            dataType: "json",
+            success: function (response) {
+                if (response && response.result) {
+                    generateNotify("Issue Reported, see here: " + response.url);
+                } else {
+                    if (response.message) {
+                        generateNotify(response.message, "danger");
+                    }
+                }
+            },
+            error: function (e) {
+                console.log(e);
+                generateNotify("Something went wrong!", "danger");
+            }
+        });
+    }
+</script>
\ No newline at end of file
diff --git a/README.md b/README.md
index 9ec603bff..a0fca5beb 100644
--- a/README.md
+++ b/README.md
@@ -9,8 +9,14 @@ ____
 [![Patreon](https://www.ombi.io/img/patreondonate.svg)](https://patreon.com/tidusjar/Ombi)
 [![Paypal](https://www.ombi.io/img/paypaldonate.svg)](https://paypal.me/PlexRequestsNet)
 
-[![Report a bug](http://i.imgur.com/xSpw482.png)](https://github.com/tidusjar/Ombi/issues/new) [![Feature request](http://i.imgur.com/mFO0OuX.png)](http://feathub.com/tidusjar/Ombi)
+[![Patreon](https://www.ombi.io/img/patreondonate.svg)](https://patreon.com/tidusjar/Ombi)
+[![Paypal](https://www.ombi.io/img/paypaldonate.svg)](https://paypal.me/PlexRequestsNet)
+___
+
 
+[![Report a bug](http://i.imgur.com/xSpw482.png)](https://forums.ombi.io/viewforum.php?f=10) [![Feature request](http://i.imgur.com/mFO0OuX.png)](https://forums.ombi.io/posting.php?mode=post&f=20)
+
+<<<<<<< HEAD
 
 | Service  | Master (V2)                | Open Beta     (V3 - Recommended)          |
 |----------|:---------------------------:|:----------------------------:|
@@ -20,6 +26,21 @@ ____
 Here are some of the features Ombi V3 has:
 * Now working without crashes on Linux.
 * Lets users request Movies and TV Shows (whether it being the entire series, an entire season, or even single episodes.)
+=======
+| Service  | Master                      | Early Access                 | Dev                          |
+|----------|:---------------------------:|:----------------------------:|:----------------------------:|
+| AppVeyor | [![Build status](https://ci.appveyor.com/api/projects/status/hgj8j6lcea7j0yhn/branch/master?svg=true)](https://ci.appveyor.com/project/tidusjar/requestplex/branch/master) | [![Build status](https://ci.appveyor.com/api/projects/status/hgj8j6lcea7j0yhn/branch/eap?svg=true)](https://ci.appveyor.com/project/tidusjar/requestplex/branch/eap) | [![Build status](https://ci.appveyor.com/api/projects/status/hgj8j6lcea7j0yhn/branch/dev?svg=true)](https://ci.appveyor.com/project/tidusjar/requestplex/branch/dev)
+| Download |[![Download](http://i.imgur.com/odToka3.png)](https://github.com/tidusjar/Ombi/releases)             |      [![Download](http://i.imgur.com/odToka3.png)](https://ci.appveyor.com/project/tidusjar/requestplex/branch/eap/artifacts)       |  [![Download](http://i.imgur.com/odToka3.png)](https://ci.appveyor.com/project/tidusjar/requestplex/branch/dev/artifacts)            |
+
+We now have a forums!
+Check it out: [https://forums.ombi.io/](https://forums.ombi.io)
+
+Want to keep up to date with the rewrite? Follow [this issue](https://github.com/tidusjar/Ombi/issues/865)
+
+# Features
+Here some of the features Ombi has:
+* All your users to Request Movies, TV Shows (Whole series, whole seasons or even single episodes!) and Albums
+>>>>>>> origin/master
 * Easily manage your requests
 * User management system (supports plex.tv, Emby and local accounts)
 * A landing page that will give you the availability of your Plex/Emby server and also add custom notification text to inform your users of downtime.
@@ -90,8 +111,20 @@ Search the existing requests to see if your suggestion has already been submitte
 
 # Installation
 
+<<<<<<< HEAD
 [Click Here](https://github.com/tidusjar/Ombi/wiki/Installation)
 [Here for Reverse Proxy Config Examples](https://github.com/tidusjar/Ombi/wiki/Reverse-Proxy-Examples)
+=======
+[Windows Guide!](https://forums.ombi.io/viewtopic.php?f=6&t=4)  
+[Ubuntu Guide!](http://www.htpcguides.com/install-plex-requests-net-ubuntu-14-x/)
+
+# FAQ
+Do you have an issue or a question? if so check out our [FAQ](https://github.com/tidusjar/Ombi/wiki/FAQ)!
+
+# Docker
+
+Looking for a Docker Image? Well [rogueosb](https://github.com/rogueosb/) has created a docker image for us, You can find it [here](https://github.com/rogueosb/docker-plexrequestsnet) :smile:
+>>>>>>> origin/master
 
 # Contributors
 
diff --git a/appveyor.yml b/appveyor.yml
index 06f93f7b1..a9c94fc07 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,5 +1,6 @@
-version: 3.0.{build}
+version: 2.2.{build}
 configuration: Release
+<<<<<<< HEAD
 os: Visual Studio 2017
 environment:
   nodejs_version: "7.8.0"
@@ -22,14 +23,33 @@ after_build:
     
     
     appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\linux.tar.gz"
+=======
+assembly_info:
+  patch: true
+  file: '**\AssemblyInfo.*'
+  assembly_version: '2.2.1'
+  assembly_file_version: '{version}'
+  assembly_informational_version: '2.2.1'
+before_build:
+- cmd: appveyor-retry nuget restore
+build:
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a Ombi.zip %APPVEYOR_BUILD_FOLDER%\Ombi.UI\bin\Release\
+>>>>>>> origin/master
 
+    appveyor PushArtifact Ombi.zip
     
+<<<<<<< HEAD
     appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\linux-arm.tar.gz"
     
     
 
 #cache:
 #- '%USERPROFILE%\.nuget\packages'
+=======
+>>>>>>> origin/master
 deploy:
 - provider: GitHub
   release: Ombi v$(appveyor_build_version)
@@ -38,4 +58,11 @@ deploy:
   draft: true
   on:
     branch: master
+<<<<<<< HEAD
 
+=======
+- provider: Environment
+  name: Microserver
+  on:
+    branch: dev
+>>>>>>> origin/master