feat(request-limits): ✨ Added in the main logic for the new request limits

src/Ombi.Core/Engine/Interfaces/BaseEngine.cs

@@ -35,7 +35,7 @@ namespace Ombi.Core.Engine.Interfaces
                 return null;
             }
             var username = Username.ToUpper();
-            return _user ?? (_user = await UserManager.Users.FirstOrDefaultAsync(x => x.NormalizedUserName == username));
+            return _user ??= await UserManager.Users.FirstOrDefaultAsync(x => x.NormalizedUserName == username);
         }
 
         protected async Task<string> UserAlias()

src/Ombi.Core/Engine/MovieRequestEngine.cs

@@ -566,7 +566,7 @@ namespace Ombi.Core.Engine
         {
             var langCode = await DefaultLanguageCode(null);
             var collections = await Cache.GetOrAddAsync($"GetCollection{collectionId}{langCode}",
-                () =>  MovieApi.GetCollection(langCode, collectionId, cancellationToken), DateTimeOffset.Now.AddDays(1));
+                () => MovieApi.GetCollection(langCode, collectionId, cancellationToken), DateTimeOffset.Now.AddDays(1));
 
             var results = new List<RequestEngineResult>();
             foreach (var collection in collections.parts)
@@ -583,7 +583,7 @@ namespace Ombi.Core.Engine
                 new RequestEngineResult { Result = false, ErrorMessage = $"The whole collection {collections.name} Is already monitored or requested!" };
             }
 
-            return new RequestEngineResult { Result = true, Message = $"The collection {collections.name} has been successfully added!", RequestId = results.FirstOrDefault().RequestId};
+            return new RequestEngineResult { Result = true, Message = $"The collection {collections.name} has been successfully added!", RequestId = results.FirstOrDefault().RequestId };
         }
 
         private async Task<RequestEngineResult> ProcessSendingMovie(MovieRequests request)
@@ -782,19 +782,65 @@ namespace Ombi.Core.Engine
 
             IQueryable<RequestLog> log = _requestLog.GetAll().Where(x => x.UserId == user.Id && x.RequestType == RequestType.Movie);
 
-            int count = limit - await log.CountAsync(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7));
 
-            DateTime oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7))
+            int count = 0;
+            DateTime oldestRequestedAt = DateTime.Now;
+            DateTime nextRequest = DateTime.Now;
+
+            if (!user.MovieRequestLimitType.HasValue)
+            {
+                count = limit - await log.CountAsync(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7));
+
+                oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7))
+                                                .OrderBy(x => x.RequestDate)
+                                                .Select(x => x.RequestDate)
+                                                .FirstOrDefaultAsync();
+
+                return new RequestQuotaCountModel()
+                {
+                    HasLimit = true,
+                    Limit = limit,
+                    Remaining = count < 0 ? 0 : count,
+                    NextRequest = DateTime.SpecifyKind(oldestRequestedAt.AddDays(7), DateTimeKind.Utc),
+                };
+            }
+
+            switch (user.MovieRequestLimitType)
+            {
+                case RequestLimitType.Day:
+                        count = limit - await log.CountAsync(x => x.RequestDate >= DateTime.UtcNow.Date);
+                        oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date)
+                                                .OrderBy(x => x.RequestDate)
+                                                .Select(x => x.RequestDate)
+                                                .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddDays(1);
+                    break;
+                case RequestLimitType.Week:
+                    count = limit - await log.CountAsync(x => x.RequestDate >= DateTime.UtcNow.Date.AddDays(-7));
+                    oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddDays(-7))
                                             .OrderBy(x => x.RequestDate)
                                             .Select(x => x.RequestDate)
                                             .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddDays(7);
+                    break;
+                case RequestLimitType.Month:
+                    count = limit - await log.CountAsync(x => x.RequestDate >= DateTime.UtcNow.Date.AddMonths(-1));
+                    oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddMonths(-1))
+                                            .OrderBy(x => x.RequestDate)
+                                            .Select(x => x.RequestDate)
+                                            .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddMonths(1);
+                    break;
+                default:
+                    break;
+            }
 
             return new RequestQuotaCountModel()
             {
                 HasLimit = true,
                 Limit = limit,
-                Remaining = count,
+                Remaining = count < 0 ? 0 : count,
-                NextRequest = DateTime.SpecifyKind(oldestRequestedAt.AddDays(7), DateTimeKind.Utc),
+                NextRequest = DateTime.SpecifyKind(nextRequest, DateTimeKind.Utc),
             };
         }
     }

src/Ombi.Core/Engine/TvRequestEngine.cs

@@ -981,29 +981,98 @@ namespace Ombi.Core.Engine
                 };
             }
 
-            IQueryable<RequestLog> log = _requestLog.GetAll()
+            IQueryable<RequestLog> log = _requestLog.GetAll().Where(x => x.UserId == user.Id && x.RequestType == RequestType.TvShow);
-                                            .Where(x => x.UserId == user.Id
-                                                && x.RequestType == RequestType.TvShow
-                                                && x.RequestDate >= DateTime.UtcNow.AddDays(-7));
 
-            // Needed, due to a bug which would cause all episode counts to be 0
+            int count = 0;
-            int zeroEpisodeCount = await log.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
+            DateTime oldestRequestedAt = DateTime.Now;
+            DateTime nextRequest = DateTime.Now;
 
-            int episodeCount = await log.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
 
-            int count = limit - (zeroEpisodeCount + episodeCount);
+            IQueryable<RequestLog> filteredLog;
+            int zeroEpisodeCount;
+            int episodeCount;
 
-            DateTime oldestRequestedAt = await log.OrderBy(x => x.RequestDate)
+            if (!user.EpisodeRequestLimitType.HasValue)
+            {
+                filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7));
+                // Needed, due to a bug which would cause all episode counts to be 0
+                zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
+
+                episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
+
+                count = limit - (zeroEpisodeCount + episodeCount);
+
+                oldestRequestedAt = await log
+                                                .Where(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7))
+                                                .OrderBy(x => x.RequestDate)
+                                                .Select(x => x.RequestDate)
+                                                .FirstOrDefaultAsync();
+
+                return new RequestQuotaCountModel()
+                {
+                    HasLimit = true,
+                    Limit = limit,
+                    Remaining = count < 0 ? 0 : count,
+                    NextRequest = DateTime.SpecifyKind(oldestRequestedAt.AddDays(7), DateTimeKind.Utc),
+                };
+            }
+
+            switch (user.EpisodeRequestLimitType)
+            {
+                case RequestLimitType.Day:
+
+                    filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.Date);
+                    // Needed, due to a bug which would cause all episode counts to be 0
+                    zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
+                    episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
+                    count = limit - (zeroEpisodeCount + episodeCount);
+
+                    oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date)
+                                            .OrderBy(x => x.RequestDate)
                                             .Select(x => x.RequestDate)
                                             .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddDays(1);
+                    break;
+                case RequestLimitType.Week:
+
+                    filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddDays(-7));
+                    // Needed, due to a bug which would cause all episode counts to be 0
+                    zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
+                    episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
+                    count = limit - (zeroEpisodeCount + episodeCount);
+                    
+                    oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddDays(-7))
+                                            .OrderBy(x => x.RequestDate)
+                                            .Select(x => x.RequestDate)
+                                            .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddDays(7);
+                    break;
+                case RequestLimitType.Month:
+                    filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddMonths(-1));
+                    // Needed, due to a bug which would cause all episode counts to be 0
+                    zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
+                    episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
+                    count = limit - (zeroEpisodeCount + episodeCount);
+
+                    oldestRequestedAt = await log.Where(x => x.RequestDate >= DateTime.UtcNow.Date.AddMonths(-1))
+                                            .OrderBy(x => x.RequestDate)
+                                            .Select(x => x.RequestDate)
+                                            .FirstOrDefaultAsync();
+                    nextRequest = oldestRequestedAt.AddMonths(1);
+                    break;
+                default:
+                    break;
+            }
 
             return new RequestQuotaCountModel()
             {
                 HasLimit = true,
                 Limit = limit,
-                Remaining = count,
+                Remaining = count < 0 ? 0 : count,
-                NextRequest = DateTime.SpecifyKind(oldestRequestedAt.AddDays(7), DateTimeKind.Utc),
+                NextRequest = DateTime.SpecifyKind(nextRequest, DateTimeKind.Utc),
             };
+
+            return null;
         }
 
         public async Task<RequestEngineResult> UpdateAdvancedOptions(MediaAdvancedOptions options)

src/Ombi.Store/Entities/OmbiUser.cs

@@ -34,9 +34,6 @@ namespace Ombi.Store.Entities
         public RequestLimitType? MovieRequestLimitType { get; set; }
         public RequestLimitType? EpisodeRequestLimitType { get; set; }
         public RequestLimitType? MusicRequestLimitType { get; set; }
-        public int? MovieRequestLimitAmount { get; set; }
-        public int? EpisodeRequestLimitAmount { get; set; }
-        public int? MusicRequestLimitAmount { get; set; }
 
         public string UserAccessToken { get; set; }
 

src/Ombi.Store/Migrations/OmbiMySql/20210922091445_UserRequestLimits_Pt2.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Ombi.Store.Migrations.OmbiMySql
+{
+    public partial class UserRequestLimits_Pt2 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "EpisodeRequestLimitAmount",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropColumn(
+                name: "MovieRequestLimitAmount",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropColumn(
+                name: "MusicRequestLimitAmount",
+                table: "AspNetUsers");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "EpisodeRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MovieRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MusicRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "int",
+                nullable: true);
+        }
+    }
+}

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

@@ -266,9 +266,6 @@ namespace Ombi.Store.Migrations.OmbiMySql
                     b.Property<int?>("EpisodeRequestLimit")
                         .HasColumnType("int");
 
-                    b.Property<int?>("EpisodeRequestLimitAmount")
-                        .HasColumnType("int");
-
                     b.Property<int?>("EpisodeRequestLimitType")
                         .HasColumnType("int");
 
@@ -287,18 +284,12 @@ namespace Ombi.Store.Migrations.OmbiMySql
                     b.Property<int?>("MovieRequestLimit")
                         .HasColumnType("int");
 
-                    b.Property<int?>("MovieRequestLimitAmount")
-                        .HasColumnType("int");
-
                     b.Property<int?>("MovieRequestLimitType")
                         .HasColumnType("int");
 
                     b.Property<int?>("MusicRequestLimit")
                         .HasColumnType("int");
 
-                    b.Property<int?>("MusicRequestLimitAmount")
-                        .HasColumnType("int");
-
                     b.Property<int?>("MusicRequestLimitType")
                         .HasColumnType("int");
 

src/Ombi.Store/Migrations/OmbiSqlite/20210922091550_UserRequestLimits_Pt2.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Ombi.Store.Migrations.OmbiSqlite
+{
+    public partial class UserRequestLimits_Pt2 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "EpisodeRequestLimitAmount",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropColumn(
+                name: "MovieRequestLimitAmount",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropColumn(
+                name: "MusicRequestLimitAmount",
+                table: "AspNetUsers");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "EpisodeRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MovieRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MusicRequestLimitAmount",
+                table: "AspNetUsers",
+                type: "INTEGER",
+                nullable: true);
+        }
+    }
+}

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

@@ -265,9 +265,6 @@ namespace Ombi.Store.Migrations.OmbiSqlite
                     b.Property<int?>("EpisodeRequestLimit")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int?>("EpisodeRequestLimitAmount")
-                        .HasColumnType("INTEGER");
-
                     b.Property<int?>("EpisodeRequestLimitType")
                         .HasColumnType("INTEGER");
 
@@ -286,18 +283,12 @@ namespace Ombi.Store.Migrations.OmbiSqlite
                     b.Property<int?>("MovieRequestLimit")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int?>("MovieRequestLimitAmount")
-                        .HasColumnType("INTEGER");
-
                     b.Property<int?>("MovieRequestLimitType")
                         .HasColumnType("INTEGER");
 
                     b.Property<int?>("MusicRequestLimit")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int?>("MusicRequestLimitAmount")
-                        .HasColumnType("INTEGER");
-
                     b.Property<int?>("MusicRequestLimitType")
                         .HasColumnType("INTEGER");