public bool ShouldAutoApprove(RequestType requestType, PlexRequestSettings prSettings, List <string> username) { foreach (var user in username) { var admin = Security.HasPermissions(user, Permissions.Administrator); // if the user is an admin or they are whitelisted, they go ahead and allow auto-approval if (admin) { return(true); } // check by request type if the category requires approval or not switch (requestType) { case RequestType.Movie: return(Security.HasPermissions(user, Permissions.AutoApproveMovie)); case RequestType.TvShow: return(Security.HasPermissions(user, Permissions.AutoApproveTv)); case RequestType.Album: return(Security.HasPermissions(user, Permissions.AutoApproveAlbum)); default: return(false); } } return(false); }
public static void ResetDatabase() { var defaultSettings = new PlexRequestSettings { RequireTvShowApproval = true, RequireMovieApproval = true, SearchForMovies = true, SearchForTvShows = true, BaseUrl = string.Empty, CollectAnalyticData = true, }; UpdateSettings(defaultSettings); LandingPageSettings lp = null; PlexSettings plexSettings = null; SonarrSettings sonarr = null; CouchPotatoSettings cp = null; SickRageSettings sr = null; UpdateSettings(lp); UpdateSettings(plexSettings); UpdateSettings(sonarr); UpdateSettings(cp); UpdateSettings(sr); }
private async Task <Response> PlexRequest() { var form = this.Bind <PlexRequestSettings>(); var valid = this.Validate(form); if (!valid.IsValid) { return(Response.AsJson(valid.SendJsonError())); } var currentSettings = await PlexRequestSettings.GetSettingsAsync(); currentSettings.SearchForMovies = form.SearchForMovies; currentSettings.SearchForTvShows = form.SearchForTvShows; currentSettings.SearchForMusic = form.SearchForMusic; currentSettings.RequireMovieApproval = form.RequireMovieApproval; currentSettings.RequireTvShowApproval = form.RequireTvShowApproval; currentSettings.RequireMusicApproval = form.RequireMusicApproval; var result = await PlexRequestSettings.SaveSettingsAsync(currentSettings); if (result) { return(Response.AsJson(new { Result = true })); } return(Response.AsJson(new JsonResponseModel { Result = false, Message = "Could not save the settings to the database, please try again." })); }
private void CreateDefaultSettingsPage(string baseUrl) { var defaultSettings = new PlexRequestSettings { RequireTvShowApproval = true, RequireMovieApproval = true, SearchForMovies = true, SearchForTvShows = true, BaseUrl = baseUrl ?? string.Empty, CollectAnalyticData = true, }; var s = new SettingsServiceV2 <PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); s.SaveSettings(defaultSettings); var cron = (Quartz.Impl.Triggers.CronTriggerImpl)CronScheduleBuilder.WeeklyOnDayAndHourAndMinute(DayOfWeek.Friday, 7, 0).Build(); var scheduled = new ScheduledJobsSettings { PlexAvailabilityChecker = 60, SickRageCacher = 60, SonarrCacher = 60, CouchPotatoCacher = 60, StoreBackup = 24, StoreCleanup = 24, UserRequestLimitResetter = 12, PlexEpisodeCacher = 12, RecentlyAddedCron = cron.CronExpressionString, // Weekly CRON at 7 am on Mondays }; var scheduledSettings = new SettingsServiceV2 <ScheduledJobsSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); scheduledSettings.SaveSettings(scheduled); }
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 CheckNoRequestLimitTest() { var settings = new PlexRequestSettings { AlbumWeeklyRequestLimit = 0, MovieWeeklyRequestLimit = 2, TvWeeklyRequestLimit = 0 }; var result = Search.CheckRequestLimit(settings, RequestType.Movie).Result; Assert.That(result, Is.True); RequestLimitRepo.Verify(x => x.GetAllAsync(), Times.Once); }
private bool Authenticated(PlexRequestSettings settings) { var query = (DynamicDictionary)Context.Request.Query; dynamic key; if (!query.TryGetValue("apikey", out key)) { return(false); } if ((string)key == settings.ApiKey) { return(true); } return(false); }
private void CreateDefaultSettingsPage(string baseUrl) { var defaultSettings = new PlexRequestSettings { RequireTvShowApproval = true, RequireMovieApproval = true, SearchForMovies = true, SearchForTvShows = true, BaseUrl = baseUrl ?? string.Empty, CollectAnalyticData = true, }; var s = new SettingsServiceV2 <PlexRequestSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); s.SaveSettings(defaultSettings); }
public bool CheckMovieLimitTest(int requestCount) { var users = F.CreateMany <RequestLimit>().ToList(); users.Add(new RequestLimit { Username = "", RequestCount = requestCount, RequestType = RequestType.Movie }); RequestLimitRepo.Setup(x => x.GetAllAsync()).ReturnsAsync(users); var settings = new PlexRequestSettings { AlbumWeeklyRequestLimit = 0, MovieWeeklyRequestLimit = 5, TvWeeklyRequestLimit = 0 }; var result = Search.CheckRequestLimit(settings, RequestType.Movie).Result; RequestLimitRepo.Verify(x => x.GetAllAsync(), Times.Once); return(result); }
/// <summary> /// Filters the issues. Checks to see if we have set <c>UsersCanViewOnlyOwnIssues</c> in the database and filters upon the user logged in and that setting. /// </summary> /// <param name="issues">The issues.</param> private async Task <IEnumerable <IssuesModel> > FilterIssuesAsync(IEnumerable <IssuesModel> issues, bool showResolved = false) { var settings = await PlexRequestSettings.GetSettingsAsync(); IEnumerable <IssuesModel> myIssues; // Is the user an Admin? If so show everything if (IsAdmin) { var issuesModels = issues as IssuesModel[] ?? issues.ToArray(); myIssues = issuesModels.Where(x => x.Deleted == false); if (!showResolved) { myIssues = issuesModels.Where(x => x.IssueStatus != IssueStatus.ResolvedIssue); } } else if (Security.HasPermissions(User, Permissions.UsersCanViewOnlyOwnIssues)) // The user is not an Admin, do we have the settings to hide them? { if (!showResolved) { myIssues = issues.Where( x => x.Issues.Any(i => i.UserReported.Equals(Username, StringComparison.CurrentCultureIgnoreCase)) && x.Deleted == false && x.IssueStatus != IssueStatus.ResolvedIssue); } else { myIssues = issues.Where( x => x.Issues.Any(i => i.UserReported.Equals(Username, StringComparison.CurrentCultureIgnoreCase)) && x.Deleted == false); } } else // Looks like the user is not an admin and there is no settings set. { var issuesModels = issues as IssuesModel[] ?? issues.ToArray(); myIssues = issuesModels.Where(x => x.Deleted == false); if (!showResolved) { myIssues = issuesModels.Where(x => x.IssueStatus != IssueStatus.ResolvedIssue); } } return(myIssues); }
private void UpdateApplicationSettings() { var plex = PlexRequestSettings.GetSettings(); var jobSettings = Jobs.GetSettings(); var newsLetter = NewsletterSettings.GetSettings(); newsLetter.SendToPlexUsers = true; UpdateScheduledSettings(jobSettings); if (plex.SendRecentlyAddedEmail) { newsLetter.SendRecentlyAddedEmail = plex.SendRecentlyAddedEmail; plex.SendRecentlyAddedEmail = false; PlexRequestSettings.SaveSettings(plex); } NewsletterSettings.SaveSettings(newsLetter); Jobs.SaveSettings(jobSettings); }
private async Task <Response> GetCustomDonationUrl(ISettingsService <PlexRequestSettings> pr) { PlexRequestSettings settings = await pr.GetSettingsAsync(); try { if (settings.EnableCustomDonationUrl && Security.IsLoggedIn(Context)) { return(Response.AsJson(new { url = settings.CustomDonationUrl, message = settings.CustomDonationMessage, enabled = true })); } return(Response.AsJson(new { enabled = false })); } catch (Exception e) { Log.Warn("Exception Thrown when attempting to check the custom donation url"); Log.Warn(e); return(Response.AsJson(new { url = settings.CustomDonationUrl, message = settings.CustomDonationMessage })); } }
private async Task <Response> CreateUser() { var username = (string)Request.Form.Username; var userId = Mapper.CreateAdmin(username, Request.Form.Password); Analytics.TrackEventAsync(Category.Wizard, Action.Finish, "Finished the wizard", username, CookieHelper.GetAnalyticClientId(Cookies)); Session[SessionKeys.UsernameKey] = username; // Destroy the Plex Auth Token Session.Delete(SessionKeys.UserWizardPlexAuth); // Update the settings so we know we have been through the wizard var settings = await PlexRequestSettings.GetSettingsAsync(); settings.Wizard = true; await PlexRequestSettings.SaveSettingsAsync(settings); return(this.LoginAndRedirect((Guid)userId, fallbackRedirectUrl: "/search")); }
private async Task <Response> PlexRequest() { var form = this.Bind <PlexRequestSettings>(); var valid = this.Validate(form); if (!valid.IsValid) { return(Response.AsJson(valid.SendJsonError())); } var result = await PlexRequestSettings.SaveSettingsAsync(form); if (result) { return(Response.AsJson(new { Result = true })); } return(Response.AsJson(new JsonResponseModel { Result = false, Message = "Could not save the settings to the database, please try again." })); }
private async Task <Response> CreateUser() { var username = (string)Request.Form.Username; var userId = Mapper.CreateUser(username, Request.Form.Password, EnumHelper <Permissions> .All() - (int)Permissions.ReadOnlyUser, 0); Analytics.TrackEventAsync(Category.Wizard, Action.Finish, "Finished the wizard", username, CookieHelper.GetAnalyticClientId(Cookies)); Session[SessionKeys.UsernameKey] = username; // Destroy the Plex Auth Token Session.Delete(SessionKeys.UserWizardPlexAuth); // Update the settings so we know we have been through the wizard var settings = await PlexRequestSettings.GetSettingsAsync(); settings.Wizard = true; await PlexRequestSettings.SaveSettingsAsync(settings); var baseUrl = string.IsNullOrEmpty(settings.BaseUrl) ? string.Empty : $"/{settings.BaseUrl}"; return(CustomModuleExtensions.LoginAndRedirect(this, (Guid)userId, fallbackRedirectUrl: $"{baseUrl}/search")); }
private void PopulateDefaultUserManagementSettings() { try { var plexRequestSettings = PlexRequestSettings.GetSettings(); UserManagementSettings.SaveSettings(new UserManagementSettings { AutoApproveMovies = !plexRequestSettings.RequireMovieApproval, RequestTvShows = plexRequestSettings.SearchForTvShows, RequestMusic = plexRequestSettings.SearchForMusic, RequestMovies = plexRequestSettings.SearchForMovies, AutoApproveMusic = !plexRequestSettings.RequireMusicApproval, AutoApproveTvShows = !plexRequestSettings.RequireTvShowApproval }); } catch (Exception e) { Logger.Fatal("Exception when migrating Version 1.10.0 (PopulateDefaultUserMngmentSettings)"); Logger.Fatal(e); } }
private bool ShouldAutoApprove(RequestType requestType, PlexRequestSettings prSettings) { // if the user is an admin or they are whitelisted, they go ahead and allow auto-approval if (IsAdmin || prSettings.ApprovalWhiteList.Any(x => x.Equals(Username, StringComparison.OrdinalIgnoreCase))) { return(true); } // check by request type if the category requires approval or not switch (requestType) { case RequestType.Movie: return(!prSettings.RequireMovieApproval); case RequestType.TvShow: return(!prSettings.RequireTvShowApproval); case RequestType.Album: return(!prSettings.RequireMusicApproval); default: return(false); } }
private void UpdatePlexUsers() { try { var settings = PlexSettings.GetSettings(); if (string.IsNullOrEmpty(settings.PlexAuthToken)) { return; } var plexUsers = PlexApi.GetUsers(settings.PlexAuthToken); if (plexUsers?.User == null) { return; } var prSettings = PlexRequestSettings.GetSettings(); var dbUsers = PlexUsers.GetAll().ToList(); foreach (var user in plexUsers.User) { if (dbUsers.FirstOrDefault(x => x.PlexUserId == user.Id) != null) { continue; } int permissions = 0; if (prSettings.SearchForMovies) { permissions = (int)Permissions.RequestMovie; } if (prSettings.SearchForTvShows) { permissions += (int)Permissions.RequestTvShow; } if (prSettings.SearchForMusic) { permissions += (int)Permissions.RequestMusic; } if (!prSettings.RequireMovieApproval) { permissions += (int)Permissions.AutoApproveMovie; } if (!prSettings.RequireTvShowApproval) { permissions += (int)Permissions.AutoApproveTv; } if (!prSettings.RequireMusicApproval) { permissions += (int)Permissions.AutoApproveAlbum; } // Add report Issues permissions += (int)Permissions.ReportIssue; var m = new PlexUsers { PlexUserId = user.Id, Permissions = permissions, Features = 0, UserAlias = string.Empty, EmailAddress = user.Email, Username = user.Username, LoginId = Guid.NewGuid().ToString() }; PlexUsers.Insert(m); } } catch (Exception e) { Logger.Fatal("Exception when migrating Version 1.10.0 (UpdatePlexUsers)"); Logger.Fatal(e); } }