Add the Issue Reporting functionality (#1811)

* Added issuesreporting and the ability to add categories to the UI
* Added lazy loading!

src/Ombi.Store/Context/IOmbiContext.cs

@@ -30,8 +30,8 @@ namespace Ombi.Store.Context
         DbSet<MovieRequests> MovieRequests { get; set; }
         DbSet<TvRequests> TvRequests { get; set; }
         DbSet<ChildRequests> ChildRequests { get; set; }
-        DbSet<MovieIssues> MovieIssues { get; set; }
-        DbSet<TvIssues> TvIssues { get; set; }
+        DbSet<Issues> Issues { get; set; }
+        DbSet<IssueCategory> IssueCategories { get; set; }
         DbSet<Tokens> Tokens { get; set; }
         DbSet<SonarrCache> SonarrCache { get; set; }
         DbSet<SonarrEpisodeCache> SonarrEpisodeCache { get; set; }

src/Ombi.Store/Context/OmbiContext.cs

@@ -33,10 +33,13 @@ namespace Ombi.Store.Context
         public DbSet<MovieRequests> MovieRequests { get; set; }
         public DbSet<TvRequests> TvRequests { get; set; }
         public DbSet<ChildRequests> ChildRequests { get; set; }
-        public DbSet<MovieIssues> MovieIssues { get; set; }
-        public DbSet<TvIssues> TvIssues { get; set; }
+
+        public DbSet<Issues> Issues { get; set; }
+        public DbSet<IssueCategory> IssueCategories { get; set; }
+        public DbSet<IssueComments> IssueComments { get; set; }
         public DbSet<RequestLog> RequestLogs { get; set; }
 
+
         public DbSet<Audit> Audit { get; set; }
         public DbSet<Tokens> Tokens { get; set; }
         public DbSet<SonarrCache> SonarrCache { get; set; }

src/Ombi.Store/Entities/Requests/ChildRequests.cs

@@ -14,7 +14,7 @@ namespace Ombi.Store.Entities.Requests
 
 
         [ForeignKey(nameof(IssueId))]
-        public List<TvIssues> Issues { get; set; }
+        public List<Issues> Issues { get; set; }
 
         public List<SeasonRequests> SeasonRequests { get; set; }
     }

src/Ombi.Store/Entities/Requests/IssueCategory.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Ombi.Store.Entities.Requests
+{
+    [Table("IssueCategory")]
+    public class IssueCategory : Entity
+    {
+        public string Value { get; set; }
+    }
+}

src/Ombi.Store/Entities/Requests/IssueComments.cs

@@ -0,0 +1,18 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Ombi.Store.Entities.Requests
+{
+    public class IssueComments : Entity
+    {
+        public string UserId { get; set; }
+        public string Comment { get; set; }
+        public int? IssuesId { get; set; }
+        public DateTime Date { get; set; }
+        
+        [ForeignKey(nameof(IssuesId))]
+        public Issues Issues{ get; set; }
+        [ForeignKey(nameof(UserId))]
+        public OmbiUser User { get; set; }
+    }
+}

src/Ombi.Store/Entities/Requests/Issues.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Ombi.Store.Entities.Requests
+{
+    [Table("Issues")]
+    public class Issues : Entity
+    {
+        public string Title { get; set; }
+        public RequestType RequestType { get; set; }
+        public string ProviderId { get; set; }
+        public int? RequestId { get; set; }
+        public string Subject { get; set; }
+        public string Description { get; set; }
+        public int IssueCategoryId { get; set; }
+        [ForeignKey(nameof(IssueCategoryId))]
+        public IssueCategory IssueCategory { get; set; }
+        public IssueStatus Status { get; set; }
+        public DateTime? ResovledDate { get; set; }
+        [ForeignKey(nameof(UserReported))]
+        public string UserReportedId { get; set; }
+        public OmbiUser UserReported { get; set; }
+        public List<IssueComments> Comments { get; set; }
+    }
+
+    public enum IssueStatus
+    {
+        Pending = 0,
+        InProgress = 1,
+        Resolved = 2,
+    }
+}

src/Ombi.Store/Entities/Requests/IssuesBase.cs

@@ -1,9 +0,0 @@
-namespace Ombi.Store.Entities.Requests
-{
-    public class IssuesBase : Entity
-    {
-        public string Subect { get; set; }
-        public string Description { get; set; }
-        
-    }
-}

src/Ombi.Store/Entities/Requests/MovieIssues.cs

@@ -1,12 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Ombi.Store.Entities.Requests
-{
-    [Table("MovieIssues")]
-    public class MovieIssues : IssuesBase
-    {
-        public int MovieId { get; set; }
-        [ForeignKey(nameof(MovieId))]
-        public MovieRequests Movie { get; set; }
-    }
-}

src/Ombi.Store/Entities/Requests/MovieRequests.cs

@@ -10,7 +10,7 @@ namespace Ombi.Store.Entities.Requests
         public int TheMovieDbId { get; set; }
         public int? IssueId { get; set; }
         [ForeignKey(nameof(IssueId))]
-        public List<MovieIssues> Issues { get; set; }
+        public List<Issues> Issues { get; set; }
 
         public int RootPathOverride { get; set; }
         public int QualityOverride { get; set; }

src/Ombi.Store/Entities/Requests/TvIssues.cs

@@ -1,12 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace Ombi.Store.Entities.Requests
-{
-    [Table("TvIssues")]
-    public class TvIssues : IssuesBase
-    {
-        public int TvId { get; set; }
-        [ForeignKey(nameof(TvId))]
-        public ChildRequests Child { get; set; }
-    }
-}

src/Ombi.Store/Migrations/20171103003202_Inital.Designer.cs

@@ -447,7 +447,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int>("MovieId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.HasKey("Id");
 
@@ -513,7 +513,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int?>("IssueId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.Property<int>("TvId");
 

src/Ombi.Store/Migrations/20171103003202_Inital.cs

@@ -504,7 +504,7 @@ namespace Ombi.Store.Migrations
                     Description = table.Column<string>(type: "TEXT", nullable: true),
                     IssueId = table.Column<int>(type: "INTEGER", nullable: true),
                     MovieId = table.Column<int>(type: "INTEGER", nullable: false),
-                    Subect = table.Column<string>(type: "TEXT", nullable: true)
+                    Subject = table.Column<string>(type: "TEXT", nullable: true)
                 },
                 constraints: table =>
                 {
@@ -551,7 +551,7 @@ namespace Ombi.Store.Migrations
                         .Annotation("Sqlite:Autoincrement", true),
                     Description = table.Column<string>(type: "TEXT", nullable: true),
                     IssueId = table.Column<int>(type: "INTEGER", nullable: true),
-                    Subect = table.Column<string>(type: "TEXT", nullable: true),
+                    Subject = table.Column<string>(type: "TEXT", nullable: true),
                     TvId = table.Column<int>(type: "INTEGER", nullable: false)
                 },
                 constraints: table =>

src/Ombi.Store/Migrations/20171103224757_MovieBackground.Designer.cs

@@ -447,7 +447,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int>("MovieId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.HasKey("Id");
 
@@ -515,7 +515,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int?>("IssueId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.Property<int>("TvId");
 

src/Ombi.Store/Migrations/20171123144147_EmbyConnectUser.Designer.cs

@@ -449,7 +449,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int>("MovieId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.HasKey("Id");
 
@@ -517,7 +517,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int?>("IssueId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.Property<int>("TvId");
 

src/Ombi.Store/Migrations/20171128081222_SickRage.Designer.cs

@@ -449,7 +449,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int>("MovieId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.HasKey("Id");
 
@@ -517,7 +517,7 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int?>("IssueId");
 
-                    b.Property<string>("Subect");
+                    b.Property<string>("Subject");
 
                     b.Property<int>("TvId");
 

src/Ombi.Store/Migrations/20171213154624_Issues.Designer.cs

@@ -0,0 +1,840 @@
+// <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("20171213154624_Issues")]
+    partial class Issues
+    {
+        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<DateTime?>("LastLoggedIn");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    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>("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<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<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.HasKey("Id");
+
+                    b.HasIndex("IssueCategoryId");
+
+                    b.HasIndex("IssueId");
+
+                    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.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<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");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            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/20171213154624_Issues.cs

@@ -0,0 +1,138 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace Ombi.Store.Migrations
+{
+    public partial class Issues : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "IssueCategory",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Value = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_IssueCategory", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Issues",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Description = table.Column<string>(type: "TEXT", nullable: true),
+                    IssueCategoryId = table.Column<int>(type: "INTEGER", nullable: false),
+                    IssueId = table.Column<int>(type: "INTEGER", nullable: true),
+                    ProviderId = table.Column<string>(type: "TEXT", nullable: true),
+                    RequestId = table.Column<int>(type: "INTEGER", nullable: true),
+                    RequestType = table.Column<int>(type: "INTEGER", nullable: false),
+                    ResovledDate = table.Column<DateTime>(type: "TEXT", nullable: true),
+                    Status = table.Column<int>(type: "INTEGER", nullable: false),
+                    Subject = table.Column<string>(type: "TEXT", nullable: true),
+                    Title = table.Column<string>(type: "TEXT", nullable: true),
+                    UserReportedId = table.Column<string>(type: "TEXT", nullable: true),
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Issues", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Issues_IssueCategory_IssueCategoryId",
+                        column: x => x.IssueCategoryId,
+                        principalTable: "IssueCategory",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Issues_ChildRequests_IssueId",
+                        column: x => x.IssueId,
+                        principalTable: "ChildRequests",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_Issues_MovieRequests_IssueId",
+                        column: x => x.IssueId,
+                        principalTable: "MovieRequests",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_Issues_AspNetUsers_UserReportedId",
+                        column: x => x.UserReportedId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "IssueComments",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Comment = table.Column<string>(type: "TEXT", nullable: true),
+                    Date = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    IssuesId = table.Column<int>(type: "INTEGER", nullable: true),
+                    UserId = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_IssueComments", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_IssueComments_Issues_IssuesId",
+                        column: x => x.IssuesId,
+                        principalTable: "Issues",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_IssueComments_AspNetUsers_UserId",
+                        column: x => x.UserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IssueComments_IssuesId",
+                table: "IssueComments",
+                column: "IssuesId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_IssueComments_UserId",
+                table: "IssueComments",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Issues_IssueCategoryId",
+                table: "Issues",
+                column: "IssueCategoryId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Issues_IssueId",
+                table: "Issues",
+                column: "IssueId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Issues_UserReportedId",
+                table: "Issues",
+                column: "UserReportedId");
+
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "IssueComments");
+
+            migrationBuilder.DropTable(
+                name: "Issues");
+
+            migrationBuilder.DropTable(
+                name: "IssueCategory");
+        }
+    }
+}

src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs

@@ -8,6 +8,7 @@ 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
@@ -441,26 +442,76 @@ namespace Ombi.Store.Migrations
                     b.ToTable("ChildRequests");
                 });
 
-            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieIssues", b =>
+            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<int>("MovieId");
+                    b.Property<string>("ProviderId");
 
-                    b.Property<string>("Subect");
+                    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("MovieId");
+                    b.HasIndex("UserReportedId");
 
-                    b.ToTable("MovieIssues");
+                    b.ToTable("Issues");
                 });
 
             modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
@@ -533,28 +584,6 @@ namespace Ombi.Store.Migrations
                     b.ToTable("RequestLog");
                 });
 
-            modelBuilder.Entity("Ombi.Store.Entities.Requests.TvIssues", b =>
-                {
-                    b.Property<int>("Id")
-                        .ValueGeneratedOnAdd();
-
-                    b.Property<string>("Description");
-
-                    b.Property<int?>("IssueId");
-
-                    b.Property<string>("Subect");
-
-                    b.Property<int>("TvId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("IssueId");
-
-                    b.HasIndex("TvId");
-
-                    b.ToTable("TvIssues");
-                });
-
             modelBuilder.Entity("Ombi.Store.Entities.Requests.TvRequests", b =>
                 {
                     b.Property<int>("Id")
@@ -778,23 +807,34 @@ namespace Ombi.Store.Migrations
                         .HasForeignKey("RequestedUserId");
                 });
 
-            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieIssues", b =>
+            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.Requests.MovieRequests", "Movie")
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "UserReported")
                         .WithMany()
-                        .HasForeignKey("MovieId")
-                        .OnDelete(DeleteBehavior.Cascade);
-                });
-
-            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
-                {
-                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
-                        .WithMany()
-                        .HasForeignKey("RequestedUserId");
+                        .HasForeignKey("UserReportedId");
                 });
 
             modelBuilder.Entity("Ombi.Store.Entities.Requests.RequestLog", b =>
@@ -803,17 +843,13 @@ namespace Ombi.Store.Migrations
                         .WithMany()
                         .HasForeignKey("UserId");
                 });
+                   
 
-            modelBuilder.Entity("Ombi.Store.Entities.Requests.TvIssues", b =>
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
                 {
-                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests")
-                        .WithMany("Issues")
-                        .HasForeignKey("IssueId");
-
-                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests", "Child")
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
                         .WithMany()
-                        .HasForeignKey("TvId")
-                        .OnDelete(DeleteBehavior.Cascade);
+                        .HasForeignKey("RequestedUserId");
                 });
 
             modelBuilder.Entity("Ombi.Store.Entities.Tokens", b =>

src/Ombi.Store/Repository/IPlexContentRepository.cs

@@ -7,7 +7,6 @@ namespace Ombi.Store.Repository
 {
     public interface IPlexContentRepository : IRepository<PlexServerContent>
     {
-        Task<PlexServerContent> Add(PlexServerContent content);
         Task<bool> ContentExists(string providerId);
         Task<PlexServerContent> Get(string providerId);
         Task<PlexServerContent> GetByKey(int key);

src/Ombi.Store/Repository/IRepository.cs

@@ -14,10 +14,10 @@ namespace Ombi.Store.Repository
         IQueryable<T> GetAll();
         Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate);
         Task AddRange(IEnumerable<T> content);
+        Task<T> Add(T content);
         Task DeleteRange(IEnumerable<T> req);
         Task Delete(T request);
         Task<int> SaveChangesAsync();
-        Task<T> Add(T content);
 
         IIncludableQueryable<TEntity, TProperty> Include<TEntity, TProperty>(
             IQueryable<TEntity> source, Expression<Func<TEntity, TProperty>> navigationPropertyPath)

src/Ombi.Store/Repository/Requests/IMovieRequestRepository.cs

@@ -6,7 +6,6 @@ namespace Ombi.Store.Repository.Requests
 {
     public interface IMovieRequestRepository : IRepository<MovieRequests>
     {
-        Task<MovieRequests> Add(MovieRequests request);
         Task<MovieRequests> GetRequestAsync(int theMovieDbId);
         MovieRequests GetRequest(int theMovieDbId);
         Task Update(MovieRequests request);

src/Ombi.Store/Repository/SettingsJsonRepository.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Caching.Memory;
+using Ombi.Helpers;
 using Ombi.Store.Context;
 using Ombi.Store.Entities;
 
@@ -11,14 +12,14 @@ namespace Ombi.Store.Repository
 {
     public class SettingsJsonRepository : ISettingsRepository
     {
-        public SettingsJsonRepository(IOmbiContext ctx, IMemoryCache mem)
+        public SettingsJsonRepository(IOmbiContext ctx, ICacheService mem)
         {
             Db = ctx;
             _cache = mem;
         }
 
         private IOmbiContext Db { get; }
-        private readonly IMemoryCache _cache;
+        private readonly ICacheService _cache;
 
         public GlobalSettings Insert(GlobalSettings entity)
         {