Merge branch 'DotNetCore' of https://github.com/tidusjar/ombi into DotNetCore

src/Ombi.Api.Emby/EmbyApi.cs

@@ -51,6 +51,7 @@ namespace Ombi.Api.Emby
             var body = new
             {
                 username,
+                pw = password,
                 password = password.GetSha1Hash().ToLower(),
                 passwordMd5 = password.CalcuateMd5Hash()
             };

src/Ombi.Schedule/Jobs/Emby/EmbyEpisodeSync.cs

@@ -99,7 +99,7 @@ namespace Ombi.Schedule.Jobs.Emby
                     continue;
                 }
 
-                var existingEpisode = await _repo.GetByEmbyId(ep.Id);
+                var existingEpisode = await _repo.GetEpisodeByEmbyId(ep.Id);
                 if (existingEpisode == null)
                 {
                     // add it

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

@@ -122,7 +122,12 @@ namespace Ombi.Schedule.Jobs.Plex
                             }
 
                             // Do we already have this item?
-                            var existingContent = await Repo.GetByKey(show.ratingKey);
+                            // Let's try and match
+                            var existingContent = await Repo.GetFirstContentByCustom(x => x.Title == show.title 
+                                                        && x.ReleaseYear == show.year.ToString()
+                                                        && x.Type == PlexMediaTypeEntity.Show);
+                            // The ratingKey keeps changing...
+                            //var existingContent = await Repo.GetByKey(show.ratingKey);
                             if (existingContent != null)
                             {
                                 try
@@ -197,7 +202,12 @@ namespace Ombi.Schedule.Jobs.Plex
                         foreach (var movie in content?.Metadata ?? new Metadata[] { })
                         {
                             // Let's check if we have this movie
-                            var existing = await Repo.GetByKey(movie.ratingKey);
+
+                            var existing = await Repo.GetFirstContentByCustom(x => x.Title == movie.title
+                                                                                          && x.ReleaseYear == movie.year.ToString()
+                                                                                          && x.Type == PlexMediaTypeEntity.Movie);
+                            // The rating key keeps changing
+                            //var existing = await Repo.GetByKey(movie.ratingKey);
                             if (existing != null)
                             {
                                 continue;

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

@@ -101,17 +101,20 @@ namespace Ombi.Schedule.Jobs.Plex
             var currentPosition = 0;
             var resultCount = settings.EpisodeBatchSize == 0 ? 50 : settings.EpisodeBatchSize;
             var episodes = await _api.GetAllEpisodes(settings.PlexAuthToken, settings.FullUri, section.key, currentPosition, resultCount);
-            var currentData = _repo.GetAllEpisodes().AsNoTracking();
             _log.LogInformation(LoggingEvents.PlexEpisodeCacher, $"Total Epsiodes found for {episodes.MediaContainer.librarySectionTitle} = {episodes.MediaContainer.totalSize}");
 
-            await ProcessEpsiodes(episodes, currentData);
+            // Delete all the episodes because we cannot uniquly match an episode to series every time, 
+            // see comment below.
+            await _repo.ExecuteSql("DELETE FROM PlexEpisode");
+
+            await ProcessEpsiodes(episodes);
             currentPosition += resultCount;
 
             while (currentPosition < episodes.MediaContainer.totalSize)
             {
                 var ep = await _api.GetAllEpisodes(settings.PlexAuthToken, settings.FullUri, section.key, currentPosition,
                     resultCount);
-                await ProcessEpsiodes(ep, currentData);
+                await ProcessEpsiodes(ep);
                 _log.LogInformation(LoggingEvents.PlexEpisodeCacher, $"Processed {resultCount} more episodes. Total Remaining {episodes.MediaContainer.totalSize - currentPosition}");
                 currentPosition += resultCount;
             }
@@ -121,7 +124,7 @@ namespace Ombi.Schedule.Jobs.Plex
             await _repo.SaveChangesAsync();
         }
 
-        private async Task ProcessEpsiodes(PlexContainer episodes, IQueryable<PlexEpisode> currentEpisodes)
+        private async Task ProcessEpsiodes(PlexContainer episodes)
         {
             var ep = new HashSet<PlexEpisode>();
 
@@ -131,12 +134,13 @@ namespace Ombi.Schedule.Jobs.Plex
                 // We have the parent and grandparent rating keys to link up to the season and series
                 //var metadata = _api.GetEpisodeMetaData(server.PlexAuthToken, server.FullUri, episode.ratingKey);
 
-                var epExists = currentEpisodes.Any(x => episode.ratingKey == x.Key &&
+                // This does seem to work, it looks like we can somehow get different rating, grandparent and parent keys with episodes. Not sure how.
-                                                          episode.grandparentRatingKey == x.GrandparentKey);
+                //var epExists = currentEpisodes.Any(x => episode.ratingKey == x.Key &&
-                if (epExists)
+                //                                          episode.grandparentRatingKey == x.GrandparentKey);
-                {
+                //if (epExists)
-                    continue;
+                //{
-                }
+                //    continue;
+                //}
 
                 ep.Add(new PlexEpisode
                 {

src/Ombi.Store/Migrations/20180128212409_EmbyEpisodeClear.Designer.cs

@@ -0,0 +1,889 @@
+// <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("20180128212409_EmbyEpisodeClear")]
+    partial class EmbyEpisodeClear
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.0-rtm-26452");
+
+            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>("ProviderId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<int>("Type");
+
+                    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>("ParentId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<string>("Title");
+
+                    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.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.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<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>("ImdbId");
+
+                    b.Property<string>("Overview");
+
+                    b.Property<string>("PosterPath");
+
+                    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.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.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.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/20180128212409_EmbyEpisodeClear.cs

@@ -0,0 +1,20 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace Ombi.Store.Migrations
+{
+    public partial class EmbyEpisodeClear : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+DELETE FROM EmbyEpisode");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

src/Ombi.Store/Repository/IPlexContentRepository.cs

@@ -1,5 +1,7 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Ombi.Store.Entities;
 
@@ -15,5 +17,7 @@ namespace Ombi.Store.Repository
         Task<PlexEpisode> Add(PlexEpisode content);
         Task<PlexEpisode> GetEpisodeByKey(int key);
         Task AddRange(IEnumerable<PlexEpisode> content);
+        IEnumerable<PlexServerContent> GetWhereContentByCustom(Expression<Func<PlexServerContent, bool>> predicate);
+        Task<PlexServerContent> GetFirstContentByCustom(Expression<Func<PlexServerContent, bool>> predicate);
     }
 }

src/Ombi.Store/Repository/IRepository.cs

@@ -22,5 +22,7 @@ namespace Ombi.Store.Repository
         IIncludableQueryable<TEntity, TProperty> Include<TEntity, TProperty>(
             IQueryable<TEntity> source, Expression<Func<TEntity, TProperty>> navigationPropertyPath)
             where TEntity : class;
+
+        Task ExecuteSql(string sql);
     }
 }

src/Ombi.Store/Repository/PlexContentRepository.cs

@@ -25,8 +25,10 @@
 //  ************************************************************************/
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Ombi.Store.Context;
@@ -74,6 +76,16 @@ namespace Ombi.Store.Repository
             return await Db.PlexServerContent.Include(x => x.Seasons).FirstOrDefaultAsync(x => x.Key == key);
         }
 
+        public IEnumerable<PlexServerContent> GetWhereContentByCustom(Expression<Func<PlexServerContent, bool>> predicate)
+        {
+            return Db.PlexServerContent.Where(predicate);
+        }
+
+        public async Task<PlexServerContent> GetFirstContentByCustom(Expression<Func<PlexServerContent, bool>>  predicate)
+        {
+            return await Db.PlexServerContent.FirstOrDefaultAsync(predicate);
+        }
+
         public async Task Update(PlexServerContent existingContent)
         {
             Db.PlexServerContent.Update(existingContent);

src/Ombi.Store/Repository/Repository.cs

@@ -72,6 +72,11 @@ namespace Ombi.Store.Repository
             return source.Include(navigationPropertyPath);
         }
 
+        public async Task ExecuteSql(string sql)
+        {
+            await _ctx.Database.ExecuteSqlCommandAsync(sql);
+        }
+
 
         private bool _disposed;
         // Protected implementation of Dispose pattern.

src/Ombi/ClientApp/app/requests/movierequests.component.ts

@@ -118,7 +118,7 @@ export class MovieRequestsComponent implements OnInit {
 
     public deny(request: IMovieRequests) {
         request.denied = true;
-        this.updateRequest(request);
+        this.denyRequest(request);
     }
 
     public selectRootFolder(searchResult: IMovieRequests, rootFolderSelected: IRadarrRootFolder, event: any) {
@@ -195,7 +195,7 @@ export class MovieRequestsComponent implements OnInit {
     private approveRequest(request: IMovieRequests) {
         this.requestService.approveMovie({ id: request.id })
             .subscribe(x => {
-
+                request.approved = true;
                 if (x.result) {
                     this.notificationService.success(
                         `Request for ${request.title} has been approved successfully`);
@@ -206,6 +206,19 @@ export class MovieRequestsComponent implements OnInit {
             });
     }
 
+    private denyRequest(request: IMovieRequests) {
+        this.requestService.denyMovie({ id: request.id })
+            .subscribe(x => {
+                if (x.result) {
+                    this.notificationService.success(
+                        `Request for ${request.title} has been denied successfully`);
+                } else {
+                    this.notificationService.warning("Request Denied", x.message ? x.message : x.errorMessage);
+                    request.denied = false;
+                }
+            });
+    }
+
     private loadInit() {
         this.requestService.getMovieRequests(this.amountToLoad, 0)
             .subscribe(x => {

src/Ombi/wwwroot/translations/da.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Fortsæt",
     "Available": "Tilgængelig",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "Behandler anmodning",
     "PendingApproval": "Afventer godkendelse",
     "RequestDenied": "Anmodning afvist",
@@ -45,6 +46,7 @@
     "UserManagement": "Brugeradministration",
     "Issues": "Problemer",
     "Donate": "Donér!",
+    "DonateLibraryMaintainer": "Donér til vedligeholder af bibliotek",
     "DonateTooltip": "Sådan overbeviser jeg min kone om, at jeg skal bruge min fritid på at udvikle Ombi :)",
     "UpdateAvailableTooltip": "Ny opdatering venter!",
     "Settings": "Indstillinger",
@@ -59,9 +61,9 @@
       "Italian": "Italiensk",
       "Danish": "Dansk",
       "Dutch": "Hollandsk",
-      "Norwegian": "Norwegian"
+      "Norwegian": "Norsk"
     },
-    "OpenMobileApp": "Open Mobile App"
+    "OpenMobileApp": "Åbn mobilapp"
   },
   "Search": {
     "Title": "Søg",
@@ -104,7 +106,9 @@
     "Season": "Sæson:",
     "GridTitle": "Titel",
     "AirDate": "Sendt",
-    "GridStatus": "Status"
+    "GridStatus": "Status",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Problemer",
@@ -124,5 +128,11 @@
     "Comments": "Kommentarer",
     "WriteMessagePlaceholder": "Indtast din besked her...",
     "ReportedBy": "Anmeldt af"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/de.json

@@ -12,14 +12,15 @@
   "Common": {
     "ContinueButton": "Weiter",
     "Available": "Verfügbar",
+    "NotAvailable": "Nicht verfügbar",
     "ProcessingRequest": "Anfrage wird bearbeitet",
     "PendingApproval": "Genehmigung ausstehend",
-    "RequestDenied": "Request Denied",
+    "RequestDenied": "Anfrage abgelehnt",
     "NotRequested": "Nicht angefragt",
     "Requested": "Angefordert",
     "Request": "Anfrage",
-    "Denied": "Denied",
+    "Denied": "Abgelehnt",
-    "Approve": "Approve",
+    "Approve": "Genehmigen",
     "Errors": {
       "Validation": "Bitte überprüfen Sie die eingegebenen Werte"
     }
@@ -43,8 +44,9 @@
     "Search": "Suche",
     "Requests": "Anfragen",
     "UserManagement": "Benutzerverwaltung",
-    "Issues": "Issues",
+    "Issues": "Probleme",
     "Donate": "Spenden!",
+    "DonateLibraryMaintainer": "Spende sie an den Bibliotheks Betreuer",
     "DonateTooltip": "So überzeuge ich meine Frau, meine Freizeit mit der Entwicklung von Ombi zu verbringen ;)",
     "UpdateAvailableTooltip": "Update verfügbar!",
     "Settings": "Einstellungen",
@@ -59,9 +61,9 @@
       "Italian": "Italienisch",
       "Danish": "Dänisch",
       "Dutch": "Niederländisch",
-      "Norwegian": "Norwegian"
+      "Norwegian": "Norwegisch"
     },
-    "OpenMobileApp": "Open Mobile App"
+    "OpenMobileApp": "Mobile App"
   },
   "Search": {
     "Title": "Suche",
@@ -83,46 +85,54 @@
     }
   },
   "Requests": {
-    "Title": "Requests",
+    "Title": "Anfragen",
-    "Paragraph": "Below you can see yours and all other requests, as well as their download and approval status.",
+    "Paragraph": "Unten sehen Sie Ihre und alle anderen Anfragen, sowie deren Download-und Genehmigungsstatus.",
-    "MoviesTab": "Movies",
+    "MoviesTab": "Filme",
-    "TvTab": "TV Shows",
+    "TvTab": "Serien",
-    "RequestedBy": "Requested By:",
+    "RequestedBy": "Angefordert von:",
     "Status": "Status:",
-    "RequestStatus": "Request status:",
+    "RequestStatus": "Anfrage Status:",
-    "Denied": " Denied:",
+    "Denied": " Abgelehnt:",
-    "ReleaseDate": "Release Date:",
+    "ReleaseDate": "Veröffentlichungsdatum:",
-    "RequestDate": "Request Date:",
+    "RequestDate": "Datum der Anfrage:",
-    "QualityOverride": "Quality Override:",
+    "QualityOverride": "Qualitäts Überschreiben:",
-    "RootFolderOverride": "Root Folder Override:",
+    "RootFolderOverride": "Stammverzeichnis Überschreiben:",
-    "ChangeRootFolder": "Change Root Folder",
+    "ChangeRootFolder": "Stammordner ändern",
-    "ChangeQualityProfile": "Change Quality Profile",
+    "ChangeQualityProfile": "Qualitätsprofil ändern",
-    "MarkUnavailable": "Mark Unavailable",
+    "MarkUnavailable": "Als Nicht verfügbar markieren",
-    "MarkAvailable": "Mark Available",
+    "MarkAvailable": "Als verfügbar markieren",
-    "Remove": "Remove",
+    "Remove": "Entfernen",
-    "Deny": "Deny",
+    "Deny": "Ablehnen",
-    "Season": "Season:",
+    "Season": "Staffel:",
-    "GridTitle": "Title",
+    "GridTitle": "Titel",
-    "AirDate": "AirDate",
+    "AirDate": "Erstausstrahlung",
-    "GridStatus": "Status"
+    "GridStatus": "Status",
+    "ReportIssue": "Problem melden",
+    "Filter": "Filter"
   },
   "Issues": {
-    "Title": "Issues",
+    "Title": "Probleme",
-    "PendingTitle": "Pending Issues",
+    "PendingTitle": "Ausstehende Probleme",
-    "InProgressTitle": "In Progress Issues",
+    "InProgressTitle": "Probleme in bearbeitung",
-    "ResolvedTitle": "Resolved Issues",
+    "ResolvedTitle": "Behobene Probleme",
-    "ColumnTitle": "Title",
+    "ColumnTitle": "Titel",
-    "Category": "Category",
+    "Category": "Kategorie",
     "Status": "Status",
     "Details": "Details",
-    "Description": "Description",
+    "Description": "Beschreibung",
-    "NoComments": "No Comments!",
+    "NoComments": "Keine Kommentare!",
-    "MarkInProgress": "Mark In Progress",
+    "MarkInProgress": "Als in Bearbeitung markieren",
-    "MarkResolved": "Mark Resolved",
+    "MarkResolved": "Als gelöst markieren",
-    "SendMessageButton": "Send",
+    "SendMessageButton": "Senden",
-    "Subject": "Subject",
+    "Subject": "Betreff",
-    "Comments": "Comments",
+    "Comments": "Kommentare",
-    "WriteMessagePlaceholder": "Write your message here...",
+    "WriteMessagePlaceholder": "Nachricht eingeben...",
-    "ReportedBy": "Reported By"
+    "ReportedBy": "Gemeldet von"
+  },
+  "Filter": {
+    "ClearFilter": "Filter zurücksetzen",
+    "FilterHeaderAvailability": "Verfügbarkeit",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Bestätigt"
   }
 }

src/Ombi/wwwroot/translations/es.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Continuar",
     "Available": "Disponible",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "Procesando solicitud",
     "PendingApproval": "Pendiente de aprobación",
     "RequestDenied": "Solicitud denegada",
@@ -45,6 +46,7 @@
     "UserManagement": "Gestión de usuarios",
     "Issues": "Incidencias",
     "Donate": "¡Donar!",
+    "DonateLibraryMaintainer": "Donate to Library Maintainer",
     "DonateTooltip": "Para que mi esposa me deje desarrollar Ombi ;)",
     "UpdateAvailableTooltip": "¡Actualización disponible!",
     "Settings": "Ajustes",
@@ -104,7 +106,9 @@
     "Season": "Temporada:",
     "GridTitle": "Título",
     "AirDate": "Fecha de estreno",
-    "GridStatus": "Estado"
+    "GridStatus": "Estado",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Incidencias",
@@ -124,5 +128,11 @@
     "Comments": "Comentarios",
     "WriteMessagePlaceholder": "Escribe tu mensaje aquí...",
     "ReportedBy": "Informado por"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/fr.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Continuer",
     "Available": "Disponible",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "En cours de traitement",
     "PendingApproval": "En attente d'approbation",
     "RequestDenied": "Demande refusée",
@@ -45,6 +46,7 @@
     "UserManagement": "Gestion des utilisateurs",
     "Issues": "Problèmes",
     "Donate": "Faire un don !",
+    "DonateLibraryMaintainer": "Donate to Library Maintainer",
     "DonateTooltip": "C’est pour convaincre ma femme de me laisser passer mon temps libre à développer Ombi ;)",
     "UpdateAvailableTooltip": "Mise à jour disponible !",
     "Settings": "Paramètres",
@@ -104,7 +106,9 @@
     "Season": "Saison :",
     "GridTitle": "Titre",
     "AirDate": "Date de diffusion",
-    "GridStatus": "Statut"
+    "GridStatus": "Statut",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Problèmes",
@@ -124,5 +128,11 @@
     "Comments": "Commentaires",
     "WriteMessagePlaceholder": "Écrivez votre message ici...",
     "ReportedBy": "Signalé par"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/it.json

@@ -3,53 +3,55 @@
     "SignInButton": "Accedi",
     "UsernamePlaceholder": "Nome utente",
     "PasswordPlaceholder": "Password",
-    "RememberMe": "Ricordati di Me",
+    "RememberMe": "Ricordati di me",
     "ForgottenPassword": "Hai dimenticato la password?",
     "Errors": {
-      "IncorrectCredentials": "Incorrect username or password"
+      "IncorrectCredentials": "Username o password non corretta"
     }
   },
   "Common": {
-    "ContinueButton": "Continuare",
+    "ContinueButton": "Continua",
-    "Available": "Available",
+    "Available": "Disponibile",
-    "ProcessingRequest": "Processing Request",
+    "NotAvailable": "Not Available",
-    "PendingApproval": "Pending Approval",
+    "ProcessingRequest": "Richiesta in elaborazione",
-    "RequestDenied": "Request Denied",
+    "PendingApproval": "In attesa di approvazione",
-    "NotRequested": "Not Requested",
+    "RequestDenied": "Richiesta negata",
-    "Requested": "Requested",
+    "NotRequested": "Non richiesto",
-    "Request": "Request",
+    "Requested": "Richiesto",
-    "Denied": "Denied",
+    "Request": "Richiesta",
-    "Approve": "Approve",
+    "Denied": "Rifiutato",
+    "Approve": "Approva",
     "Errors": {
-      "Validation": "Please check your entered values"
+      "Validation": "Per favore, controlla i valori che hai inserito"
     }
   },
   "PasswordReset": {
-    "EmailAddressPlaceholder": "Indirizzo di posta elettronica",
+    "EmailAddressPlaceholder": "Indirizzo e-mail",
-    "ResetPasswordButton": "Reimpostare la Password"
+    "ResetPasswordButton": "Reimposta la password"
   },
   "LandingPage": {
     "OnlineHeading": "Attualmente Online",
     "OnlineParagraph": "Il media server è attualmente online",
     "PartiallyOnlineHeading": "Parzialmente in linea",
     "PartiallyOnlineParagraph": "Il media server è parzialmente in linea.",
-    "MultipleServersUnavailable": "Ci sono {{serversUnavailable}} server offline fuori {{totalServers}}.",
+    "MultipleServersUnavailable": "Ci sono {{serversUnavailable}} server offline su {{totalServers}}.",
-    "SingleServerUnavailable": "C'è {{serversUnavailable}} il server offline fuori {{totalServers}}.",
+    "SingleServerUnavailable": "C'è {{serversUnavailable}} server offline su {{totalServers}}.",
     "OfflineHeading": "Attualmente Offline",
     "OfflineParagraph": "Il media server è attualmente offline.",
-    "CheckPageForUpdates": "Check this page for continuous site updates."
+    "CheckPageForUpdates": "Controlla questa pagina per ottenere aggiornamenti del sito."
   },
   "NavigationBar": {
-    "Search": "Ricerca",
+    "Search": "Cerca",
     "Requests": "Richieste",
     "UserManagement": "Gestione degli utenti",
-    "Issues": "Issues",
+    "Issues": "Problemi",
     "Donate": "Fai una donazione!",
-    "DonateTooltip": "Questo è come convincere mia moglie a farmi spendere il mio tempo libero lo sviluppo di Ombi ;)",
+    "DonateLibraryMaintainer": "Dona al manutentore della libreria",
+    "DonateTooltip": "Questo è come convinco mia moglie a farmi spendere il mio tempo libero nello sviluppo di Ombi ;)",
     "UpdateAvailableTooltip": "Aggiornamento disponibile!",
     "Settings": "Impostazioni",
     "Welcome": "Benvenuto {{username}}",
-    "UpdateDetails": "Aggiornare i dettagli",
+    "UpdateDetails": "Aggiorna i tuoi dati",
     "Logout": "Logout",
     "Language": {
       "English": "Inglese",
@@ -59,70 +61,78 @@
       "Italian": "Italiano",
       "Danish": "Danese",
       "Dutch": "Olandese",
-      "Norwegian": "Norwegian"
+      "Norwegian": "Norvegese"
     },
-    "OpenMobileApp": "Open Mobile App"
+    "OpenMobileApp": "Apri l'applicazione mobile"
   },
   "Search": {
-    "Title": "Search",
+    "Title": "Cerca",
-    "Paragraph": "Want to watch something that is not currently available? No problem, just search for it below and request it!",
+    "Paragraph": "Vuoi vedere qualcosa che non è attualmente disponibile? Nessun problema, basta cercare qui sotto e richiederlo!",
-    "MoviesTab": "Movies",
+    "MoviesTab": "Film",
-    "TvTab": "TV Shows",
+    "TvTab": "Serie TV",
-    "Suggestions": "Suggestions",
+    "Suggestions": "Suggerimenti",
-    "NoResults": "Sorry, we didn't find any results!",
+    "NoResults": "Ci dispiace, non abbiamo trovato alcun risultato!",
-    "ReleaseDate": "Release Date",
+    "ReleaseDate": "Data di rilascio",
-    "ViewOnPlex": "View On Plex",
+    "ViewOnPlex": "Guarda su Plex",
-    "RequestAdded": "Request for {{title}} has been added successfully",
+    "RequestAdded": "La richiesta per {{title}} è stata aggiunta correttamente",
     "Movies": {
-      "PopularMovies": "Popular Movies",
+      "PopularMovies": "Film popolari",
-      "UpcomingMovies": "Upcoming Movies",
+      "UpcomingMovies": "Film in arrivo",
-      "TopRatedMovies": "Top Rated Movies",
+      "TopRatedMovies": "Film più votati",
-      "NowPlayingMovies": "Now Playing Movies",
+      "NowPlayingMovies": "Film ora in riproduzione",
-      "HomePage": "Home Page",
+      "HomePage": "Pagina iniziale",
       "Trailer": "Trailer"
     }
   },
   "Requests": {
-    "Title": "Requests",
+    "Title": "Richieste",
-    "Paragraph": "Below you can see yours and all other requests, as well as their download and approval status.",
+    "Paragraph": "Qui sotto puoi vedere le tue e tutte le altre richieste con il loro stato di download e approvazione.",
-    "MoviesTab": "Movies",
+    "MoviesTab": "Film",
-    "TvTab": "TV Shows",
+    "TvTab": "Serie TV",
-    "RequestedBy": "Requested By:",
+    "RequestedBy": "Richiesta da:",
-    "Status": "Status:",
+    "Status": "Stato:",
-    "RequestStatus": "Request status:",
+    "RequestStatus": "Stato della richiesta:",
-    "Denied": " Denied:",
+    "Denied": " Rifiutato:",
-    "ReleaseDate": "Release Date:",
+    "ReleaseDate": "Data di rilascio:",
-    "RequestDate": "Request Date:",
+    "RequestDate": "Data della richiesta:",
-    "QualityOverride": "Quality Override:",
+    "QualityOverride": "Sovrascrivi qualità:",
-    "RootFolderOverride": "Root Folder Override:",
+    "RootFolderOverride": "Sovrascrivi cartella principale:",
-    "ChangeRootFolder": "Change Root Folder",
+    "ChangeRootFolder": "Modifica cartella principale",
-    "ChangeQualityProfile": "Change Quality Profile",
+    "ChangeQualityProfile": "Modifica il profilo della qualità",
-    "MarkUnavailable": "Mark Unavailable",
+    "MarkUnavailable": "Segna come Non disponibile",
-    "MarkAvailable": "Mark Available",
+    "MarkAvailable": "Segna come Disponibile",
-    "Remove": "Remove",
+    "Remove": "Elimina",
-    "Deny": "Deny",
+    "Deny": "Nega",
-    "Season": "Season:",
+    "Season": "Stagione:",
-    "GridTitle": "Title",
+    "GridTitle": "Titolo",
-    "AirDate": "AirDate",
+    "AirDate": "Data di trasmissione",
-    "GridStatus": "Status"
+    "GridStatus": "Stato",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
-    "Title": "Issues",
+    "Title": "Problemi",
-    "PendingTitle": "Pending Issues",
+    "PendingTitle": "Problemi in sospeso",
-    "InProgressTitle": "In Progress Issues",
+    "InProgressTitle": "Problemi in risoluzione",
-    "ResolvedTitle": "Resolved Issues",
+    "ResolvedTitle": "Problemi risolti",
-    "ColumnTitle": "Title",
+    "ColumnTitle": "Titolo",
-    "Category": "Category",
+    "Category": "Categoria",
-    "Status": "Status",
+    "Status": "Stato",
-    "Details": "Details",
+    "Details": "Dettagli",
-    "Description": "Description",
+    "Description": "Descrizione",
-    "NoComments": "No Comments!",
+    "NoComments": "Non ci sono commenti!",
-    "MarkInProgress": "Mark In Progress",
+    "MarkInProgress": "Segna come in risoluzione",
-    "MarkResolved": "Mark Resolved",
+    "MarkResolved": "Segna come risolto",
-    "SendMessageButton": "Send",
+    "SendMessageButton": "Invia",
-    "Subject": "Subject",
+    "Subject": "Oggetto",
-    "Comments": "Comments",
+    "Comments": "Commenti",
-    "WriteMessagePlaceholder": "Write your message here...",
+    "WriteMessagePlaceholder": "Scrivi qui il tuo messaggio...",
-    "ReportedBy": "Reported By"
+    "ReportedBy": "Segnalato da"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/nl.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Doorgaan",
     "Available": "Beschikbaar",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "Verzoek wordt verwerkt",
     "PendingApproval": "Wacht op goedkeuring",
     "RequestDenied": "Verzoek geweigerd",
@@ -45,6 +46,7 @@
     "UserManagement": "Gebruikersbeheer",
     "Issues": "Problemen",
     "Donate": "Doneer!",
+    "DonateLibraryMaintainer": "Donate to Library Maintainer",
     "DonateTooltip": "Zo heb ik mijn vrouw overtuigd dat ik Ombi mag ontwikkelen ;)",
     "UpdateAvailableTooltip": "Update beschikbaar!",
     "Settings": "Instellingen",
@@ -104,7 +106,9 @@
     "Season": "Seizoen:",
     "GridTitle": "Titel",
     "AirDate": "Uitzenddatum",
-    "GridStatus": "Status"
+    "GridStatus": "Status",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Problemen",
@@ -124,5 +128,11 @@
     "Comments": "Opmerkingen",
     "WriteMessagePlaceholder": "Schrijf hier je bericht...",
     "ReportedBy": "Gerapporteerd door"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/no.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Gå videre",
     "Available": "Tilgjengelig",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "Behandler forespørsel",
     "PendingApproval": "Venter på godkjenning",
     "RequestDenied": "Forespørsel avslått",
@@ -45,6 +46,7 @@
     "UserManagement": "Brukeradministrasjon",
     "Issues": "Mangler",
     "Donate": "Doner!",
+    "DonateLibraryMaintainer": "Doner til vedlikeholderen av biblioteket",
     "DonateTooltip": "Dette er hvordan jeg overbevise min kone til å la meg bruke min fritid til å utvikle Ombi ;)",
     "UpdateAvailableTooltip": "Ny opdatering venter!",
     "Settings": "Innstillinger",
@@ -104,7 +106,9 @@
     "Season": "Sesong:",
     "GridTitle": "Tittel",
     "AirDate": "Sendedato",
-    "GridStatus": "Status"
+    "GridStatus": "Status",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Mangler",
@@ -124,5 +128,11 @@
     "Comments": "Kommentarer",
     "WriteMessagePlaceholder": "Skriv meldingen din her...",
     "ReportedBy": "Rapportert av"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }

src/Ombi/wwwroot/translations/sv.json

@@ -12,6 +12,7 @@
   "Common": {
     "ContinueButton": "Fortsätt",
     "Available": "Tillgänglig",
+    "NotAvailable": "Not Available",
     "ProcessingRequest": "Bearbetar förfrågan",
     "PendingApproval": "I väntan på godkännande",
     "RequestDenied": "Efterfrågan nekas",
@@ -45,6 +46,7 @@
     "UserManagement": "Användarhantering",
     "Issues": "Problem",
     "Donate": "Donera!",
+    "DonateLibraryMaintainer": "Donera till bibliotekets utvecklare",
     "DonateTooltip": "Det är så här jag övertygar min fru att jag vill spendera min fritid att utveckla Ombi ;)",
     "UpdateAvailableTooltip": "Uppdatering tillgänglig!",
     "Settings": "Inställningar",
@@ -59,9 +61,9 @@
       "Italian": "Italienska",
       "Danish": "Danska",
       "Dutch": "Holländska",
-      "Norwegian": "Norwegian"
+      "Norwegian": "Norska"
     },
-    "OpenMobileApp": "Open Mobile App"
+    "OpenMobileApp": "Öppna Mobil App"
   },
   "Search": {
     "Title": "Sök",
@@ -89,7 +91,7 @@
     "TvTab": "TV-serier",
     "RequestedBy": "Efterfrågats av:",
     "Status": "Status:",
-    "RequestStatus": "Request status:",
+    "RequestStatus": "Status för efterfrågan:",
     "Denied": " Nekad:",
     "ReleaseDate": "Releasedatum:",
     "RequestDate": "Datum för efterfrågan:",
@@ -104,7 +106,9 @@
     "Season": "Säsong:",
     "GridTitle": "Titel",
     "AirDate": "Sändningsdatum",
-    "GridStatus": "Status"
+    "GridStatus": "Status",
+    "ReportIssue": "Report Issue",
+    "Filter": "Filter"
   },
   "Issues": {
     "Title": "Problem",
@@ -124,5 +128,11 @@
     "Comments": "Kommentarer",
     "WriteMessagePlaceholder": "Skriv ditt meddelande här...",
     "ReportedBy": "Rapporterad av"
+  },
+  "Filter": {
+    "ClearFilter": "Clear Filter",
+    "FilterHeaderAvailability": "Availability",
+    "FilterHeaderRequestStatus": "Status",
+    "Approved": "Approved"
   }
 }