Merge pull request #2336 from tidusjar/develop

Develop

appveyor.yml

@@ -15,19 +15,19 @@ test: off
 after_build:
 - cmd: >-
     
-    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\windows.zip"
+    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.1\windows.zip"
     
     
-    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\osx.tar.gz"  
+    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.1\osx.tar.gz"  
     
     
-    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\linux.tar.gz"
+    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.1\linux.tar.gz"
 
     
-    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\linux-arm.tar.gz"
+    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.1\linux-arm.tar.gz"
 
     
-    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\windows-32bit.zip"
+    appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.1\windows-32bit.zip"
 
     
 #   appveyor PushArtifact "%APPVEYOR_BUILD_FOLDER%\src\Ombi\bin\Release\netcoreapp2.0\linux-arm64.tar.gz"

build.cake

@@ -26,7 +26,7 @@ var csProj = "./src/Ombi/Ombi.csproj";          // Path to the project.csproj
 var solutionFile = "Ombi.sln";                  // Solution file if needed
 GitVersion versionInfo = null;
 
-var frameworkVer = "netcoreapp2.0";
+var frameworkVer = "netcoreapp2.1";
 
 var buildSettings = new DotNetCoreBuildSettings
 {

src/Ombi.Api.Radarr/Ombi.Api.Radarr.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.1.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Ombi.Api.Service/Ombi.Api.Service.csproj

@@ -11,7 +11,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Options" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="2.1.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Ombi.Api/Ombi.Api.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="Polly" Version="5.8.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />

src/Ombi.Core.Tests/Ombi.Core.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>    
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

src/Ombi.Core/Ombi.Core.csproj

@@ -12,9 +12,9 @@
     <PackageReference Include="AutoMapper" Version="6.1.1" />
     <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="3.2.0" />
     <PackageReference Include="Hangfire" Version="1.6.19" />
-    <PackageReference Include="Microsoft.AspNetCore.Cryptography.KeyDerivation" Version="2.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Design" Version="1.1.5" />
+    <PackageReference Include="Microsoft.AspNetCore.Cryptography.KeyDerivation" Version="2.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Design" Version="2.0.0-preview1-final" />
     <PackageReference Include="MiniProfiler.AspNetCore" Version="4.0.0-alpha6-79" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="System.Diagnostics.Process" Version="4.3.0" />

src/Ombi.DependencyInjection/Ombi.DependencyInjection.csproj

@@ -9,9 +9,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.0.4" />
-    <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="2.0.4" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.1.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.1.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Ombi.Helpers/Ombi.Helpers.csproj

@@ -10,8 +10,8 @@
 
   <ItemGroup>
     <PackageReference Include="EasyCrypto" Version="3.3.2" />
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="Nito.AsyncEx" Version="5.0.0-pre-05" />
     <PackageReference Include="System.Security.Claims" Version="4.3.0" />

src/Ombi.Helpers/OmbiRoles.cs

@@ -11,6 +11,6 @@
         public const string RequestTv = nameof(RequestTv);
         public const string RequestMovie = nameof(RequestMovie);
         public const string Disabled = nameof(Disabled);
-        public const string RecievesNewsletter = nameof(RecievesNewsletter);
+        public const string ReceivesNewsletter = nameof(ReceivesNewsletter);
     }
 }

src/Ombi.Notifications.Tests/Ombi.Notifications.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

src/Ombi.Notifications/NotificationMessageCurlys.cs

@@ -44,8 +44,17 @@ namespace Ombi.Notifications
             }
             Overview = req?.Overview;
             Year = req?.ReleaseDate.Year.ToString();
-            PosterImage = req?.RequestType == RequestType.Movie ?
-                string.Format("https://image.tmdb.org/t/p/w300{0}", req?.PosterPath) : req?.PosterPath;
+
+            if (req?.RequestType == RequestType.Movie)
+            {
+                PosterImage = string.Format((req?.PosterPath ?? string.Empty).StartsWith("/", StringComparison.InvariantCultureIgnoreCase) 
+                    ? "https://image.tmdb.org/t/p/w300{0}" : "https://image.tmdb.org/t/p/w300/{0}", req?.PosterPath);
+            }
+            else
+            {
+                PosterImage = req?.PosterPath;
+            }
+            
             AdditionalInformation = opts?.AdditionalInformation ?? string.Empty;
         }
 
@@ -88,8 +97,15 @@ namespace Ombi.Notifications
 
             Overview = req?.ParentRequest.Overview;
             Year = req?.ParentRequest.ReleaseDate.Year.ToString();
-            PosterImage = req?.RequestType == RequestType.Movie ?
-                $"https://image.tmdb.org/t/p/w300{req?.ParentRequest.PosterPath}" : req?.ParentRequest.PosterPath;
+            if (req?.RequestType == RequestType.Movie)
+            {
+                PosterImage = string.Format((req?.ParentRequest.PosterPath ?? string.Empty).StartsWith("/", StringComparison.InvariantCultureIgnoreCase)
+                    ? "https://image.tmdb.org/t/p/w300{0}" : "https://image.tmdb.org/t/p/w300/{0}", req?.ParentRequest.PosterPath);
+            }
+            else
+            {
+                PosterImage = req?.ParentRequest.PosterPath;
+            }
             AdditionalInformation = opts.AdditionalInformation;
             // DO Episode and Season Lists
 
@@ -133,6 +149,8 @@ namespace Ombi.Notifications
             ApplicationUrl = (s?.ApplicationUrl.HasValue() ?? false) ? s.ApplicationUrl : string.Empty;
             ApplicationName = string.IsNullOrEmpty(s?.ApplicationName) ? "Ombi" : s?.ApplicationName;
             RequestedUser = user.UserName;
+            Alias = user.UserAlias;
+            UserName = user.UserName;
         }
 
         private void LoadIssues(NotificationOptions opts)

src/Ombi.Notifications/Ombi.Notifications.csproj

@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Ensure.That" Version="7.0.0-pre32" />
-    <PackageReference Include="MailKit" Version="2.0.3" />
+    <PackageReference Include="MailKit" Version="2.0.4" />
   </ItemGroup>
 
   <ItemGroup>

src/Ombi.Schedule.Tests/Ombi.Schedule.Tests.csproj

@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore" Version="2.1.0" />
     <PackageReference Include="Moq" Version="4.7.99" />
     <PackageReference Include="Nunit" Version="3.10.1" />
     <PackageReference Include="NUnit.ConsoleRunner" Version="3.8.0" />

src/Ombi.Schedule/Jobs/Ombi/NewsletterJob.cs

@@ -131,7 +131,7 @@ namespace Ombi.Schedule.Jobs.Ombi
                 if (!test)
                 {
                     // Get the users to send it to
-                    var users = await _userManager.GetUsersInRoleAsync(OmbiRoles.RecievesNewsletter);
+                    var users = await _userManager.GetUsersInRoleAsync(OmbiRoles.ReceivesNewsletter);
                     if (!users.Any())
                     {
                         return;

src/Ombi.Schedule/Jobs/Plex/Interfaces/IPlexAvailabilityChecker.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace Ombi.Schedule.Jobs.Plex
 {

src/Ombi.Schedule/Jobs/Plex/Interfaces/IPlexEpisodeSync.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Ombi.Api.Plex.Models;
@@ -9,6 +10,6 @@ namespace Ombi.Schedule.Jobs.Plex.Interfaces
     public interface IPlexEpisodeSync : IBaseJob
     {
         Task Start();
-        Task ProcessEpsiodes(Metadata[] episodes, IQueryable<PlexEpisode> currentEpisodes);
+        Task<HashSet<PlexEpisode>> ProcessEpsiodes(Metadata[] episodes, IQueryable<PlexEpisode> currentEpisodes);
     }
 }

src/Ombi.Schedule/Jobs/Plex/Models/ProcessedContent.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ombi.Schedule.Jobs.Plex.Models
+{
+    public class ProcessedContent
+    {
+        public IEnumerable<int> Content { get; set; }
+        public IEnumerable<int> Episodes { get; set; }
+
+        public bool HasProcessedContent => Content.Any();
+        public bool HasProcessedEpisodes => Episodes.Any();
+    }
+}

src/Ombi.Schedule/Jobs/Plex/PlexAvailabilityChecker.cs

@@ -4,10 +4,12 @@ using System.Linq;
 using System.Threading.Tasks;
 using Hangfire;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Ombi.Core.Notifications;
 using Ombi.Helpers;
 using Ombi.Notifications.Models;
 using Ombi.Store.Entities;
+using Ombi.Store.Entities.Requests;
 using Ombi.Store.Repository;
 using Ombi.Store.Repository.Requests;
 
@@ -16,13 +18,14 @@ namespace Ombi.Schedule.Jobs.Plex
     public class PlexAvailabilityChecker : IPlexAvailabilityChecker
     {
         public PlexAvailabilityChecker(IPlexContentRepository repo, ITvRequestRepository tvRequest, IMovieRequestRepository movies,
-            INotificationService notification, IBackgroundJobClient background)
+            INotificationService notification, IBackgroundJobClient background, ILogger<PlexAvailabilityChecker> log)
         {
             _tvRepo = tvRequest;
             _repo = repo;
             _movieRepo = movies;
             _notificationService = notification;
             _backgroundJobClient = background;
+            _log = log;
         }
 
         private readonly ITvRequestRepository _tvRepo;
@@ -30,16 +33,29 @@ namespace Ombi.Schedule.Jobs.Plex
         private readonly IPlexContentRepository _repo;
         private readonly INotificationService _notificationService;
         private readonly IBackgroundJobClient _backgroundJobClient;
+        private readonly ILogger _log;
 
         public async Task Start()
         {
-            await ProcessMovies();
-            await ProcessTv();
+            try
+            {
+                await ProcessMovies();
+                await ProcessTv();
+            }
+            catch (Exception e)
+            {
+                _log.LogError(e, "Exception thrown in Plex availbility checker");
+            }
         }
 
-        private async Task ProcessTv()
+        private Task ProcessTv()
         {
             var tv = _tvRepo.GetChild().Where(x => !x.Available);
+            return ProcessTv(tv);
+        }
+
+        private async Task ProcessTv(IQueryable<ChildRequests> tv)
+        {
             var plexEpisodes = _repo.GetAllEpisodes().Include(x => x.Series);
 
             foreach (var child in tv)
@@ -81,6 +97,10 @@ namespace Ombi.Schedule.Jobs.Plex
                 {
                     foreach (var episode in season.Episodes)
                     {
+                        if (episode.Available)
+                        {
+                            continue;
+                        }
                         var foundEp = await seriesEpisodes.FirstOrDefaultAsync(
                             x => x.EpisodeNumber == episode.EpisodeNumber &&
                                  x.SeasonNumber == episode.Season.SeasonNumber);

src/Ombi.Schedule/Jobs/Plex/PlexContentSync.cs

@@ -39,6 +39,7 @@ using Ombi.Core.Settings.Models.External;
 using Ombi.Helpers;
 using Ombi.Schedule.Jobs.Ombi;
 using Ombi.Schedule.Jobs.Plex.Interfaces;
+using Ombi.Schedule.Jobs.Plex.Models;
 using Ombi.Store.Entities;
 using Ombi.Store.Repository;
 
@@ -47,7 +48,7 @@ namespace Ombi.Schedule.Jobs.Plex
     public class PlexContentSync : IPlexContentSync
     {
         public PlexContentSync(ISettingsService<PlexSettings> plex, IPlexApi plexApi, ILogger<PlexContentSync> logger, IPlexContentRepository repo,
-            IPlexEpisodeSync epsiodeSync, IRefreshMetadata metadataRefresh)
+            IPlexEpisodeSync epsiodeSync, IRefreshMetadata metadataRefresh, IPlexAvailabilityChecker checker)
         {
             Plex = plex;
             PlexApi = plexApi;
@@ -55,6 +56,7 @@ namespace Ombi.Schedule.Jobs.Plex
             Repo = repo;
             EpisodeSync = epsiodeSync;
             Metadata = metadataRefresh;
+            Checker = checker;
             plex.ClearCache();
         }
 
@@ -64,6 +66,7 @@ namespace Ombi.Schedule.Jobs.Plex
         private IPlexContentRepository Repo { get; }
         private IPlexEpisodeSync EpisodeSync { get; }
         private IRefreshMetadata Metadata { get; }
+        private IPlexAvailabilityChecker Checker { get; }
 
         public async Task CacheContent(bool recentlyAddedSearch = false)
         {
@@ -77,17 +80,13 @@ namespace Ombi.Schedule.Jobs.Plex
                 Logger.LogError("Plex Settings are not valid");
                 return;
             }
-            var processedContent = new HashSet<int>();
+            var processedContent = new ProcessedContent();
             Logger.LogInformation("Starting Plex Content Cacher");
             try
             {
                 if (recentlyAddedSearch)
                 {
-                    var result = await StartTheCache(plexSettings, true);
-                    foreach (var r in result)
-                    {
-                        processedContent.Add(r);
-                    }
+                    processedContent = await StartTheCache(plexSettings, true);
                 }
                 else
                 {
@@ -105,31 +104,32 @@ namespace Ombi.Schedule.Jobs.Plex
                 BackgroundJob.Enqueue(() => EpisodeSync.Start());
             }
 
-            if (processedContent.Any() && recentlyAddedSearch)
+            if (processedContent.HasProcessedContent && recentlyAddedSearch)
             {
                 // Just check what we send it
-                BackgroundJob.Enqueue(() => Metadata.ProcessPlexServerContent(processedContent));
+                BackgroundJob.Enqueue(() => Metadata.ProcessPlexServerContent(processedContent.Content));
+            }
+
+            if (processedContent.HasProcessedEpisodes && recentlyAddedSearch)
+            {
+                BackgroundJob.Enqueue(() => Checker.Start());
             }
         }
 
-        private async Task<IEnumerable<int>> StartTheCache(PlexSettings plexSettings, bool recentlyAddedSearch)
+        private async Task<ProcessedContent> StartTheCache(PlexSettings plexSettings, bool recentlyAddedSearch)
         {
-            var processedContent = new HashSet<int>();
+            var processedContent = new ProcessedContent();
             foreach (var servers in plexSettings.Servers ?? new List<PlexServers>())
             {
                 try
                 {
-                    Logger.LogInformation("Starting to cache the content on server {0}", servers.Name); 
-                    
+                    Logger.LogInformation("Starting to cache the content on server {0}", servers.Name);
+
                     if (recentlyAddedSearch)
                     {
                         // If it's recently added search then we want the results to pass to the metadata job
                         // This way the metadata job is smaller in size to process, it only need to look at newly added shit
-                        var result = await ProcessServer(servers, true);
-                        foreach (var plexServerContent in result)
-                        {
-                            processedContent.Add(plexServerContent);
-                        }
+                        return await ProcessServer(servers, true);
                     }
                     else
                     {
@@ -145,9 +145,11 @@ namespace Ombi.Schedule.Jobs.Plex
             return processedContent;
         }
 
-        private async Task<IEnumerable<int>> ProcessServer(PlexServers servers, bool recentlyAddedSearch)
+        private async Task<ProcessedContent> ProcessServer(PlexServers servers, bool recentlyAddedSearch)
         {
-            var processedContent = new Dictionary<int,int>();
+            var retVal = new ProcessedContent();
+            var contentProcessed = new Dictionary<int, int>();
+            var episodesProcessed = new List<int>();
             Logger.LogInformation("Getting all content from server {0}", servers.Name);
             var allContent = await GetAllContent(servers, recentlyAddedSearch);
             Logger.LogInformation("We found {0} items", allContent.Count);
@@ -170,12 +172,12 @@ namespace Ombi.Schedule.Jobs.Plex
                         // Lookup the rating key
                         var showMetadata = await PlexApi.GetMetadata(servers.PlexAuthToken, servers.FullUri, grandParentKey);
                         var show = showMetadata.MediaContainer.Metadata.FirstOrDefault();
-                        if(show == null)
+                        if (show == null)
                         {
                             continue;
                         }
 
-                        await ProcessTvShow(servers, show, contentToAdd, processedContent);
+                        await ProcessTvShow(servers, show, contentToAdd, contentProcessed);
                         if (contentToAdd.Any())
                         {
                             await Repo.AddRange(contentToAdd, false);
@@ -183,7 +185,7 @@ namespace Ombi.Schedule.Jobs.Plex
                             {
                                 foreach (var plexServerContent in contentToAdd)
                                 {
-                                    processedContent.Add(plexServerContent.Id, plexServerContent.Key);
+                                    contentProcessed.Add(plexServerContent.Id, plexServerContent.Key);
                                 }
                             }
                             contentToAdd.Clear();
@@ -198,7 +200,8 @@ namespace Ombi.Schedule.Jobs.Plex
                     // Save just to make sure we don't leave anything hanging
                     await Repo.SaveChangesAsync();
 
-                    await EpisodeSync.ProcessEpsiodes(content.Metadata, allEps);
+                    var episodesAdded = await EpisodeSync.ProcessEpsiodes(content.Metadata, allEps);
+                    episodesProcessed.AddRange(episodesAdded.Select(x => x.Id));
                 }
                 if (content.viewGroup.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase))
                 {
@@ -208,7 +211,7 @@ namespace Ombi.Schedule.Jobs.Plex
                     foreach (var show in content.Metadata ?? new Metadata[] { })
                     {
                         count++;
-                        await ProcessTvShow(servers, show, contentToAdd, processedContent);
+                        await ProcessTvShow(servers, show, contentToAdd, contentProcessed);
 
                         if (contentToAdd.Any())
                         {
@@ -217,7 +220,7 @@ namespace Ombi.Schedule.Jobs.Plex
                             {
                                 foreach (var plexServerContent in contentToAdd)
                                 {
-                                    processedContent.Add(plexServerContent.Id, plexServerContent.Key);
+                                    contentProcessed.Add(plexServerContent.Id, plexServerContent.Key);
                                 }
                             }
                             contentToAdd.Clear();
@@ -299,7 +302,7 @@ namespace Ombi.Schedule.Jobs.Plex
                             await Repo.AddRange(contentToAdd);
                             foreach (var c in contentToAdd)
                             {
-                                processedContent.Add(c.Id, c.Key);
+                                contentProcessed.Add(c.Id, c.Key);
                             }
                             contentToAdd.Clear();
                         }
@@ -310,7 +313,7 @@ namespace Ombi.Schedule.Jobs.Plex
                     await Repo.AddRange(contentToAdd);
                     foreach (var c in contentToAdd)
                     {
-                        processedContent.Add(c.Id, c.Key);
+                        contentProcessed.Add(c.Id, c.Key);
                     }
                     contentToAdd.Clear();
                 }
@@ -321,14 +324,16 @@ namespace Ombi.Schedule.Jobs.Plex
                 await Repo.AddRange(contentToAdd);
                 foreach (var c in contentToAdd)
                 {
-                    processedContent.Add(c.Id, c.Key);
+                    contentProcessed.Add(c.Id, c.Key);
                 }
             }
 
-            return processedContent.Values;
+            retVal.Content = contentProcessed.Values;
+            retVal.Episodes = episodesProcessed;
+            return retVal;
         }
 
-        private async Task ProcessTvShow(PlexServers servers, Metadata show, HashSet<PlexServerContent> contentToAdd, Dictionary<int,int> contentProcessed)
+        private async Task ProcessTvShow(PlexServers servers, Metadata show, HashSet<PlexServerContent> contentToAdd, Dictionary<int, int> contentProcessed)
         {
             var seasonList = await PlexApi.GetSeasons(servers.PlexAuthToken, servers.FullUri,
                 show.ratingKey);
@@ -349,7 +354,7 @@ namespace Ombi.Schedule.Jobs.Plex
             var existingContent = await Repo.GetFirstContentByCustom(x => x.Title == show.title
                                                                           && x.ReleaseYear == show.year.ToString()
                                                                           && x.Type == PlexMediaTypeEntity.Show);
-            
+
             // Just double check the rating key, since this is our unique constraint
             var existingKey = await Repo.GetByKey(show.ratingKey);
 
@@ -422,6 +427,26 @@ namespace Ombi.Schedule.Jobs.Plex
                         if (seasonExists != null)
                         {
                             // We already have this season
+                            // check if we have the episode
+                            //if (episode != null)
+                            //{
+                            //    var existing = existingContent.Episodes.Any(x =>
+                            //        x.SeasonNumber == episode.parentIndex && x.EpisodeNumber == episode.index);
+                            //    if (!existing)
+                            //    {
+                            //        // We don't have this episode, lets add it
+                            //        existingContent.Episodes.Add(new PlexEpisode
+                            //        {
+                            //            EpisodeNumber = episode.index,
+                            //            SeasonNumber = episode.parentIndex,
+                            //            GrandparentKey = episode.grandparentRatingKey,
+                            //            ParentKey = episode.parentRatingKey,
+                            //            Key = episode.ratingKey,
+                            //            Title = episode.title
+                            //        });
+                            //        itemAdded = true;
+                            //    }
+                            //}
                             continue;
                         }
 

src/Ombi.Schedule/Jobs/Plex/PlexEpisodeSync.cs

@@ -129,7 +129,7 @@ namespace Ombi.Schedule.Jobs.Plex
             await _repo.SaveChangesAsync();
         }
 
-        public async Task ProcessEpsiodes(Metadata[] episodes, IQueryable<PlexEpisode> currentEpisodes)
+        public async Task<HashSet<PlexEpisode>> ProcessEpsiodes(Metadata[] episodes, IQueryable<PlexEpisode> currentEpisodes)
         {
             var ep = new HashSet<PlexEpisode>();
             try
@@ -179,6 +179,7 @@ namespace Ombi.Schedule.Jobs.Plex
                 }
 
                 await _repo.AddRange(ep);
+                return ep;
             }
             catch (Exception e)
             {

src/Ombi.Settings/Ombi.Settings.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
   </ItemGroup>
 

src/Ombi.Store/Context/OmbiContext.cs

@@ -117,12 +117,12 @@ namespace Ombi.Store.Context
             Database.ExecuteSqlCommand("VACUUM;");
 
             // Make sure we have the roles
-            var roles = Roles.Where(x => x.Name == OmbiRoles.RecievesNewsletter);
+            var roles = Roles.Where(x => x.Name == OmbiRoles.ReceivesNewsletter);
             if (!roles.Any())
             {
-                Roles.Add(new IdentityRole(OmbiRoles.RecievesNewsletter)
+                Roles.Add(new IdentityRole(OmbiRoles.ReceivesNewsletter)
                 {
-                    NormalizedName = OmbiRoles.RecievesNewsletter.ToUpper()
+                    NormalizedName = OmbiRoles.ReceivesNewsletter.ToUpper()
                 });
                 SaveChanges();
             }

src/Ombi.Store/Migrations/20180613203443_RoleRename.Designer.cs

@@ -0,0 +1,981 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using Ombi.Helpers;
+using Ombi.Store.Context;
+using Ombi.Store.Entities;
+using Ombi.Store.Entities.Requests;
+using System;
+
+namespace Ombi.Store.Migrations
+{
+    [DbContext(typeof(OmbiContext))]
+    [Migration("20180613203443_RoleRename")]
+    partial class RoleRename
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.3-rtm-10026");
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.ApplicationConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationConfiguration");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Audit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AuditArea");
+
+                    b.Property<int>("AuditType");
+
+                    b.Property<DateTime>("DateTime");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("User");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Audit");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.CouchPotatoCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CouchPotatoCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("EmbyId")
+                        .IsRequired();
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Url");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyEpisode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("EmbyId");
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("ParentId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("EmbyEpisode");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.GlobalSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Content");
+
+                    b.Property<string>("SettingsName");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalSettings");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationTemplates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Agent");
+
+                    b.Property<bool>("Enabled");
+
+                    b.Property<string>("Message");
+
+                    b.Property<int>("NotificationType");
+
+                    b.Property<string>("Subject");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("NotificationTemplates");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("PlayerId");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("NotificationUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.OmbiUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("Alias");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<string>("EmbyConnectUserId");
+
+                    b.Property<int?>("EpisodeRequestLimit");
+
+                    b.Property<DateTime?>("LastLoggedIn");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<int?>("MovieRequestLimit");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<string>("ProviderUserId");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserAccessToken");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.Property<int>("UserType");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexEpisode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<int>("GrandparentKey");
+
+                    b.Property<int>("Key");
+
+                    b.Property<int>("ParentKey");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GrandparentKey");
+
+                    b.ToTable("PlexEpisode");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexSeasonsContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ParentKey");
+
+                    b.Property<int>("PlexContentId");
+
+                    b.Property<int?>("PlexServerContentId");
+
+                    b.Property<int>("SeasonKey");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexServerContentId");
+
+                    b.ToTable("PlexSeasonsContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexServerContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<int>("Key");
+
+                    b.Property<string>("Quality");
+
+                    b.Property<string>("ReleaseYear");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Url");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexServerContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RadarrCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("HasFile");
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RadarrCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RecentlyAddedLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<int>("ContentId");
+
+                    b.Property<int>("ContentType");
+
+                    b.Property<int?>("EpisodeNumber");
+
+                    b.Property<int?>("SeasonNumber");
+
+                    b.Property<int>("Type");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RecentlyAddedLog");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.ChildRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<bool?>("Denied");
+
+                    b.Property<string>("DeniedReason");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<int>("ParentRequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime>("RequestedDate");
+
+                    b.Property<string>("RequestedUserId");
+
+                    b.Property<int>("SeriesType");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentRequestId");
+
+                    b.HasIndex("RequestedUserId");
+
+                    b.ToTable("ChildRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("IssueCategory");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueComments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Comment");
+
+                    b.Property<DateTime>("Date");
+
+                    b.Property<int?>("IssuesId");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuesId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("IssueComments");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.Issues", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Description");
+
+                    b.Property<int>("IssueCategoryId");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<int?>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime?>("ResovledDate");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("Subject");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("UserReportedId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssueCategoryId");
+
+                    b.HasIndex("IssueId");
+
+                    b.HasIndex("UserReportedId");
+
+                    b.ToTable("Issues");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("Background");
+
+                    b.Property<bool?>("Denied");
+
+                    b.Property<string>("DeniedReason");
+
+                    b.Property<DateTime?>("DigitalReleaseDate");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<string>("Overview");
+
+                    b.Property<string>("PosterPath");
+
+                    b.Property<int>("QualityOverride");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime>("RequestedDate");
+
+                    b.Property<string>("RequestedUserId");
+
+                    b.Property<int>("RootPathOverride");
+
+                    b.Property<string>("Status");
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestedUserId");
+
+                    b.ToTable("MovieRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.RequestLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeCount");
+
+                    b.Property<DateTime>("RequestDate");
+
+                    b.Property<int>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RequestLog");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.TvRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Background");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("Overview");
+
+                    b.Property<string>("PosterPath");
+
+                    b.Property<int?>("QualityOverride");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<int?>("RootFolder");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("Title");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TvRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RequestSubscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RequestSubscription");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SickRageCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SickRageCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SickRageEpisodeCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SickRageEpisodeCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SonarrCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SonarrCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SonarrEpisodeCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<bool>("HasFile");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SonarrEpisodeCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Tokens", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Token");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Tokens");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.EpisodeRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AirDate");
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<bool>("Requested");
+
+                    b.Property<int>("SeasonId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("Url");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("EpisodeRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.SeasonRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ChildRequestId");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildRequestId");
+
+                    b.ToTable("SeasonRequests");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyEpisode", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.EmbyContent", "Series")
+                        .WithMany("Episodes")
+                        .HasForeignKey("ParentId")
+                        .HasPrincipalKey("EmbyId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationUserId", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany("NotificationUserIds")
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexEpisode", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.PlexServerContent", "Series")
+                        .WithMany("Episodes")
+                        .HasForeignKey("GrandparentKey")
+                        .HasPrincipalKey("Key")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexSeasonsContent", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.PlexServerContent")
+                        .WithMany("Seasons")
+                        .HasForeignKey("PlexServerContentId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.ChildRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.TvRequests", "ParentRequest")
+                        .WithMany("ChildRequests")
+                        .HasForeignKey("ParentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueComments", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.Issues", "Issues")
+                        .WithMany("Comments")
+                        .HasForeignKey("IssuesId");
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.Issues", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.IssueCategory", "IssueCategory")
+                        .WithMany()
+                        .HasForeignKey("IssueCategoryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests")
+                        .WithMany("Issues")
+                        .HasForeignKey("IssueId");
+
+                    b.HasOne("Ombi.Store.Entities.Requests.MovieRequests")
+                        .WithMany("Issues")
+                        .HasForeignKey("IssueId");
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "UserReported")
+                        .WithMany()
+                        .HasForeignKey("UserReportedId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.RequestLog", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RequestSubscription", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Tokens", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.EpisodeRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Repository.Requests.SeasonRequests", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.SeasonRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests", "ChildRequest")
+                        .WithMany("SeasonRequests")
+                        .HasForeignKey("ChildRequestId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Ombi.Store/Migrations/20180613203443_RoleRename.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace Ombi.Store.Migrations
+{
+    public partial class RoleRename : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+                UPDATE AspNetRoles
+SET Name = 'ReceivesNewsletter',
+NORMALIZEDNAME = 'RECEIVESNEWSLETTER'
+where Name = 'RecievesNewsletter'
+                ");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs

@@ -947,7 +947,7 @@ namespace Ombi.Store.Migrations
 
             modelBuilder.Entity("Ombi.Store.Entities.RequestSubscription", b =>
                 {
-                    b.HasOne("Ombi.Store.Entities.OmbiUser", "user")
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
                         .WithMany()
                         .HasForeignKey("UserId");
                 });

src/Ombi.Store/Ombi.Store.csproj

@@ -10,10 +10,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.0.4" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="2.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.0.3" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="2.1.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="2.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="1.1.9" />
   </ItemGroup>

src/Ombi.Store/Repository/PlexContentRepository.cs

@@ -89,6 +89,7 @@ namespace Ombi.Store.Repository
         {
             return await Db.PlexServerContent
                 .Include(x => x.Seasons)
+                .Include(x => x.Episodes)
                 .FirstOrDefaultAsync(predicate);
         }
 

src/Ombi.Tests/Ombi.Tests.csproj

@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.TestHost" Version="2.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.TestHost" Version="2.1.0" />
     <PackageReference Include="Moq" Version="4.7.99" />
     <PackageReference Include="Nunit" Version="3.8.1" />
     <PackageReference Include="NUnit.ConsoleRunner" Version="3.7.0" />

src/Ombi.Updater/Ombi.Updater.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <RuntimeIdentifiers>win10-x64;win10-x86;osx-x64;ubuntu-x64;debian.8-x64;centos.7-x64;linux-x64;linux-arm;linux-arm64;</RuntimeIdentifiers>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
     <AssemblyVersion>3.0.0.0</AssemblyVersion>
     <FileVersion>3.0.0.0</FileVersion>
     <Version></Version>
@@ -12,14 +12,14 @@
 
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.1.1-beta" />
-    <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.0.2" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.1.0" />
     <PackageReference Include="Serilog" Version="2.6.0-dev-00892" />
     <PackageReference Include="Serilog.Extensions.Logging" Version="2.0.2" />
     <PackageReference Include="Serilog.Sinks.File" Version="3.2.0" />

src/Ombi/ClientApp/app/settings/massemail/massemail.component.html

@@ -39,8 +39,8 @@
 
             <div class="form-group" *ngFor="let u of users">
                     <div class="checkbox">
-                        <input type="checkbox" id="{{u.user.id}}" [(ngModel)]="u.selected" (click)="selectSingleUser(u)">
-                        <label for="{{u.user.id}}">{{u.user.userName}}</label>
+                        <input type="checkbox" id="user{{u.user.id}}" [(ngModel)]="u.selected" (click)="selectSingleUser(u)">
+                        <label for="user{{u.user.id}}">{{u.user.userName}}</label>
                     </div>
                 </div>
     </div>

src/Ombi/Controllers/IdentityController.cs

@@ -203,7 +203,7 @@ namespace Ombi.Controllers
             await CreateRole(OmbiRoles.RequestMovie);
             await CreateRole(OmbiRoles.RequestTv);
             await CreateRole(OmbiRoles.Disabled);
-            await CreateRole(OmbiRoles.RecievesNewsletter);
+            await CreateRole(OmbiRoles.ReceivesNewsletter);
         }
 
         private async Task CreateRole(string role)

src/Ombi/Ombi.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
     <RuntimeIdentifiers>win10-x64;win10-x86;osx-x64;ubuntu-x64;debian.8-x64;centos.7-x64;linux-x64;linux-arm;linux-arm64;</RuntimeIdentifiers>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <TypeScriptToolsVersion>Latest</TypeScriptToolsVersion>
@@ -67,10 +67,10 @@
     <PackageReference Include="Hangfire.RecurringJobExtensions" Version="1.1.6" />
     <PackageReference Include="Hangfire.SQLite" Version="1.4.2" />
 
-    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.8" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.0.2" />
-    <PackageReference Include="Microsoft.VisualStudio.Web.BrowserLink" Version="2.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.1.0" />
+    <PackageReference Include="Microsoft.VisualStudio.Web.BrowserLink" Version="2.1.0" />
     <PackageReference Include="MiniProfiler.AspNetCore.Mvc" Version="4.0.0-alpha6-79" />
     <PackageReference Include="ncrontab" Version="3.3.0" />
     <PackageReference Include="Serilog" Version="2.6.0-dev-00892" />

src/Ombi/Startup.cs

@@ -218,7 +218,7 @@ namespace Ombi
 
             app.UseMiddleware<ErrorHandlingMiddleware>();
 
-            app.ApiKeyMiddlewear(serviceProvider);
+            app.ApiKeyMiddlewear(app.ApplicationServices);
             app.UseSwagger();
             app.UseSwaggerUI(c =>
             {