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);
}
}
