Finished #6

PlexRequests.Core/SettingModels/PlexRequestSettings.cs

@@ -32,6 +32,13 @@ namespace PlexRequests.Core.SettingModels
 {
     public class PlexRequestSettings : Settings
     {
+        public PlexRequestSettings()
+        {
+            TvWeeklyRequestLimit = 0;
+            MovieWeeklyRequestLimit = 0;
+            AlbumWeeklyRequestLimit = 0;
+        }
+
         public int Port { get; set; }
         public string BaseUrl { get; set; }
         public bool SearchForMovies { get; set; }
@@ -42,7 +49,9 @@ namespace PlexRequests.Core.SettingModels
         public bool RequireMusicApproval { get; set; }
         public bool UsersCanViewOnlyOwnRequests { get; set; }
         public bool UsersCanViewOnlyOwnIssues { get; set; }
-        public int WeeklyRequestLimit { get; set; }
+        public int MovieWeeklyRequestLimit { get; set; }
+        public int TvWeeklyRequestLimit { get; set; }
+        public int AlbumWeeklyRequestLimit { get; set; }
         public string NoApprovalUsers { get; set; }
         public bool CollectAnalyticData { get; set; }
         public bool IgnoreNotifyForAutoApprovedRequests { get; set; }

PlexRequests.Core/SettingModels/ScheduledJobsSettings.cs

@@ -36,6 +36,7 @@ namespace PlexRequests.Core.SettingModels
             CouchPotatoCacher = 10;
             StoreBackup = 24;
             StoreCleanup = 24;
+            UserRequestLimitResetter = 12;
         }
         public int PlexAvailabilityChecker { get; set; }
         public int SickRageCacher { get; set; }
@@ -43,5 +44,6 @@ namespace PlexRequests.Core.SettingModels
         public int CouchPotatoCacher { get; set; }
         public int StoreBackup { get; set; }
         public int StoreCleanup { get; set; }
+        public int UserRequestLimitResetter { get; set; }
     }
 }

PlexRequests.Core/Setup.cs

@@ -100,7 +100,6 @@ namespace PlexRequests.Core
                 RequireMovieApproval = true,
                 SearchForMovies = true,
                 SearchForTvShows = true,
-                WeeklyRequestLimit = 0,
                 BaseUrl = baseUrl ?? string.Empty,
                 CollectAnalyticData = true,
             };

PlexRequests.Services/Jobs/JobNames.cs

@@ -34,5 +34,6 @@ namespace PlexRequests.Services.Jobs
         public const string SrCacher = "SickRage Cacher";
         public const string PlexChecker = "Plex Availability Cacher";
         public const string StoreCleanup = "Database Cleanup";
+        public const string RequestLimitReset = "Request Limit Reset";
     }
 }

PlexRequests.Services/Jobs/UserRequestLimitResetter.cs

@@ -0,0 +1,119 @@
+#region Copyright
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: UserRequestLimitResetter.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+#endregion
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using NLog;
+
+using PlexRequests.Core;
+using PlexRequests.Core.SettingModels;
+using PlexRequests.Services.Interfaces;
+using PlexRequests.Store;
+using PlexRequests.Store.Models;
+using PlexRequests.Store.Repository;
+
+using Quartz;
+
+namespace PlexRequests.Services.Jobs
+{
+    public class UserRequestLimitResetter : IJob
+    {
+        public UserRequestLimitResetter(IJobRecord record, IRepository<RequestLimit> repo, ISettingsService<PlexRequestSettings> settings)
+        {
+            Record = record;
+            Repo = repo;
+            Settings = settings;
+        }
+        private IJobRecord Record { get; }
+        private IRepository<RequestLimit> Repo { get; }
+        private ISettingsService<PlexRequestSettings> Settings { get; }
+
+        private static Logger Log = LogManager.GetCurrentClassLogger();
+
+        public void Execute(IJobExecutionContext context)
+        {
+            try
+            {
+                var settings = Settings.GetSettings();
+                var users = Repo.GetAll();
+                var requestLimits = users as RequestLimit[] ?? users.ToArray();
+
+                MovieLimit(settings, requestLimits);
+                TvLimit(settings, requestLimits);
+                AlbumLimit(settings, requestLimits);
+            }
+            catch (Exception e)
+            {
+                Log.Error(e);
+            }
+            finally
+            {
+                Record.Record(JobNames.RequestLimitReset);
+            }
+        }
+
+        public void MovieLimit(PlexRequestSettings s, IEnumerable<RequestLimit> allUsers)
+        {
+            if (s.MovieWeeklyRequestLimit == 0)
+            {
+                return; // The limit has not been set
+            }
+            CheckAndDelete(allUsers, RequestType.Movie);
+        }
+
+        public void TvLimit(PlexRequestSettings s, IEnumerable<RequestLimit> allUsers)
+        {
+            if (s.TvWeeklyRequestLimit == 0)
+            {
+                return; // The limit has not been set
+            }
+            CheckAndDelete(allUsers, RequestType.TvShow);
+        }
+
+        public void AlbumLimit(PlexRequestSettings s, IEnumerable<RequestLimit> allUsers)
+        {
+            if (s.AlbumWeeklyRequestLimit == 0)
+            {
+                return; // The limit has not been set
+            }
+            CheckAndDelete(allUsers, RequestType.Album);
+        }
+
+        private void CheckAndDelete(IEnumerable<RequestLimit> allUsers, RequestType type)
+        {
+            var users = allUsers.Where(x => x.RequestType == type);
+            foreach (var u in users)
+            {
+                if (u.FirstRequestDate > DateTime.UtcNow.AddDays(-7))
+                {
+                    Repo.Delete(u);
+                }
+            }
+        }
+    }
+}

PlexRequests.Services/PlexRequests.Services.csproj

@@ -79,6 +79,7 @@
     <Compile Include="Jobs\PlexAvailabilityChecker.cs" />
     <Compile Include="Jobs\SickRageCacher.cs" />
     <Compile Include="Jobs\SonarrCacher.cs" />
+    <Compile Include="Jobs\UserRequestLimitResetter.cs" />
     <Compile Include="Models\PlexAlbum.cs" />
     <Compile Include="Models\PlexMovie.cs" />
     <Compile Include="Models\PlexTvShow.cs" />

PlexRequests.Store/Models/RequestLimit.cs

@@ -0,0 +1,41 @@
+#region Copyright
+// /************************************************************************
+//    Copyright (c) 2016 Jamie Rees
+//    File: UsersToNotify.cs
+//    Created By: Jamie Rees
+//   
+//    Permission is hereby granted, free of charge, to any person obtaining
+//    a copy of this software and associated documentation files (the
+//    "Software"), to deal in the Software without restriction, including
+//    without limitation the rights to use, copy, modify, merge, publish,
+//    distribute, sublicense, and/or sell copies of the Software, and to
+//    permit persons to whom the Software is furnished to do so, subject to
+//    the following conditions:
+//   
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//   
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//  ************************************************************************/
+#endregion
+using System;
+
+using Dapper.Contrib.Extensions;
+
+namespace PlexRequests.Store.Models
+{
+    [Table("RequestLimit")]
+    public class RequestLimit : Entity
+    {
+        public string Username { get; set; }
+        public DateTime FirstRequestDate { get; set; }
+        public int RequestCount { get; set; }
+        public RequestType RequestType { get; set; }
+    }
+}

PlexRequests.Store/PlexRequests.Store.csproj

@@ -65,6 +65,7 @@
     <Compile Include="Entity.cs" />
     <Compile Include="Models\IssueBlobs.cs" />
     <Compile Include="Models\ScheduledJobs.cs" />
+    <Compile Include="Models\RequestLimit.cs" />
     <Compile Include="Models\UsersToNotify.cs" />
     <Compile Include="Repository\BaseGenericRepository.cs" />
     <Compile Include="Repository\IRequestRepository.cs" />

PlexRequests.Store/SqlTables.sql

@@ -82,3 +82,13 @@ CREATE TABLE IF NOT EXISTS IssueBlobs
     Content								BLOB NOT NULL
 );
 CREATE UNIQUE INDEX IF NOT EXISTS IssueBlobs_Id ON IssueBlobs (Id);
+
+CREATE TABLE IF NOT EXISTS RequestLimit
+(
+    Id									INTEGER PRIMARY KEY AUTOINCREMENT,
+    Username							varchar(100) NOT NULL,
+	FirstRequestDate					varchar(100) NOT NULL,
+	RequestCount						INTEGER NOT NULL,
+	RequestType							INTEGER NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS RequestLimit_Id ON RequestLimit (Id);

PlexRequests.UI/Bootstrapper.cs

@@ -193,6 +193,7 @@ namespace PlexRequests.UI
             container.Register<IRepository<UsersToNotify>, GenericRepository<UsersToNotify>>();
             container.Register<IRepository<ScheduledJobs>, GenericRepository<ScheduledJobs>>();
             container.Register<IRepository<IssueBlobs>, GenericRepository<IssueBlobs>>();
+            container.Register<IRepository<RequestLimit>, GenericRepository<RequestLimit>>();
             container.Register<IRequestService, JsonRequestModelRequestService>();
             container.Register<IIssueService, IssueJsonService>();
             container.Register<ISettingsRepository, SettingsJsonRepository>();

PlexRequests.UI/Jobs/Scheduler.cs

@@ -62,6 +62,7 @@ namespace PlexRequests.UI.Jobs
             var cp = JobBuilder.Create<CouchPotatoCacher>().WithIdentity("CouchPotatoCacher", "Cache").Build();
             var store = JobBuilder.Create<StoreBackup>().WithIdentity("StoreBackup", "Database").Build();
             var storeClean = JobBuilder.Create<StoreCleanup>().WithIdentity("StoreCleanup", "Database").Build();
+            var userRequestLimitReset = JobBuilder.Create<UserRequestLimitResetter>().WithIdentity("UserRequestLimiter", "Request").Build();
 
             jobs.Add(plex);
             jobs.Add(sickrage);
@@ -69,6 +70,7 @@ namespace PlexRequests.UI.Jobs
             jobs.Add(cp);
             jobs.Add(store);
             jobs.Add(storeClean);
+            jobs.Add(userRequestLimitReset);
 
             return jobs;
         }
@@ -150,6 +152,13 @@ namespace PlexRequests.UI.Jobs
                           .WithSimpleSchedule(x => x.WithIntervalInHours(s.StoreCleanup).RepeatForever())
                           .Build();
 
+            var userRequestLimiter =
+    TriggerBuilder.Create()
+                  .WithIdentity("UserRequestLimiter", "Request")
+                  .StartAt(DateTimeOffset.Now.AddMinutes(5)) // Everything has started on application start, lets wait 5 minutes
+                  .WithSimpleSchedule(x => x.WithIntervalInHours(s.UserRequestLimitResetter).RepeatForever())
+                  .Build();
+
 
             triggers.Add(plexAvailabilityChecker);
             triggers.Add(srCacher);
@@ -157,6 +166,7 @@ namespace PlexRequests.UI.Jobs
             triggers.Add(cpCacher);
             triggers.Add(storeBackup);
             triggers.Add(storeCleanup);
+            triggers.Add(userRequestLimiter);
 
             return triggers;
         }

PlexRequests.UI/Modules/SearchModule.cs

@@ -72,7 +72,7 @@ namespace PlexRequests.UI.Modules
             INotificationService notify, IMusicBrainzApi mbApi, IHeadphonesApi hpApi, ISettingsService<HeadphonesSettings> hpService,
             ICouchPotatoCacher cpCacher, ISonarrCacher sonarrCacher, ISickRageCacher sickRageCacher, IPlexApi plexApi,
             ISettingsService<PlexSettings> plexService, ISettingsService<AuthenticationSettings> auth, IRepository<UsersToNotify> u, ISettingsService<EmailNotificationSettings> email,
-            IIssueService issue, IAnalytics a) : base("search", prSettings)
+            IIssueService issue, IAnalytics a, IRepository<RequestLimit> rl) : base("search", prSettings)
         {
             Auth = auth;
             PlexService = plexService;
@@ -99,6 +99,7 @@ namespace PlexRequests.UI.Modules
             EmailNotificationSettings = email;
             IssueService = issue;
             Analytics = a;
+            RequestLimitRepo = rl;
 
 
             Get["/", true] = async (x, ct) => await RequestLoad();
@@ -145,6 +146,7 @@ namespace PlexRequests.UI.Modules
         private IRepository<UsersToNotify> UsersToNotifyRepo { get; }
         private IIssueService IssueService { get; }
         private IAnalytics Analytics { get; }
+        private IRepository<RequestLimit> RequestLimitRepo { get; }
         private static Logger Log = LogManager.GetCurrentClassLogger();
 
         private async Task<Negotiator> RequestLoad()
@@ -423,13 +425,17 @@ namespace PlexRequests.UI.Modules
 
         private async Task<Response> RequestMovie(int movieId)
         {
+            var settings = await PrService.GetSettingsAsync();
+            if (!await CheckRequestLimit(settings, RequestType.Movie))
+            {
+                return Response.AsJson(new JsonResponseModel { Result = false, Message = "You have reached your weekly request limit for Movies! Please contact your admin." });
+            }
+
             await Analytics.TrackEventAsync(Category.Search, Action.Request, "Movie", Username, CookieHelper.GetAnalyticClientId(Cookies));
             var movieInfo = MovieApi.GetMovieInformation(movieId).Result;
             var fullMovieName = $"{movieInfo.Title}{(movieInfo.ReleaseDate.HasValue ? $" ({movieInfo.ReleaseDate.Value.Year})" : string.Empty)}";
             Log.Trace("Getting movie info from TheMovieDb");
 
-            var settings = await PrService.GetSettingsAsync();
-
             // check if the movie has already been requested
             Log.Info("Requesting movie with id {0}", movieId);
             var existingRequest = await RequestService.CheckRequestAsync(movieId);
@@ -491,64 +497,23 @@ namespace PlexRequests.UI.Modules
                     Log.Debug("Adding movie to CP result {0}", result);
                     if (result)
                     {
-                        model.Approved = true;
+                        return await AddRequest(model, settings, $"{fullMovieName} was successfully added!");
-                        Log.Info("Adding movie to database (No approval required)");
+                    }
-                        await RequestService.AddRequestAsync(model);
 
-                        if (ShouldSendNotification(RequestType.Movie, settings))
+                    return Response.AsJson(new JsonResponseModel
-                        {
-                            var notificationModel = new NotificationModel
-                            {
-                                Title = model.Title,
-                                User = Username,
-                                DateTime = DateTime.Now,
-                                NotificationType = NotificationType.NewRequest,
-                                RequestType = RequestType.Movie
-                            };
-                            await NotificationService.Publish(notificationModel);
-                        }
-                        return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullMovieName} was successfully added!" });
-                    }
-                    return
-                        Response.AsJson(new JsonResponseModel
                     {
                         Result = false,
                         Message =
                                 "Something went wrong adding the movie to CouchPotato! Please check your settings."
                     });
                 }
-                else
-                {
-                    model.Approved = true;
-                    Log.Info("Adding movie to database (No approval required)");
-                    await RequestService.AddRequestAsync(model);
 
-                    if (ShouldSendNotification(RequestType.Movie, settings))
+                return await AddRequest(model, settings, $"{fullMovieName} was successfully added!");
-                    {
-                        var notificationModel = new NotificationModel
-                        {
-                            Title = model.Title,
-                            User = Username,
-                            DateTime = DateTime.Now,
-                            NotificationType = NotificationType.NewRequest,
-                            RequestType = RequestType.Movie
-                        };
-                        await NotificationService.Publish(notificationModel);
-                    }
-
-                    return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullMovieName} was successfully added!" });
-                }
             }
 
             try
             {
-                Log.Info("Adding movie to database");
+                return await AddRequest(model, settings, $"{fullMovieName} was successfully added!");
-                var id = await RequestService.AddRequestAsync(model);
-
-                var notificationModel = new NotificationModel { Title = model.Title, User = Username, DateTime = DateTime.Now, NotificationType = NotificationType.NewRequest, RequestType = RequestType.Movie };
-                await NotificationService.Publish(notificationModel);
-
-                return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullMovieName} was successfully added!" });
             }
             catch (Exception e)
             {
@@ -566,6 +531,11 @@ namespace PlexRequests.UI.Modules
         /// <returns></returns>
         private async Task<Response> RequestTvShow(int showId, string seasons)
         {
+            var settings = await PrService.GetSettingsAsync();
+            if (!await CheckRequestLimit(settings, RequestType.TvShow))
+            {
+                return Response.AsJson(new JsonResponseModel { Result = false, Message = "You have reached your weekly request limit for TV Shows! Please contact your admin." });
+            }
             await Analytics.TrackEventAsync(Category.Search, Action.Request, "TvShow", Username, CookieHelper.GetAnalyticClientId(Cookies));
             var tvApi = new TvMazeApi();
 
@@ -575,7 +545,6 @@ namespace PlexRequests.UI.Modules
             string fullShowName = $"{showInfo.name} ({firstAir.Year})";
             //#if !DEBUG
 
-            var settings = await PrService.GetSettingsAsync();
 
             // check if the show has already been requested
             Log.Info("Requesting tv show with id {0}", showId);
@@ -669,28 +638,10 @@ namespace PlexRequests.UI.Modules
                     var result = sender.SendToSonarr(sonarrSettings, model);
                     if (!string.IsNullOrEmpty(result?.title))
                     {
-                        model.Approved = true;
+                        return await AddRequest(model, settings, $"{fullShowName} was successfully added!");
-                        Log.Debug("Adding tv to database requests (No approval required & Sonarr)");
-                        await RequestService.AddRequestAsync(model);
-
-                        if (ShouldSendNotification(RequestType.TvShow, settings))
-                        {
-                            var notify1 = new NotificationModel
-                            {
-                                Title = model.Title,
-                                User = Username,
-                                DateTime = DateTime.Now,
-                                NotificationType = NotificationType.NewRequest,
-                                RequestType = RequestType.TvShow
-                            };
-                            await NotificationService.Publish(notify1);
                     }
-                        return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" });
-                    }
-
 
                     return Response.AsJson(ValidationHelper.SendSonarrError(result?.ErrorMessages));
-
                 }
 
                 var srSettings = SickRageService.GetSettings();
@@ -699,57 +650,20 @@ namespace PlexRequests.UI.Modules
                     var result = sender.SendToSickRage(srSettings, model);
                     if (result?.result == "success")
                     {
-                        model.Approved = true;
+                        return await AddRequest(model, settings, $"{fullShowName} was successfully added!");
-                        Log.Debug("Adding tv to database requests (No approval required & SickRage)");
-                        await RequestService.AddRequestAsync(model);
-                        if (ShouldSendNotification(RequestType.TvShow, settings))
-                        {
-                            var notify2 = new NotificationModel
-                            {
-                                Title = model.Title,
-                                User = Username,
-                                DateTime = DateTime.Now,
-                                NotificationType = NotificationType.NewRequest,
-                                RequestType = RequestType.TvShow
-                            };
-                            await NotificationService.Publish(notify2);
-                        }
-
-                        return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" });
                     }
                     return Response.AsJson(new JsonResponseModel { Result = false, Message = result?.message != null ? "<b>Message From SickRage: </b>" + result.message : "Something went wrong adding the movie to SickRage! Please check your settings." });
                 }
 
                 if (!srSettings.Enabled && !sonarrSettings.Enabled)
                 {
-                    model.Approved = true;
+                    return await AddRequest(model, settings, $"{fullShowName} was successfully added!");
-                    Log.Debug("Adding tv to database requests (No approval required) and Sonarr/Sickrage not setup");
-                    await RequestService.AddRequestAsync(model);
-                    if (ShouldSendNotification(RequestType.TvShow, settings))
-                    {
-                        var notify2 = new NotificationModel
-                        {
-                            Title = model.Title,
-                            User = Username,
-                            DateTime = DateTime.Now,
-                            NotificationType = NotificationType.NewRequest,
-                            RequestType = RequestType.TvShow
-                        };
-                        await NotificationService.Publish(notify2);
-                    }
-                    return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" });
                 }
 
                 return Response.AsJson(new JsonResponseModel { Result = false, Message = "The request of TV Shows is not correctly set up. Please contact your admin." });
 
             }
-
+            return await AddRequest(model, settings, $"{fullShowName} was successfully added!");
-            await RequestService.AddRequestAsync(model);
-
-            var notificationModel = new NotificationModel { Title = model.Title, User = Username, DateTime = DateTime.Now, NotificationType = NotificationType.NewRequest, RequestType = RequestType.TvShow };
-            await NotificationService.Publish(notificationModel);
-
-            return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" });
         }
 
         private bool ShouldSendNotification(RequestType type, PlexRequestSettings prSettings)
@@ -770,8 +684,12 @@ namespace PlexRequests.UI.Modules
 
         private async Task<Response> RequestAlbum(string releaseId)
         {
-            await Analytics.TrackEventAsync(Category.Search, Action.Request, "Album", Username, CookieHelper.GetAnalyticClientId(Cookies));
             var settings = await PrService.GetSettingsAsync();
+            if (!await CheckRequestLimit(settings, RequestType.Album))
+            {
+                return Response.AsJson(new JsonResponseModel { Result = false, Message = "You have reached your weekly request limit for Albums! Please contact your admin." });
+            }
+            await Analytics.TrackEventAsync(Category.Search, Action.Request, "Album", Username, CookieHelper.GetAnalyticClientId(Cookies));
             var existingRequest = await RequestService.CheckRequestAsync(releaseId);
             Log.Debug("Checking for an existing request");
 
@@ -849,48 +767,10 @@ namespace PlexRequests.UI.Modules
 
                 var sender = new HeadphonesSender(HeadphonesApi, hpSettings, RequestService);
                 await sender.AddAlbum(model);
-                model.Approved = true;
+                return await AddRequest(model, settings, $"{model.Title} was successfully added!");
-                await RequestService.AddRequestAsync(model);
-
-                if (ShouldSendNotification(RequestType.Album, settings))
-                {
-                    var notify2 = new NotificationModel
-                    {
-                        Title = model.Title,
-                        User = Username,
-                        DateTime = DateTime.Now,
-                        NotificationType = NotificationType.NewRequest,
-                        RequestType = RequestType.Album
-                    };
-                    await NotificationService.Publish(notify2);
             }
 
-                return
+            return await AddRequest(model, settings, $"{model.Title} was successfully added!");
-                    Response.AsJson(new JsonResponseModel
-                    {
-                        Result = true,
-                        Message = $"{model.Title} was successfully added!"
-                    });
-            }
-
-            if (ShouldSendNotification(RequestType.Album, settings))
-            {
-                var notify2 = new NotificationModel
-                {
-                    Title = model.Title,
-                    User = Username,
-                    DateTime = DateTime.Now,
-                    NotificationType = NotificationType.NewRequest,
-                    RequestType = RequestType.Album
-                };
-                await NotificationService.Publish(notify2);
-            }
-            await RequestService.AddRequestAsync(model);
-            return Response.AsJson(new JsonResponseModel
-            {
-                Result = true,
-                Message = $"{model.Title} was successfully added!"
-            });
         }
 
         private string GetMusicBrainzCoverArt(string id)
@@ -994,5 +874,84 @@ namespace PlexRequests.UI.Modules
             var model = seasons.Select(x => x.number);
             return Response.AsJson(model);
         }
+
+        private async Task<bool> CheckRequestLimit(PlexRequestSettings s, RequestType type)
+        {
+            var requestLimit = GetRequestLimitForType(type, s);
+            if (requestLimit == 0)
+            {
+                return true;
+            }
+
+            var limit = await RequestLimitRepo.GetAllAsync();
+            var usersLimit = limit.FirstOrDefault(x => x.Username == Username && x.RequestType == type);
+            if (usersLimit == null)
+            {
+                // Have not set a requestLimit yet
+                return true;
+            }
+
+            return usersLimit.RequestCount >= requestLimit;
+        }
+
+        private int GetRequestLimitForType(RequestType type, PlexRequestSettings s)
+        {
+            int requestLimit;
+            switch (type)
+            {
+                case RequestType.Movie:
+                    requestLimit = s.MovieWeeklyRequestLimit;
+                    break;
+                case RequestType.TvShow:
+                    requestLimit = s.TvWeeklyRequestLimit;
+                    break;
+                case RequestType.Album:
+                    requestLimit = s.AlbumWeeklyRequestLimit;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type), type, null);
+            }
+            return requestLimit;
+        }
+
+        private async Task<Response> AddRequest(RequestedModel model, PlexRequestSettings settings, string message)
+        {
+
+            model.Approved = true;
+            await RequestService.AddRequestAsync(model);
+
+            if (ShouldSendNotification(RequestType.Movie, settings))
+            {
+                var notificationModel = new NotificationModel
+                {
+                    Title = model.Title,
+                    User = Username,
+                    DateTime = DateTime.Now,
+                    NotificationType = NotificationType.NewRequest,
+                    RequestType = RequestType.Movie
+                };
+                await NotificationService.Publish(notificationModel);
+            }
+
+            var limit = await RequestLimitRepo.GetAllAsync();
+            var usersLimit = limit.FirstOrDefault(x => x.Username == Username && x.RequestType == model.Type);
+            if (usersLimit == null)
+            {
+                await RequestLimitRepo.InsertAsync(new RequestLimit
+                {
+                    Username = Username,
+                    RequestType = model.Type,
+                    FirstRequestDate = DateTime.UtcNow,
+                    RequestCount = 1
+                });
+            }
+            else
+            {
+                usersLimit.RequestCount++;
+                await RequestLimitRepo.UpdateAsync(usersLimit);
+            }
+
+            return Response.AsJson(new JsonResponseModel { Result = true, Message = message });
+        }
     }
 }

PlexRequests.UI/Views/Admin/SchedulerSettings.cshtml

@@ -61,6 +61,15 @@
                     <input type="text" class="form-control form-control-custom " id="StoreCleanup" name="StoreCleanup" value="@Model.StoreCleanup">
                 </div>
             </div>
+
+            <small>Please note, this will not reset the users request limit, it will just check every X hours to see if it needs to be reset.</small>
+            <div class="form-group">
+                <label for="UserRequestLimitResetter" class="control-label">User Request Limit Reset (hour)</label>
+                <div>
+                    <input type="text" class="form-control form-control-custom " id="UserRequestLimitResetter" name="UserRequestLimitResetter" value="@Model.UserRequestLimitResetter">
+                </div>
+            </div>
+
             <div class="form-group">
                 <div>
                     <button id="save" type="submit" class="btn btn-primary-outline ">Submit</button>

PlexRequests.UI/Views/Admin/Settings.cshtml

@@ -234,14 +234,34 @@
                 </div>
             </div>
 
-            @*<div class="form-group">
+
-                <label for="WeeklyRequestLimit" class="control-label">Weekly Request Limit</label>
+            <p class="form-group">If the request limits are set to 0 then no request limit is applied.</p>
+        <div class="form-group">
+            <label for="MovieWeeklyRequestLimit" class="control-label">Movie Weekly Request Limit</label>
             <div>
                 <label>
-                        <input type="number" id="WeeklyRequestLimit" name="WeeklyRequestLimit" class="form-control form-control-custom " value="@Model.WeeklyRequestLimit">
+                    <input type="number" id="MovieWeeklyRequestLimit" name="MovieWeeklyRequestLimit" class="form-control form-control-custom " value="@Model.MovieWeeklyRequestLimit">
                 </label>
             </div>
-            </div> //TODO: Need to implement this*@
+        </div>
+
+        <div class="form-group">
+            <label for="TvWeeklyRequestLimit" class="control-label">TV Show Weekly Request Limit</label>
+            <div>
+                <label>
+                    <input type="number" id="TvWeeklyRequestLimit" name="TvWeeklyRequestLimit" class="form-control form-control-custom " value="@Model.TvWeeklyRequestLimit">
+                </label>
+            </div>
+        </div>
+
+            <div class="form-group">
+                <label for="AlbumWeeklyRequestLimit" class="control-label">Album Weekly Request Limit</label>
+                <div>
+                    <label>
+                        <input type="number" id="AlbumWeeklyRequestLimit" name="AlbumWeeklyRequestLimit" class="form-control form-control-custom " value="@Model.AlbumWeeklyRequestLimit">
+                    </label>
+                </div>
+            </div>
 
         <div>
             </div>
@@ -255,7 +275,7 @@
 </div>
 
 <script>
-$(function() {
+    $(function () {
         $('#save').click(function (e) {
             e.preventDefault();
 
@@ -297,7 +317,7 @@ $(function() {
                     if (response) {
                         generateNotify("Success!", "success");
                         $('#apiKey').val(response);
-}
+                    }
                 },
                 error: function (e) {
                     console.log(e);
@@ -305,5 +325,5 @@ $(function() {
                 }
             });
         });
-});
+    });
 </script>