feat: Got some of the backend rules done

src/Ombi.Core.Tests/Rule/Request/CanRequestRuleTests.cs

@@ -42,7 +42,42 @@ namespace Ombi.Core.Tests.Rule.Request
         public async Task Should_ReturnSuccess_WhenRequestingMovieWithMovieRole()
         {
             UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.RequestMovie)).ReturnsAsync(true);
-            var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
+            var request = new MovieRequests() { RequestType = Store.Entities.RequestType.Movie };
+            var result = await Rule.Execute(request);
+
+            Assert.True(result.Success);
+        }
+
+        [Test]
+        public async Task Should_ReturnSuccess_WhenRequestingMovie4KWithMovieRole()
+        {
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.RequestMovie)).ReturnsAsync(true);
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.Request4KMovie)).ReturnsAsync(true);
+            var request = new MovieRequests() { RequestType = Store.Entities.RequestType.Movie, Has4KRequest = true };
+            var result = await Rule.Execute(request);
+
+            Assert.True(result.Success);
+        }
+
+        [Test]
+        public async Task Should_ReturnFailure_WhenRequestingMovie4KWithMovieRole()
+        {
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.RequestMovie)).ReturnsAsync(true);
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.Request4KMovie)).ReturnsAsync(false);
+            var request = new MovieRequests() { RequestType = Store.Entities.RequestType.Movie, Has4KRequest = true };
+            var result = await Rule.Execute(request);
+
+            Assert.False(result.Success);
+            Assert.False(string.IsNullOrEmpty(result.Message));
+        }
+
+        [Test]
+        public async Task Should_ReturnSuccess_WhenRequestingMovie4KWithAutoApprove()
+        {
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.RequestMovie)).ReturnsAsync(true);
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.AutoApproveMovie)).ReturnsAsync(true);
+            UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.Request4KMovie)).ReturnsAsync(false);
+            var request = new MovieRequests() { RequestType = Store.Entities.RequestType.Movie, Has4KRequest = true };
             var result = await Rule.Execute(request);
 
             Assert.True(result.Success);
@@ -52,7 +87,7 @@ namespace Ombi.Core.Tests.Rule.Request
         public async Task Should_ReturnFail_WhenRequestingMovieWithoutMovieRole()
         {
             UserManager.Setup(x => x.IsInRoleAsync(It.IsAny<OmbiUser>(), OmbiRoles.RequestMovie)).ReturnsAsync(false);
-            var request = new BaseRequest() { RequestType = Store.Entities.RequestType.Movie };
+            var request = new MovieRequests() { RequestType = Store.Entities.RequestType.Movie };
             var result = await Rule.Execute(request);
 
             Assert.False(result.Success);

src/Ombi.Core.Tests/Rule/Request/ExistingMovieRequestRuleTests.cs

@@ -96,5 +96,55 @@ namespace Ombi.Core.Tests.Rule.Request
             Assert.That(result.Success, Is.True);
             Assert.That(result.Message, Is.Null.Or.Empty);
         }
+
+        [Test]
+        public async Task ExistingRequestRule_Movie_HasAlready4K_Request()
+        {
+            ContextMock.Setup(x => x.GetAll()).Returns(new List<MovieRequests>
+            {
+                new MovieRequests
+                {
+                    TheMovieDbId = 2,
+                    ImdbId = "2",
+                    RequestType = RequestType.Movie,
+                    Has4KRequest = true
+                }
+            }.AsQueryable().BuildMock().Object);
+            var o = new MovieRequests
+            {
+                TheMovieDbId = 2,
+                ImdbId = "1",
+                Has4KRequest = true
+            };
+            var result = await Rule.Execute(o);
+
+            Assert.That(result.Success, Is.False);
+            Assert.That(result.Message, Is.Not.Empty);
+        }
+
+        [Test]
+        public async Task ExistingRequestRule_Movie_4K_Request()
+        {
+            ContextMock.Setup(x => x.GetAll()).Returns(new List<MovieRequests>
+            {
+                new MovieRequests
+                {
+                    TheMovieDbId = 2,
+                    ImdbId = "2",
+                    RequestType = RequestType.Movie,
+                    Has4KRequest = false
+                }
+            }.AsQueryable().BuildMock().Object);
+            var o = new MovieRequests
+            {
+                TheMovieDbId = 2,
+                ImdbId = "1",
+                Has4KRequest = true
+            };
+            var result = await Rule.Execute(o);
+
+            Assert.That(result.Success, Is.True);
+            Assert.That(result.Message, Is.Null.Or.Empty);
+        }
     }
 }

src/Ombi.Core/Engine/MovieRequestEngine.cs

@@ -72,7 +72,8 @@ namespace Ombi.Core.Engine
             var userDetails = await GetUser();
             var canRequestOnBehalf = model.RequestOnBehalf.HasValue();
 
-            var isAdmin = await UserManager.IsInRoleAsync(userDetails, OmbiRoles.PowerUser) || await UserManager.IsInRoleAsync(userDetails, OmbiRoles.Admin);
+            var isAdmin = await UserManager.IsInRoleAsync(userDetails, OmbiRoles.PowerUser) 
+                || await UserManager.IsInRoleAsync(userDetails, OmbiRoles.Admin);
             if (canRequestOnBehalf && !isAdmin)
             {
                 return new RequestEngineResult
@@ -112,7 +113,8 @@ namespace Ombi.Core.Engine
                 LangCode = model.LanguageCode,
                 RequestedByAlias = model.RequestedByAlias,
                 RootPathOverride = model.RootFolderOverride.GetValueOrDefault(),
-                QualityOverride = model.QualityPathOverride.GetValueOrDefault()
+                QualityOverride = model.QualityPathOverride.GetValueOrDefault(),
+                Has4KRequest = model.Is4kRequest
             };
 
             var usDates = movieInfo.ReleaseDates?.Results?.FirstOrDefault(x => x.IsoCode == "US");

src/Ombi.Core/Models/Requests/MovieRequestViewModel.cs

@@ -34,6 +34,8 @@ namespace Ombi.Core.Models.Requests
         public int TheMovieDbId { get; set; }
         public string LanguageCode { get; set; } = "en";
 
+        public bool Is4kRequest { get; set; }
+
         /// <summary>
         /// This is only set from a HTTP Header
         /// </summary>

src/Ombi.Core/Rule/Rules/Request/CanRequestRule.cs

@@ -33,8 +33,23 @@ namespace Ombi.Core.Rule.Rules.Request
 
             if (obj.RequestType == RequestType.Movie)
             {
-                if (await _manager.IsInRoleAsync(user, OmbiRoles.RequestMovie) || await _manager.IsInRoleAsync(user, OmbiRoles.AutoApproveMovie))
+                var movie = (MovieRequests)obj;
+                var hasAutoApprove = await _manager.IsInRoleAsync(user, OmbiRoles.AutoApproveMovie);
+                if (await _manager.IsInRoleAsync(user, OmbiRoles.RequestMovie) || hasAutoApprove)
+                {
+                    if (movie.Has4KRequest && !hasAutoApprove)
+                    {
+                        var has4kPermission = await _manager.IsInRoleAsync(user, OmbiRoles.Request4KMovie);
+                        if (has4kPermission)
+                        {
                             return Success();
+                        }
+                    }
+                    else
+                    {
+                        return Success();
+                    }
+                }
                 return Fail(ErrorCode.NoPermissionsRequestMovie, "You do not have permissions to Request a Movie");
             }
 

src/Ombi.Core/Rule/Rules/Request/ExistingMovieRequestRule.cs

@@ -35,7 +35,7 @@ namespace Ombi.Core.Rule.Rules.Request
                 var existing = await movieRequests.FirstOrDefaultAsync(x => x.TheMovieDbId == movie.TheMovieDbId);
                 if (existing != null) // Do we already have a request for this?
                 {
-                    found = true;
+                    found = Check4KRequests(movie, existing);
                 }
 
                 if (!found && movie.ImdbId.HasValue())
@@ -45,15 +45,29 @@ namespace Ombi.Core.Rule.Rules.Request
                        x.ImdbId == movie.ImdbId);
                    if (existing != null)
                    {
-                       found = true;
+                       found = Check4KRequests(movie, existing);
                    }
                 }
-                if(found)
+                if (found)
                 {
                     return Fail(ErrorCode.AlreadyRequested, $"\"{obj.Title}\" has already been requested");
                 }
             }
             return Success();
         }
+
+        private static bool Check4KRequests(MovieRequests movie,MovieRequests existing)
+        {
+            if (movie.Has4KRequest && existing.Has4KRequest)
+            {
+               return true;
+            }
+            if (!movie.Has4KRequest && !existing.Has4KRequest)
+            {
+                return true;
+            }
+
+            return false;
+        }
     }
 }

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

@@ -25,6 +25,8 @@ namespace Ombi.Store.Entities.Requests
         public int RootPathOverride { get; set; }
         public int QualityOverride { get; set; }
 
+        public bool Has4KRequest  { get; set; }
+
         /// <summary>
         /// Only Use for setting the Language Code, Use the LanguageCode property for reading
         /// </summary>

src/Ombi.Store/MigrationHelper.cs

@@ -12,5 +12,13 @@ INSERT INTO AspnetRoles(Id, ConcurrencyStamp, Name, NormalizedName)
 SELECT '{Guid.NewGuid()}','{Guid.NewGuid()}','{role}', '{role.ToUpper()}' 
 WHERE NOT EXISTS(SELECT 1 FROM AspnetRoles WHERE Name = '{role}');");
         }
+
+        public static void InsertRoleMySql(this MigrationBuilder mb, string role)
+        {
+            mb.Sql($@"
+INSERT INTO AspNetRoles(Id, ConcurrencyStamp, Name, NormalizedName) 
+SELECT '{Guid.NewGuid()}','{Guid.NewGuid()}','{role}', '{role.ToUpper()}' 
+WHERE NOT EXISTS(SELECT 1 FROM AspNetRoles WHERE Name = '{role}');");
+        }
     }
 }

src/Ombi.Store/Migrations/OmbiMySql/20220210195008_Radarr4kRole.cs

@@ -9,7 +9,7 @@ namespace Ombi.Store.Migrations.OmbiMySql
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            migrationBuilder.InsertRole(OmbiRoles.Request4KMovie);
+            migrationBuilder.InsertRoleMySql(OmbiRoles.Request4KMovie);
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)

src/Ombi.Store/Migrations/OmbiMySql/20220210201011_MovieRequest4K.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Ombi.Store.Migrations.OmbiMySql
+{
+    public partial class MovieRequest4K : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Has4KRequest",
+                table: "MovieRequests",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Has4KRequest",
+                table: "MovieRequests");
+        }
+    }
+}

src/Ombi.Store/Migrations/OmbiMySql/OmbiMySqlContextModelSnapshot.cs

@@ -659,6 +659,9 @@ namespace Ombi.Store.Migrations.OmbiMySql
                     b.Property<string>("ImdbId")
                         .HasColumnType("longtext");
 
+                    b.Property<bool>("Has4KRequest")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<int?>("IssueId")
                         .HasColumnType("int");
 

src/Ombi.Store/Migrations/OmbiSqlite/20220210200338_MovieRequest4K.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Ombi.Store.Migrations.OmbiSqlite
+{
+    public partial class MovieRequest4K : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Has4KRequest",
+                table: "MovieRequests",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Has4KRequest",
+                table: "MovieRequests");
+        }
+    }
+}

src/Ombi.Store/Migrations/OmbiSqlite/OmbiSqliteContextModelSnapshot.cs

@@ -657,6 +657,9 @@ namespace Ombi.Store.Migrations.OmbiSqlite
                     b.Property<string>("ImdbId")
                         .HasColumnType("TEXT");
 
+                    b.Property<bool>("Has4KRequest")
+                        .HasColumnType("INTEGER");
+
                     b.Property<int?>("IssueId")
                         .HasColumnType("INTEGER");
 

src/Ombi/ClientApp/src/app/interfaces/IRequestModel.ts

@@ -16,6 +16,7 @@ export interface IMovieRequests extends IFullBaseRequest {
   subscribed: boolean;
   showSubscribe: boolean;
   requestStatus: string;
+  has4KRequest: boolean;
 
   // For the UI
   rootPathOverrideTitle: string;
@@ -176,6 +177,7 @@ export interface IEpisodesRequests {
 export interface IMovieRequestModel extends BaseRequestOptions {
   theMovieDbId: number;
   languageCode: string | undefined;
+  is4KRequest?: boolean;
 }
 
 export interface IFilter {