github/Ombi
1
0
Fork 0
mirror of https://github.com/Ombi-app/Ombi.git synced 2025-07-15 01:32:55 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Moved the plex auth token to the plex settings where it should belong.

Browse source
This commit is contained in:
tidusjar 2016-07-14 13:01:07 +01:00
parent ffe6bc41ac
commit 57ec940d5a
18 changed files with 2753 additions and 2837 deletions
Download patch file Download diff file Expand all files Collapse all files

4
PlexRequests.Core/SettingModels/AuthenticationSettings.cs
View file

@ -35,7 +35,9 @@ namespace PlexRequests.Core.SettingModels
{ {
public bool UserAuthentication { get; set; } public bool UserAuthentication { get; set; }
public bool UsePassword { get; set; } public bool UsePassword { get; set; }
public string PlexAuthToken { get; set; } [JsonProperty("PlexAuthToken")]
[Obsolete("This should be migrated over into the Plex Settings and then removed in the next release")]
public string OldPlexAuthToken { get; set; }
/// <summary> /// <summary>

2
PlexRequests.Core/SettingModels/PlexSettings.cs
View file

@ -39,6 +39,8 @@ namespace PlexRequests.Core.SettingModels
public string SubDir { get; set; } public string SubDir { get; set; }
public bool AdvancedSearch { get; set; } public bool AdvancedSearch { get; set; }
public string PlexAuthToken { get; set; }
[JsonIgnore] [JsonIgnore]
public Uri FullUri public Uri FullUri
{ {

24
PlexRequests.Core/Setup.cs
View file

@ -61,6 +61,10 @@ namespace PlexRequests.Core
{ {
MigrateToVersion1800(); MigrateToVersion1800();
} }
if (version > 1899 && version <= 1900)
{
MigrateToVersion1900();
}
} }
return Db.DbConnection().ConnectionString; return Db.DbConnection().ConnectionString;
@ -167,11 +171,23 @@ namespace PlexRequests.Core
Log.Error(ex, "Failed to cache CouchPotato quality profiles!"); Log.Error(ex, "Failed to cache CouchPotato quality profiles!");
} }
} }
public void MigrateToVersion1700() public void MigrateToVersion1900()
{ {
// Drop old tables // Need to change the Plex Token location
TableCreation.DropTable(Db.DbConnection(), "User"); var authSettings = new SettingsServiceV2<AuthenticationSettings>(new SettingsJsonRepository(Db, new MemoryCacheProvider()));
TableCreation.DropTable(Db.DbConnection(), "Log"); var auth = authSettings.GetSettings();
var plexSettings = new SettingsServiceV2<PlexSettings>(new SettingsJsonRepository(Db, new MemoryCacheProvider()));
var currentSettings = plexSettings.GetSettings();
if (!string.IsNullOrEmpty(auth.OldPlexAuthToken))
{
currentSettings.PlexAuthToken = auth.OldPlexAuthToken;
plexSettings.SaveSettings(currentSettings);
// Clear out the old value
auth.OldPlexAuthToken = string.Empty;
authSettings.SaveSettings(auth);
}
} }
/// <summary> /// <summary>

2
PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
View file

@ -65,7 +65,7 @@ namespace PlexRequests.Services.Tests
CacheMock = new Mock<ICacheProvider>(); CacheMock = new Mock<ICacheProvider>();
NotifyUsers = new Mock<IRepository<UsersToNotify>>(); NotifyUsers = new Mock<IRepository<UsersToNotify>>();
JobRec = new Mock<IJobRecord>(); JobRec = new Mock<IJobRecord>();
Checker = new PlexAvailabilityChecker(SettingsMock.Object, AuthMock.Object, RequestMock.Object, PlexMock.Object, CacheMock.Object, NotificationMock.Object, JobRec.Object, NotifyUsers.Object); Checker = new PlexAvailabilityChecker(SettingsMock.Object, RequestMock.Object, PlexMock.Object, CacheMock.Object, NotificationMock.Object, JobRec.Object, NotifyUsers.Object);
} }

34
PlexRequests.Services/Jobs/PlexAvailabilityChecker.cs
View file

@ -36,7 +36,6 @@ using PlexRequests.Core;
using PlexRequests.Core.Models; using PlexRequests.Core.Models;
using PlexRequests.Core.SettingModels; using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using PlexRequests.Helpers.Analytics;
using PlexRequests.Services.Interfaces; using PlexRequests.Services.Interfaces;
using PlexRequests.Services.Models; using PlexRequests.Services.Models;
using PlexRequests.Services.Notification; using PlexRequests.Services.Notification;
@ -52,11 +51,10 @@ namespace PlexRequests.Services.Jobs
{ {
public class PlexAvailabilityChecker : IJob, IAvailabilityChecker public class PlexAvailabilityChecker : IJob, IAvailabilityChecker
{ {
public PlexAvailabilityChecker(ISettingsService<PlexSettings> plexSettings, ISettingsService<AuthenticationSettings> auth, IRequestService request, IPlexApi plex, ICacheProvider cache, public PlexAvailabilityChecker(ISettingsService<PlexSettings> plexSettings, IRequestService request, IPlexApi plex, ICacheProvider cache,
INotificationService notify, IJobRecord rec, IRepository<UsersToNotify> users) INotificationService notify, IJobRecord rec, IRepository<UsersToNotify> users)
{ {
Plex = plexSettings; Plex = plexSettings;
Auth = auth;
RequestService = request; RequestService = request;
PlexApi = plex; PlexApi = plex;
Cache = cache; Cache = cache;
@ -66,7 +64,6 @@ namespace PlexRequests.Services.Jobs
} }
private ISettingsService<PlexSettings> Plex { get; } private ISettingsService<PlexSettings> Plex { get; }
private ISettingsService<AuthenticationSettings> Auth { get; }
private IRequestService RequestService { get; } private IRequestService RequestService { get; }
private static Logger Log = LogManager.GetCurrentClassLogger(); private static Logger Log = LogManager.GetCurrentClassLogger();
private IPlexApi PlexApi { get; } private IPlexApi PlexApi { get; }
@ -77,15 +74,14 @@ namespace PlexRequests.Services.Jobs
public void CheckAndUpdateAll() public void CheckAndUpdateAll()
{ {
var plexSettings = Plex.GetSettings(); var plexSettings = Plex.GetSettings();
var authSettings = Auth.GetSettings();
if (!ValidateSettings(plexSettings, authSettings)) if (!ValidateSettings(plexSettings))
{ {
Log.Debug("Validation of the plex settings failed."); Log.Debug("Validation of the plex settings failed.");
return; return;
} }
var libraries = CachedLibraries(authSettings, plexSettings, true); //force setting the cache (10 min intervals via scheduler) var libraries = CachedLibraries(plexSettings, true); //force setting the cache (10 min intervals via scheduler)
if (libraries == null || !libraries.Any()) if (libraries == null || !libraries.Any())
{ {
@ -140,7 +136,7 @@ namespace PlexRequests.Services.Jobs
if (modifiedModel.Any()) if (modifiedModel.Any())
{ {
NotifyUsers(modifiedModel, authSettings.PlexAuthToken); NotifyUsers(modifiedModel, plexSettings.PlexAuthToken);
RequestService.BatchUpdate(modifiedModel); RequestService.BatchUpdate(modifiedModel);
} }
@ -275,11 +271,11 @@ namespace PlexRequests.Services.Jobs
x.Artist.Equals(artist, StringComparison.CurrentCultureIgnoreCase)); x.Artist.Equals(artist, StringComparison.CurrentCultureIgnoreCase));
} }
private List<PlexSearch> CachedLibraries(AuthenticationSettings authSettings, PlexSettings plexSettings, bool setCache) private List<PlexSearch> CachedLibraries(PlexSettings plexSettings, bool setCache)
{ {
var results = new List<PlexSearch>(); var results = new List<PlexSearch>();
if (!ValidateSettings(plexSettings, authSettings)) if (!ValidateSettings(plexSettings))
{ {
Log.Warn("The settings are not configured"); Log.Warn("The settings are not configured");
return results; // don't error out here, just let it go! let it goo!!! return results; // don't error out here, just let it go! let it goo!!!
@ -289,7 +285,7 @@ namespace PlexRequests.Services.Jobs
{ {
if (setCache) if (setCache)
{ {
results = GetLibraries(authSettings, plexSettings); results = GetLibraries(plexSettings);
if (plexSettings.AdvancedSearch) if (plexSettings.AdvancedSearch)
{ {
for (var i = 0; i < results.Count; i++) for (var i = 0; i < results.Count; i++)
@ -297,7 +293,7 @@ namespace PlexRequests.Services.Jobs
for (var j = 0; j < results[i].Directory.Count; j++) for (var j = 0; j < results[i].Directory.Count; j++)
{ {
var currentItem = results[i].Directory[j]; var currentItem = results[i].Directory[j];
var metaData = PlexApi.GetMetadata(authSettings.PlexAuthToken, plexSettings.FullUri, var metaData = PlexApi.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri,
currentItem.RatingKey); currentItem.RatingKey);
var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Directory.Guid); var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Directory.Guid);
results[i].Directory[j].ProviderId = providerId; results[i].Directory[j].ProviderId = providerId;
@ -305,7 +301,7 @@ namespace PlexRequests.Services.Jobs
for (var j = 0; j < results[i].Video.Count; j++) for (var j = 0; j < results[i].Video.Count; j++)
{ {
var currentItem = results[i].Video[j]; var currentItem = results[i].Video[j];
var metaData = PlexApi.GetMetadata(authSettings.PlexAuthToken, plexSettings.FullUri, var metaData = PlexApi.GetMetadata(plexSettings.PlexAuthToken, plexSettings.FullUri,
currentItem.RatingKey); currentItem.RatingKey);
var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Video.Guid); var providerId = PlexHelper.GetProviderIdFromPlexGuid(metaData.Video.Guid);
results[i].Video[j].ProviderId = providerId; results[i].Video[j].ProviderId = providerId;
@ -320,7 +316,7 @@ namespace PlexRequests.Services.Jobs
else else
{ {
results = Cache.GetOrSet(CacheKeys.PlexLibaries, () => results = Cache.GetOrSet(CacheKeys.PlexLibaries, () =>
GetLibraries(authSettings, plexSettings), CacheKeys.TimeFrameMinutes.SchedulerCaching); GetLibraries(plexSettings), CacheKeys.TimeFrameMinutes.SchedulerCaching);
} }
} }
catch (Exception ex) catch (Exception ex)
@ -331,16 +327,16 @@ namespace PlexRequests.Services.Jobs
return results; return results;
} }
private List<PlexSearch> GetLibraries(AuthenticationSettings authSettings, PlexSettings plexSettings) private List<PlexSearch> GetLibraries(PlexSettings plexSettings)
{ {
var sections = PlexApi.GetLibrarySections(authSettings.PlexAuthToken, plexSettings.FullUri); var sections = PlexApi.GetLibrarySections(plexSettings.PlexAuthToken, plexSettings.FullUri);
List<PlexSearch> libs = new List<PlexSearch>(); List<PlexSearch> libs = new List<PlexSearch>();
if (sections != null) if (sections != null)
{ {
foreach (var dir in sections.Directories) foreach (var dir in sections.Directories)
{ {
var lib = PlexApi.GetLibrary(authSettings.PlexAuthToken, plexSettings.FullUri, dir.Key); var lib = PlexApi.GetLibrary(plexSettings.PlexAuthToken, plexSettings.FullUri, dir.Key);
if (lib != null) if (lib != null)
{ {
libs.Add(lib); libs.Add(lib);
@ -351,9 +347,9 @@ namespace PlexRequests.Services.Jobs
return libs; return libs;
} }
private bool ValidateSettings(PlexSettings plex, AuthenticationSettings auth) private bool ValidateSettings(PlexSettings plex)
{ {
if (plex?.Ip == null || auth?.PlexAuthToken == null) if (plex?.Ip == null || plex?.PlexAuthToken == null)
{ {
Log.Warn("A setting is null, Ensure Plex is configured correctly, and we have a Plex Auth token."); Log.Warn("A setting is null, Ensure Plex is configured correctly, and we have a Plex Auth token.");
return false; return false;

606
PlexRequests.UI.Tests/AdminModuleTests.cs
View file

@ -1,365 +1,365 @@
#region Copyright //#region Copyright
// /************************************************************************ //// /************************************************************************
// Copyright (c) 2016 Jamie Rees //// Copyright (c) 2016 Jamie Rees
// File: UserLoginModuleTests.cs //// File: UserLoginModuleTests.cs
// Created By: Jamie Rees //// Created By: Jamie Rees
// ////
// Permission is hereby granted, free of charge, to any person obtaining //// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the //// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including //// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish, //// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to //// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to //// permit persons to whom the Software is furnished to do so, subject to
// the following conditions: //// the following conditions:
// ////
// The above copyright notice and this permission notice shall be //// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software. //// included in all copies or substantial portions of the Software.
// ////
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, //// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF //// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND //// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE //// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION //// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION //// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. //// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/ //// ************************************************************************/
#endregion //#endregion
using System.Collections.Generic; //using System.Collections.Generic;
using System.Linq; //using System.Linq;
using Moq; //using Moq;
using Nancy; //using Nancy;
using Nancy.Testing; //using Nancy.Testing;
using Newtonsoft.Json; //using Newtonsoft.Json;
using Newtonsoft.Json.Linq; //using Newtonsoft.Json.Linq;
using NUnit.Framework; //using NUnit.Framework;
using PlexRequests.Api.Interfaces; //using PlexRequests.Api.Interfaces;
using PlexRequests.Api.Models.Plex; //using PlexRequests.Api.Models.Plex;
using PlexRequests.Core; //using PlexRequests.Core;
using PlexRequests.Core.SettingModels; //using PlexRequests.Core.SettingModels;
using PlexRequests.Services.Interfaces; //using PlexRequests.Services.Interfaces;
using PlexRequests.Store.Models; //using PlexRequests.Store.Models;
using PlexRequests.Store.Repository; //using PlexRequests.Store.Repository;
using PlexRequests.UI.Models; //using PlexRequests.UI.Models;
using PlexRequests.UI.Modules; //using PlexRequests.UI.Modules;
using PlexRequests.Helpers; //using PlexRequests.Helpers;
using PlexRequests.Helpers.Analytics; //using PlexRequests.Helpers.Analytics;
using PlexRequests.UI.Helpers; //using PlexRequests.UI.Helpers;
namespace PlexRequests.UI.Tests //namespace PlexRequests.UI.Tests
{ //{
[TestFixture] // [TestFixture]
public class AdminModuleTests // public class AdminModuleTests
{ // {
private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; } // private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; }
private Mock<ISettingsService<CouchPotatoSettings>> CpMock { get; set; } // private Mock<ISettingsService<CouchPotatoSettings>> CpMock { get; set; }
private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; } // private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
private Mock<ISettingsService<PlexSettings>> PlexSettingsMock { get; set; } // private Mock<ISettingsService<PlexSettings>> PlexSettingsMock { get; set; }
private Mock<ISettingsService<SonarrSettings>> SonarrSettingsMock { get; set; } // private Mock<ISettingsService<SonarrSettings>> SonarrSettingsMock { get; set; }
private Mock<ISettingsService<SickRageSettings>> SickRageSettingsMock { get; set; } // private Mock<ISettingsService<SickRageSettings>> SickRageSettingsMock { get; set; }
private Mock<ISettingsService<ScheduledJobsSettings>> ScheduledJobsSettingsMock { get; set; } // private Mock<ISettingsService<ScheduledJobsSettings>> ScheduledJobsSettingsMock { get; set; }
private Mock<ISettingsService<EmailNotificationSettings>> EmailMock { get; set; } // private Mock<ISettingsService<EmailNotificationSettings>> EmailMock { get; set; }
private Mock<ISettingsService<PushbulletNotificationSettings>> PushbulletSettings { get; set; } // private Mock<ISettingsService<PushbulletNotificationSettings>> PushbulletSettings { get; set; }
private Mock<ISettingsService<PushoverNotificationSettings>> PushoverSettings { get; set; } // private Mock<ISettingsService<PushoverNotificationSettings>> PushoverSettings { get; set; }
private Mock<ISettingsService<HeadphonesSettings>> HeadphonesSettings { get; set; } // private Mock<ISettingsService<HeadphonesSettings>> HeadphonesSettings { get; set; }
private Mock<IPlexApi> PlexMock { get; set; } // private Mock<IPlexApi> PlexMock { get; set; }
private Mock<ISonarrApi> SonarrApiMock { get; set; } // private Mock<ISonarrApi> SonarrApiMock { get; set; }
private Mock<IPushbulletApi> PushbulletApi { get; set; } // private Mock<IPushbulletApi> PushbulletApi { get; set; }
private Mock<IPushoverApi> PushoverApi { get; set; } // private Mock<IPushoverApi> PushoverApi { get; set; }
private Mock<ICouchPotatoApi> CpApi { get; set; } // private Mock<ICouchPotatoApi> CpApi { get; set; }
private Mock<IJobRecord> RecorderMock { get; set; } // private Mock<IJobRecord> RecorderMock { get; set; }
private Mock<IRepository<LogEntity>> LogRepo { get; set; } // private Mock<IRepository<LogEntity>> LogRepo { get; set; }
private Mock<INotificationService> NotificationService { get; set; } // private Mock<INotificationService> NotificationService { get; set; }
private Mock<ICacheProvider> Cache { get; set; } // private Mock<ICacheProvider> Cache { get; set; }
private Mock<ISettingsService<LogSettings>> Log { get; set; } // private Mock<ISettingsService<LogSettings>> Log { get; set; }
private Mock<ISettingsService<SlackNotificationSettings>> SlackSettings { get; set; } // private Mock<ISettingsService<SlackNotificationSettings>> SlackSettings { get; set; }
private Mock<ISettingsService<LandingPageSettings>> LandingPageSettings { get; set; } // private Mock<ISettingsService<LandingPageSettings>> LandingPageSettings { get; set; }
private Mock<ISlackApi> SlackApi { get; set; } // private Mock<ISlackApi> SlackApi { get; set; }
private Mock<IAnalytics> IAnalytics { get; set; } // private Mock<IAnalytics> IAnalytics { get; set; }
private ConfigurableBootstrapper Bootstrapper { get; set; } // private ConfigurableBootstrapper Bootstrapper { get; set; }
[SetUp] // [SetUp]
public void Setup() // public void Setup()
{ // {
AuthMock = new Mock<ISettingsService<AuthenticationSettings>>(); // AuthMock = new Mock<ISettingsService<AuthenticationSettings>>();
var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock = new Mock<IPlexApi>(); // PlexMock = new Mock<IPlexApi>();
PlexMock.Setup(x => x.SignIn("Username1", "Password1")) // PlexMock.Setup(x => x.SignIn("Username1", "Password1"))
.Returns(new PlexAuthentication { user = new User { authentication_token = "abc", title = "Username1" } }); // .Returns(new PlexAuthentication { user = new User { authentication_token = "abc", title = "Username1" } });
PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>(); // PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>();
PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings()); // PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings());
CpMock = new Mock<ISettingsService<CouchPotatoSettings>>(); // CpMock = new Mock<ISettingsService<CouchPotatoSettings>>();
PlexSettingsMock = new Mock<ISettingsService<PlexSettings>>(); // PlexSettingsMock = new Mock<ISettingsService<PlexSettings>>();
SonarrApiMock = new Mock<ISonarrApi>(); // SonarrApiMock = new Mock<ISonarrApi>();
SonarrSettingsMock = new Mock<ISettingsService<SonarrSettings>>(); // SonarrSettingsMock = new Mock<ISettingsService<SonarrSettings>>();
EmailMock = new Mock<ISettingsService<EmailNotificationSettings>>(); // EmailMock = new Mock<ISettingsService<EmailNotificationSettings>>();
PushbulletApi = new Mock<IPushbulletApi>(); // PushbulletApi = new Mock<IPushbulletApi>();
PushbulletSettings = new Mock<ISettingsService<PushbulletNotificationSettings>>(); // PushbulletSettings = new Mock<ISettingsService<PushbulletNotificationSettings>>();
CpApi = new Mock<ICouchPotatoApi>(); // CpApi = new Mock<ICouchPotatoApi>();
SickRageSettingsMock = new Mock<ISettingsService<SickRageSettings>>(); // SickRageSettingsMock = new Mock<ISettingsService<SickRageSettings>>();
LogRepo = new Mock<IRepository<LogEntity>>(); // LogRepo = new Mock<IRepository<LogEntity>>();
PushoverSettings = new Mock<ISettingsService<PushoverNotificationSettings>>(); // PushoverSettings = new Mock<ISettingsService<PushoverNotificationSettings>>();
PushoverApi = new Mock<IPushoverApi>(); // PushoverApi = new Mock<IPushoverApi>();
NotificationService = new Mock<INotificationService>(); // NotificationService = new Mock<INotificationService>();
HeadphonesSettings = new Mock<ISettingsService<HeadphonesSettings>>(); // HeadphonesSettings = new Mock<ISettingsService<HeadphonesSettings>>();
Cache = new Mock<ICacheProvider>(); // Cache = new Mock<ICacheProvider>();
Log = new Mock<ISettingsService<LogSettings>>(); // Log = new Mock<ISettingsService<LogSettings>>();
SlackApi = new Mock<ISlackApi>(); // SlackApi = new Mock<ISlackApi>();
SlackSettings = new Mock<ISettingsService<SlackNotificationSettings>>(); // SlackSettings = new Mock<ISettingsService<SlackNotificationSettings>>();
LandingPageSettings = new Mock<ISettingsService<LandingPageSettings>>(); // LandingPageSettings = new Mock<ISettingsService<LandingPageSettings>>();
ScheduledJobsSettingsMock = new Mock<ISettingsService<ScheduledJobsSettings>>(); // ScheduledJobsSettingsMock = new Mock<ISettingsService<ScheduledJobsSettings>>();
RecorderMock = new Mock<IJobRecord>(); // RecorderMock = new Mock<IJobRecord>();
IAnalytics = new Mock<IAnalytics>(); // IAnalytics = new Mock<IAnalytics>();
Bootstrapper = new ConfigurableBootstrapper(with => // Bootstrapper = new ConfigurableBootstrapper(with =>
{ // {
with.Module<AdminModule>(); // with.Module<AdminModule>();
with.Dependency(AuthMock.Object); // with.Dependency(AuthMock.Object);
with.Dependency(PlexRequestMock.Object); // with.Dependency(PlexRequestMock.Object);
with.Dependency(CpMock.Object); // with.Dependency(CpMock.Object);
with.Dependency(PlexSettingsMock.Object); // with.Dependency(PlexSettingsMock.Object);
with.Dependency(SonarrApiMock.Object); // with.Dependency(SonarrApiMock.Object);
with.Dependency(SonarrSettingsMock.Object); // with.Dependency(SonarrSettingsMock.Object);
with.Dependency(PlexMock.Object); // with.Dependency(PlexMock.Object);
with.Dependency(EmailMock.Object); // with.Dependency(EmailMock.Object);
with.Dependency(PushbulletApi.Object); // with.Dependency(PushbulletApi.Object);
with.Dependency(PushbulletSettings.Object); // with.Dependency(PushbulletSettings.Object);
with.Dependency(CpApi.Object); // with.Dependency(CpApi.Object);
with.Dependency(SickRageSettingsMock.Object); // with.Dependency(SickRageSettingsMock.Object);
with.Dependency(LogRepo.Object); // with.Dependency(LogRepo.Object);
with.Dependency(PushoverSettings.Object); // with.Dependency(PushoverSettings.Object);
with.Dependency(PushoverApi.Object); // with.Dependency(PushoverApi.Object);
with.Dependency(NotificationService.Object); // with.Dependency(NotificationService.Object);
with.Dependency(IAnalytics.Object); // with.Dependency(IAnalytics.Object);
with.Dependency(HeadphonesSettings.Object); // with.Dependency(HeadphonesSettings.Object);
with.Dependency(Cache.Object); // with.Dependency(Cache.Object);
with.Dependency(Log.Object); // with.Dependency(Log.Object);
with.Dependency(SlackApi.Object); // with.Dependency(SlackApi.Object);
with.Dependency(LandingPageSettings.Object); // with.Dependency(LandingPageSettings.Object);
with.Dependency(SlackSettings.Object); // with.Dependency(SlackSettings.Object);
with.Dependency(ScheduledJobsSettingsMock.Object); // with.Dependency(ScheduledJobsSettingsMock.Object);
with.Dependency(RecorderMock.Object); // with.Dependency(RecorderMock.Object);
with.RootPathProvider<TestRootPathProvider>(); // with.RootPathProvider<TestRootPathProvider>();
with.RequestStartup((container, pipelines, context) => // with.RequestStartup((container, pipelines, context) =>
{ // {
context.CurrentUser = new UserIdentity { UserName = "user", Claims = new List<string> {"Admin"} }; // context.CurrentUser = new UserIdentity { UserName = "user", Claims = new List<string> {"Admin"} };
}); // });
}); // });
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
} // }
[Test] // [Test]
public void RequestAuthTokenTestNewSettings() // public void RequestAuthTokenTestNewSettings()
{ // {
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/admin/requestauth", with => // var result = browser.Post("/admin/requestauth", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once); // PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once); // AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once);
} // }
[Test] // [Test]
public void RequestAuthTokenTestEmptyCredentials() // public void RequestAuthTokenTestEmptyCredentials()
{ // {
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/admin/requestauth", with => // var result = browser.Post("/admin/requestauth", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", string.Empty); // with.FormValue("username", string.Empty);
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
Assert.That(body.Message, Is.Not.Empty); // Assert.That(body.Message, Is.Not.Empty);
PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Never); // PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Never);
AuthMock.Verify(x => x.GetSettings(), Times.Never); // AuthMock.Verify(x => x.GetSettings(), Times.Never);
AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never); // AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never);
} // }
[Test] // [Test]
public void RequestAuthTokenTesPlexSignInFail() // public void RequestAuthTokenTesPlexSignInFail()
{ // {
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/admin/requestauth", with => // var result = browser.Post("/admin/requestauth", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Badusername"); // with.FormValue("username", "Badusername");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
Assert.That(body.Message, Is.Not.Empty); // Assert.That(body.Message, Is.Not.Empty);
PlexMock.Verify(x => x.SignIn("Badusername", "Password1"), Times.Once); // PlexMock.Verify(x => x.SignIn("Badusername", "Password1"), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Never); // AuthMock.Verify(x => x.GetSettings(), Times.Never);
AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never); // AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Never);
} // }
[Test] // [Test]
public void RequestAuthTokenTestExistingSettings() // public void RequestAuthTokenTestExistingSettings()
{ // {
AuthMock.Setup(x => x.GetSettings()).Returns(() => null); // AuthMock.Setup(x => x.GetSettings()).Returns(() => null);
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/admin/requestauth", with => // var result = browser.Post("/admin/requestauth", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once); // PlexMock.Verify(x => x.SignIn("Username1", "Password1"), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once); // AuthMock.Verify(x => x.SaveSettings(It.IsAny<AuthenticationSettings>()), Times.Once);
} // }
[Test] // [Test]
public void GetUsersSuccessfully() // public void GetUsersSuccessfully()
{ // {
var users = new PlexFriends { User = new[] { new UserFriends { Title = "abc2" }, } }; // var users = new PlexFriends { User = new[] { new UserFriends { Title = "abc2" }, } };
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users);
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Get("/admin/getusers", with => // var result = browser.Get("/admin/getusers", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JObject>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JObject>(result.Body.AsString());
var user = body["users"]; // var user = body["users"];
Assert.That(body, Is.Not.Null); // Assert.That(body, Is.Not.Null);
Assert.That(user.ToString().Contains("abc"), Is.True); // Assert.That(user.ToString().Contains("abc"), Is.True);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
} // }
[Test] // [Test]
public void GetUsersReturnsNoUsers() // public void GetUsersReturnsNoUsers()
{ // {
var users = new PlexFriends(); // var users = new PlexFriends();
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(users);
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Get("/admin/getusers", with => // var result = browser.Get("/admin/getusers", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<string>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<string>(result.Body.AsString());
Assert.That(body, Is.Not.Null); // Assert.That(body, Is.Not.Null);
Assert.That(string.IsNullOrWhiteSpace(body), Is.True); // Assert.That(string.IsNullOrWhiteSpace(body), Is.True);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
} // }
[Test] // [Test]
public void GetUsersReturnsNull() // public void GetUsersReturnsNull()
{ // {
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(() => null); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(() => null);
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Get("/admin/getusers", with => // var result = browser.Get("/admin/getusers", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<string>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<string>(result.Body.AsString());
Assert.That(body, Is.Not.Null); // Assert.That(body, Is.Not.Null);
Assert.That(string.IsNullOrWhiteSpace(body), Is.True); // Assert.That(string.IsNullOrWhiteSpace(body), Is.True);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
} // }
[Test] // [Test]
public void GetUsersTokenIsNull() // public void GetUsersTokenIsNull()
{ // {
AuthMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings()); // AuthMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Get("/admin/getusers", with => // var result = browser.Get("/admin/getusers", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("username", "Username1"); // with.FormValue("username", "Username1");
with.FormValue("password", "Password1"); // with.FormValue("password", "Password1");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JObject>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JObject>(result.Body.AsString());
var user = (string)body["users"]; // var user = (string)body["users"];
Assert.That(body, Is.Not.Null); // Assert.That(body, Is.Not.Null);
Assert.That(string.IsNullOrWhiteSpace(user), Is.True); // Assert.That(string.IsNullOrWhiteSpace(user), Is.True);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
} // }
} // }
} //}

1556
PlexRequests.UI.Tests/ApiModuleTests.cs
View file

File diff suppressed because it is too large Load diff

882
PlexRequests.UI.Tests/UserLoginModuleTests.cs
View file

@ -1,441 +1,441 @@
#region Copyright //#region Copyright
// /************************************************************************ //// /************************************************************************
// Copyright (c) 2016 Jamie Rees //// Copyright (c) 2016 Jamie Rees
// File: UserLoginModuleTests.cs //// File: UserLoginModuleTests.cs
// Created By: Jamie Rees //// Created By: Jamie Rees
// ////
// Permission is hereby granted, free of charge, to any person obtaining //// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the //// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including //// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish, //// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to //// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to //// permit persons to whom the Software is furnished to do so, subject to
// the following conditions: //// the following conditions:
// ////
// The above copyright notice and this permission notice shall be //// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software. //// included in all copies or substantial portions of the Software.
// ////
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, //// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF //// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND //// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE //// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION //// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION //// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. //// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/ //// ************************************************************************/
#endregion //#endregion
using System.Collections.Generic; //using System.Collections.Generic;
using System.Threading.Tasks; //using System.Threading.Tasks;
using Moq; //using Moq;
using Nancy; //using Nancy;
using Nancy.Testing; //using Nancy.Testing;
using Newtonsoft.Json; //using Newtonsoft.Json;
using NUnit.Framework; //using NUnit.Framework;
using PlexRequests.Api.Interfaces; //using PlexRequests.Api.Interfaces;
using PlexRequests.Api.Models.Plex; //using PlexRequests.Api.Models.Plex;
using PlexRequests.Core; //using PlexRequests.Core;
using PlexRequests.Core.SettingModels; //using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers.Analytics; //using PlexRequests.Helpers.Analytics;
using PlexRequests.UI.Models; //using PlexRequests.UI.Models;
using PlexRequests.UI.Modules; //using PlexRequests.UI.Modules;
namespace PlexRequests.UI.Tests //namespace PlexRequests.UI.Tests
{ //{
[TestFixture] // [TestFixture]
public class UserLoginModuleTests // public class UserLoginModuleTests
{ // {
private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; } // private Mock<ISettingsService<AuthenticationSettings>> AuthMock { get; set; }
private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; } // private Mock<ISettingsService<PlexRequestSettings>> PlexRequestMock { get; set; }
private Mock<ISettingsService<LandingPageSettings>> LandingPageMock { get; set; } // private Mock<ISettingsService<LandingPageSettings>> LandingPageMock { get; set; }
private ConfigurableBootstrapper Bootstrapper { get; set; } // private ConfigurableBootstrapper Bootstrapper { get; set; }
private Mock<IPlexApi> PlexMock { get; set; } // private Mock<IPlexApi> PlexMock { get; set; }
private Mock<IAnalytics> IAnalytics { get; set; } // private Mock<IAnalytics> IAnalytics { get; set; }
[SetUp] // [SetUp]
public void Setup() // public void Setup()
{ // {
AuthMock = new Mock<ISettingsService<AuthenticationSettings>>(); // AuthMock = new Mock<ISettingsService<AuthenticationSettings>>();
PlexMock = new Mock<IPlexApi>(); // PlexMock = new Mock<IPlexApi>();
LandingPageMock = new Mock<ISettingsService<LandingPageSettings>>(); // LandingPageMock = new Mock<ISettingsService<LandingPageSettings>>();
PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>(); // PlexRequestMock = new Mock<ISettingsService<PlexRequestSettings>>();
PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings()); // PlexRequestMock.Setup(x => x.GetSettings()).Returns(new PlexRequestSettings());
PlexRequestMock.Setup(x => x.GetSettingsAsync()).Returns(Task.FromResult(new PlexRequestSettings())); // PlexRequestMock.Setup(x => x.GetSettingsAsync()).Returns(Task.FromResult(new PlexRequestSettings()));
LandingPageMock.Setup(x => x.GetSettings()).Returns(new LandingPageSettings()); // LandingPageMock.Setup(x => x.GetSettings()).Returns(new LandingPageSettings());
IAnalytics = new Mock<IAnalytics>(); // IAnalytics = new Mock<IAnalytics>();
Bootstrapper = new ConfigurableBootstrapper(with => // Bootstrapper = new ConfigurableBootstrapper(with =>
{ // {
with.Module<UserLoginModule>(); // with.Module<UserLoginModule>();
with.Dependency(PlexRequestMock.Object); // with.Dependency(PlexRequestMock.Object);
with.Dependency(AuthMock.Object); // with.Dependency(AuthMock.Object);
with.Dependency(PlexMock.Object); // with.Dependency(PlexMock.Object);
with.Dependency(LandingPageMock.Object); // with.Dependency(LandingPageMock.Object);
with.Dependency(IAnalytics.Object); // with.Dependency(IAnalytics.Object);
with.RootPathProvider<TestRootPathProvider>(); // with.RootPathProvider<TestRootPathProvider>();
}); // });
} // }
[Test] // [Test]
public void LoginWithoutAuthentication() // public void LoginWithoutAuthentication()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc")); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
} // }
[Test] // [Test]
public void LoginWithoutAuthenticationWithEmptyUsername() // public void LoginWithoutAuthenticationWithEmptyUsername()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = false, PlexAuthToken = "abc" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", string.Empty); // with.FormValue("Username", string.Empty);
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
AuthMock.Verify(x => x.GetSettings(), Times.Never); // AuthMock.Verify(x => x.GetSettings(), Times.Never);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
} // }
[Test] // [Test]
public void LoginWithUsernameSuccessfully() // public void LoginWithUsernameSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends // new UserFriends
{ // {
Title = "abc", // Title = "abc",
}, // },
} // }
}; // };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount()); // PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc")); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
} // }
[Test] // [Test]
public void LoginWithUsernameUnSuccessfully() // public void LoginWithUsernameUnSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends // new UserFriends
{ // {
Username = "aaaa", // Username = "aaaa",
}, // },
} // }
}; // };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount()); // PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
Assert.That(body.Message, Is.Not.Empty); // Assert.That(body.Message, Is.Not.Empty);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
} // }
[Test] // [Test]
public void LoginWithUsernameAndPasswordSuccessfully() // public void LoginWithUsernameAndPasswordSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends // new UserFriends
{ // {
Title = "abc", // Title = "abc",
} // }
} // }
}; // };
var plexAuth = new PlexAuthentication // var plexAuth = new PlexAuthentication
{ // {
user = new User // user = new User
{ // {
authentication_token = "abc" // authentication_token = "abc"
} // }
}; // };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth); // PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount()); // PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(new PlexAccount());
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
with.FormValue("Password", "abc"); // with.FormValue("Password", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc")); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("abc"));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
} // }
[Test] // [Test]
public void LoginWithUsernameAndPasswordUnSuccessfully() // public void LoginWithUsernameAndPasswordUnSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends // new UserFriends
{ // {
Username = "abc", // Username = "abc",
}, // },
} // }
}; // };
var plexAuth = new PlexAuthentication // var plexAuth = new PlexAuthentication
{ // {
user = null // user = null
}; // };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth); // PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
with.FormValue("Password", "abc"); // with.FormValue("Password", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
Assert.That(body.Message, Is.Not.Empty); // Assert.That(body.Message, Is.Not.Empty);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
} // }
[Test] // [Test]
public void AttemptToLoginAsDeniedUser() // public void AttemptToLoginAsDeniedUser()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = false, DeniedUsers = "abc", PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = false, DeniedUsers = "abc", PlexAuthToken = "abc" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "abc"); // with.FormValue("Username", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(false)); // Assert.That(body.Result, Is.EqualTo(false));
Assert.That(body.Message, Is.Not.Empty); // Assert.That(body.Message, Is.Not.Empty);
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
} // }
[Test] // [Test]
public void Logout() // public void Logout()
{ // {
Bootstrapper.WithSession(new Dictionary<string, object> { { SessionKeys.UsernameKey, "abc" } }); // Bootstrapper.WithSession(new Dictionary<string, object> { { SessionKeys.UsernameKey, "abc" } });
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Get("/userlogin/logout", with => // var result = browser.Get("/userlogin/logout", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
}); // });
Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.SeeOther, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.Null);
} // }
[Test] // [Test]
public void LoginWithOwnerUsernameSuccessfully() // public void LoginWithOwnerUsernameSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends() // new UserFriends()
} // }
}; // };
var account = new PlexAccount { Username = "Jamie" }; // var account = new PlexAccount { Username = "Jamie" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account); // PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(new PlexAuthentication { user = new User { username = "Jamie" } }); // PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(new PlexAuthentication { user = new User { username = "Jamie" } });
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "Jamie"); // with.FormValue("Username", "Jamie");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("Jamie")); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("Jamie"));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Never);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Once);
} // }
[Test] // [Test]
public void LoginWithOwnerUsernameAndPasswordSuccessfully() // public void LoginWithOwnerUsernameAndPasswordSuccessfully()
{ // {
var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" }; // var expectedSettings = new AuthenticationSettings { UserAuthentication = true, UsePassword = true, PlexAuthToken = "abc" };
var plexFriends = new PlexFriends // var plexFriends = new PlexFriends
{ // {
User = new[] // User = new[]
{ // {
new UserFriends() // new UserFriends()
} // }
}; // };
var plexAuth = new PlexAuthentication // var plexAuth = new PlexAuthentication
{ // {
user = new User // user = new User
{ // {
authentication_token = "abc", // authentication_token = "abc",
username = "Jamie" // username = "Jamie"
} // }
}; // };
var account = new PlexAccount { Username = "Jamie" }; // var account = new PlexAccount { Username = "Jamie" };
AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings); // AuthMock.Setup(x => x.GetSettings()).Returns(expectedSettings);
PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends); // PlexMock.Setup(x => x.GetUsers(It.IsAny<string>())).Returns(plexFriends);
PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth); // PlexMock.Setup(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>())).Returns(plexAuth);
PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account); // PlexMock.Setup(x => x.GetAccount(It.IsAny<string>())).Returns(account);
Bootstrapper.WithSession(new Dictionary<string, object>()); // Bootstrapper.WithSession(new Dictionary<string, object>());
var browser = new Browser(Bootstrapper); // var browser = new Browser(Bootstrapper);
var result = browser.Post("/userlogin", with => // var result = browser.Post("/userlogin", with =>
{ // {
with.HttpRequest(); // with.HttpRequest();
with.Header("Accept", "application/json"); // with.Header("Accept", "application/json");
with.FormValue("Username", "jamie"); // with.FormValue("Username", "jamie");
with.FormValue("Password", "abc"); // with.FormValue("Password", "abc");
}); // });
Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode)); // Assert.That(HttpStatusCode.OK, Is.EqualTo(result.StatusCode));
Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("jamie")); // Assert.That(result.Context.Request.Session[SessionKeys.UsernameKey], Is.EqualTo("jamie"));
var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString()); // var body = JsonConvert.DeserializeObject<JsonResponseModel>(result.Body.AsString());
Assert.That(body.Result, Is.EqualTo(true)); // Assert.That(body.Result, Is.EqualTo(true));
AuthMock.Verify(x => x.GetSettings(), Times.Once); // AuthMock.Verify(x => x.GetSettings(), Times.Once);
PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once); // PlexMock.Verify(x => x.SignIn(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never); // PlexMock.Verify(x => x.GetUsers(It.IsAny<string>()), Times.Never);
} // }
} // }
} //}

1
PlexRequests.UI/ModelDataProviders/AuthSettingsDataProvider.cs
View file

@ -46,7 +46,6 @@ namespace PlexRequests.UI.ModelDataProviders
.Description("The blacklisted users, this is for internal use by the application, do not modify this list.") .Description("The blacklisted users, this is for internal use by the application, do not modify this list.")
.Required(false); .Required(false);
with.Property(x => x.DeniedUsers).Description("The blacklisted users, comma separated.").Required(false); with.Property(x => x.DeniedUsers).Description("The blacklisted users, comma separated.").Required(false);
with.Property(x => x.PlexAuthToken).Description("The Plex authentication token").Required(false);
with.Property(x => x.UsePassword) with.Property(x => x.UsePassword)
.Description("Require users to use a password to login when authentication is enabled") .Description("Require users to use a password to login when authentication is enabled")
.Required(false) .Required(false)

10
PlexRequests.UI/Modules/AdminModule.cs
View file

@ -290,19 +290,19 @@ namespace PlexRequests.UI.Modules
return Response.AsJson(new { Result = false, Message = "Incorrect username or password!" }); return Response.AsJson(new { Result = false, Message = "Incorrect username or password!" });
} }
var oldSettings = AuthService.GetSettings(); var oldSettings = PlexService.GetSettings();
if (oldSettings != null) if (oldSettings != null)
{ {
oldSettings.PlexAuthToken = model.user.authentication_token; oldSettings.PlexAuthToken = model.user.authentication_token;
AuthService.SaveSettings(oldSettings); PlexService.SaveSettings(oldSettings);
} }
else else
{ {
var newModel = new AuthenticationSettings var newModel = new PlexSettings
{ {
PlexAuthToken = model.user.authentication_token PlexAuthToken = model.user.authentication_token
}; };
AuthService.SaveSettings(newModel); PlexService.SaveSettings(newModel);
} }
return Response.AsJson(new { Result = true, AuthToken = model.user.authentication_token }); return Response.AsJson(new { Result = true, AuthToken = model.user.authentication_token });
@ -311,7 +311,7 @@ namespace PlexRequests.UI.Modules
private Response GetUsers() private Response GetUsers()
{ {
var settings = AuthService.GetSettings(); var settings = PlexService.GetSettings();
var token = settings?.PlexAuthToken; var token = settings?.PlexAuthToken;
if (token == null) if (token == null)

9
PlexRequests.UI/Modules/ApplicationTesterModule.cs
View file

@ -44,14 +44,13 @@ namespace PlexRequests.UI.Modules
{ {
public ApplicationTesterModule(ICouchPotatoApi cpApi, ISonarrApi sonarrApi, IPlexApi plexApi, public ApplicationTesterModule(ICouchPotatoApi cpApi, ISonarrApi sonarrApi, IPlexApi plexApi,
ISettingsService<AuthenticationSettings> authSettings, ISickRageApi srApi, IHeadphonesApi hpApi, ISettingsService<PlexRequestSettings> pr) : base("test", pr) ISickRageApi srApi, IHeadphonesApi hpApi, ISettingsService<PlexRequestSettings> pr) : base("test", pr)
{ {
this.RequiresAuthentication(); this.RequiresAuthentication();
CpApi = cpApi; CpApi = cpApi;
SonarrApi = sonarrApi; SonarrApi = sonarrApi;
PlexApi = plexApi; PlexApi = plexApi;
AuthSettings = authSettings;
SickRageApi = srApi; SickRageApi = srApi;
HeadphonesApi = hpApi; HeadphonesApi = hpApi;
@ -69,7 +68,6 @@ namespace PlexRequests.UI.Modules
private IPlexApi PlexApi { get; } private IPlexApi PlexApi { get; }
private ISickRageApi SickRageApi { get; } private ISickRageApi SickRageApi { get; }
private IHeadphonesApi HeadphonesApi { get; } private IHeadphonesApi HeadphonesApi { get; }
private ISettingsService<AuthenticationSettings> AuthSettings { get; }
private Response CouchPotatoTest() private Response CouchPotatoTest()
{ {
@ -137,14 +135,13 @@ namespace PlexRequests.UI.Modules
{ {
return Response.AsJson(valid.SendJsonError()); return Response.AsJson(valid.SendJsonError());
} }
var settings = AuthSettings.GetSettings(); if (plexSettings?.PlexAuthToken == null)
if (settings?.PlexAuthToken == null)
{ {
return Response.AsJson(new JsonResponseModel { Result = false, Message = "Plex is not setup yet, you need to update your Authentication settings" }); return Response.AsJson(new JsonResponseModel { Result = false, Message = "Plex is not setup yet, you need to update your Authentication settings" });
} }
try try
{ {
var status = PlexApi.GetStatus(settings.PlexAuthToken, plexSettings.FullUri); var status = PlexApi.GetStatus(plexSettings.PlexAuthToken, plexSettings.FullUri);
return status != null return status != null
? Response.AsJson(new JsonResponseModel { Result = true, Message = "Connected to Plex successfully!" }) ? Response.AsJson(new JsonResponseModel { Result = true, Message = "Connected to Plex successfully!" })
: Response.AsJson(new JsonResponseModel { Result = false, Message = "Could not connect to Plex, please check your settings." }); : Response.AsJson(new JsonResponseModel { Result = false, Message = "Could not connect to Plex, please check your settings." });

10
PlexRequests.UI/Modules/LandingPageModule.cs
View file

@ -29,7 +29,6 @@ using System.Threading.Tasks;
using Nancy; using Nancy;
using Nancy.Linker; using Nancy.Linker;
using Nancy.Responses.Negotiation;
using PlexRequests.Api.Interfaces; using PlexRequests.Api.Interfaces;
using PlexRequests.Core; using PlexRequests.Core;
@ -41,12 +40,11 @@ namespace PlexRequests.UI.Modules
public class LandingPageModule : BaseModule public class LandingPageModule : BaseModule
{ {
public LandingPageModule(ISettingsService<PlexRequestSettings> settingsService, ISettingsService<LandingPageSettings> landing, public LandingPageModule(ISettingsService<PlexRequestSettings> settingsService, ISettingsService<LandingPageSettings> landing,
ISettingsService<PlexSettings> ps, IPlexApi pApi, ISettingsService<AuthenticationSettings> auth, IResourceLinker linker) : base("landing", settingsService) ISettingsService<PlexSettings> ps, IPlexApi pApi, IResourceLinker linker) : base("landing", settingsService)
{ {
LandingSettings = landing; LandingSettings = landing;
PlexSettings = ps; PlexSettings = ps;
PlexApi = pApi; PlexApi = pApi;
AuthSettings = auth;
Linker = linker; Linker = linker;
Get["LandingPageIndex","/", true] = async (x, ct) => Get["LandingPageIndex","/", true] = async (x, ct) =>
@ -77,21 +75,19 @@ namespace PlexRequests.UI.Modules
private ISettingsService<LandingPageSettings> LandingSettings { get; } private ISettingsService<LandingPageSettings> LandingSettings { get; }
private ISettingsService<PlexSettings> PlexSettings { get; } private ISettingsService<PlexSettings> PlexSettings { get; }
private ISettingsService<AuthenticationSettings> AuthSettings { get; }
private IPlexApi PlexApi { get; } private IPlexApi PlexApi { get; }
private IResourceLinker Linker { get; } private IResourceLinker Linker { get; }
private async Task<Response> CheckStatus() private async Task<Response> CheckStatus()
{ {
var auth = await AuthSettings.GetSettingsAsync();
var plexSettings = await PlexSettings.GetSettingsAsync(); var plexSettings = await PlexSettings.GetSettingsAsync();
if (string.IsNullOrEmpty(auth.PlexAuthToken) || string.IsNullOrEmpty(plexSettings.Ip)) if (string.IsNullOrEmpty(plexSettings.PlexAuthToken) || string.IsNullOrEmpty(plexSettings.Ip))
{ {
return Response.AsJson(false); return Response.AsJson(false);
} }
try try
{ {
var status = PlexApi.GetStatus(auth.PlexAuthToken, plexSettings.FullUri); var status = PlexApi.GetStatus(plexSettings.PlexAuthToken, plexSettings.FullUri);
return Response.AsJson(status != null); return Response.AsJson(status != null);
} }
catch (Exception) catch (Exception)

98
PlexRequests.UI/Modules/PlexUsersModule.cs
View file

@ -1,98 +0,0 @@
#region Copyright
// /************************************************************************
// Copyright (c) 2016 Jamie Rees
// File: PlexUsersModule.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.Linq;
using System.Threading.Tasks;
using Nancy;
using Nancy.Responses.Negotiation;
using PlexRequests.Api.Interfaces;
using PlexRequests.Api.Models.Music;
using PlexRequests.Core;
using PlexRequests.Core.SettingModels;
using PlexRequests.Store.Models;
using PlexRequests.Store.Repository;
using PlexRequests.UI.Models;
namespace PlexRequests.UI.Modules
{
public class PlexUsersModule : BaseAuthModule
{
public PlexUsersModule(ISettingsService<PlexRequestSettings> pr, IPlexApi plexApi, ISettingsService<AuthenticationSettings> auth,
IRepository<PlexUsers> repo) : base("plexusers", pr)
{
PlexApi = plexApi;
AuthSettings = auth;
Repo = repo;
Get["/"] = x => Index();
Get["/users", true] = async (x, ct) => await GetPlexUsers();
Post["/alias", true] = async (x, ct) => await Alias();
}
private IPlexApi PlexApi { get; }
private ISettingsService<AuthenticationSettings> AuthSettings { get; }
private IRepository<PlexUsers> Repo { get; }
private Negotiator Index()
{
return View["Index"];
}
private async Task<Response> GetPlexUsers()
{
var authSettings = await AuthSettings.GetSettingsAsync();
var users = PlexApi.GetUsers(authSettings.PlexAuthToken);
return Response.AsJson(users.User);
}
private async Task<Response> Alias()
{
var plexUserId = (int)Request.Form["plexid"];
var alias = (string)Request.Form["alias"];
var allUsers = await Repo.GetAllAsync();
var existingUser = allUsers.FirstOrDefault(x => x.PlexUserId == plexUserId);
if (existingUser == null)
{
// Create a new mapping
existingUser = new PlexUsers { PlexUserId = plexUserId, UserAlias = alias };
}
else
{
// Modify existing alias
existingUser.UserAlias = alias;
}
await Repo.InsertAsync(existingUser);
return Response.AsJson(new JsonResponseModel { Result = true });
}
}
}

20
PlexRequests.UI/Modules/UserLoginModule.cs
View file

@ -49,19 +49,22 @@ namespace PlexRequests.UI.Modules
{ {
public class UserLoginModule : BaseModule public class UserLoginModule : BaseModule
{ {
public UserLoginModule(ISettingsService<AuthenticationSettings> auth, IPlexApi api, ISettingsService<PlexRequestSettings> pr, ISettingsService<LandingPageSettings> lp, IAnalytics a) : base("userlogin", pr) public UserLoginModule(ISettingsService<AuthenticationSettings> auth, IPlexApi api, ISettingsService<PlexSettings> plexSettings, ISettingsService<PlexRequestSettings> pr, ISettingsService<LandingPageSettings> lp, IAnalytics a) : base("userlogin", pr)
{ {
AuthService = auth; AuthService = auth;
LandingPageSettings = lp; LandingPageSettings = lp;
Analytics = a; Analytics = a;
Api = api; Api = api;
PlexSettings = plexSettings;
Get["UserLoginIndex","/", true] = async (x, ct) => await Index(); Get["UserLoginIndex","/", true] = async (x, ct) => await Index();
Post["/"] = x => LoginUser(); Post["/", true] = async (x,ct) => await LoginUser();
Get["/logout"] = x => Logout(); Get["/logout"] = x => Logout();
} }
private ISettingsService<AuthenticationSettings> AuthService { get; } private ISettingsService<AuthenticationSettings> AuthService { get; }
private ISettingsService<LandingPageSettings> LandingPageSettings { get; } private ISettingsService<LandingPageSettings> LandingPageSettings { get; }
private ISettingsService<PlexSettings> PlexSettings { get; }
private IPlexApi Api { get; } private IPlexApi Api { get; }
private IAnalytics Analytics { get; } private IAnalytics Analytics { get; }
@ -74,7 +77,7 @@ namespace PlexRequests.UI.Modules
return View["Index", settings]; return View["Index", settings];
} }
private Response LoginUser() private async Task<Response> LoginUser()
{ {
var dateTimeOffset = Request.Form.DateTimeOffset; var dateTimeOffset = Request.Form.DateTimeOffset;
var username = Request.Form.username.Value; var username = Request.Form.username.Value;
@ -86,7 +89,8 @@ namespace PlexRequests.UI.Modules
var authenticated = false; var authenticated = false;
var settings = AuthService.GetSettings(); var settings = await AuthService.GetSettingsAsync();
var plexSettings = await PlexSettings.GetSettingsAsync();
if (IsUserInDeniedList(username, settings)) if (IsUserInDeniedList(username, settings))
{ {
@ -109,14 +113,14 @@ namespace PlexRequests.UI.Modules
if (signedIn.user?.authentication_token != null) if (signedIn.user?.authentication_token != null)
{ {
Log.Debug("Correct credentials, checking if the user is account owner or in the friends list"); Log.Debug("Correct credentials, checking if the user is account owner or in the friends list");
if (CheckIfUserIsOwner(settings.PlexAuthToken, signedIn.user?.username)) if (CheckIfUserIsOwner(plexSettings.PlexAuthToken, signedIn.user?.username))
{ {
Log.Debug("User is the account owner"); Log.Debug("User is the account owner");
authenticated = true; authenticated = true;
} }
else else
{ {
authenticated = CheckIfUserIsInPlexFriends(username, settings.PlexAuthToken); authenticated = CheckIfUserIsInPlexFriends(username, plexSettings.PlexAuthToken);
Log.Debug("Friends list result = {0}", authenticated); Log.Debug("Friends list result = {0}", authenticated);
} }
} }
@ -124,8 +128,8 @@ namespace PlexRequests.UI.Modules
else if (settings.UserAuthentication) // Check against the users in Plex else if (settings.UserAuthentication) // Check against the users in Plex
{ {
Log.Debug("Need to auth"); Log.Debug("Need to auth");
authenticated = CheckIfUserIsInPlexFriends(username, settings.PlexAuthToken); authenticated = CheckIfUserIsInPlexFriends(username, plexSettings.PlexAuthToken);
if (CheckIfUserIsOwner(settings.PlexAuthToken, username)) if (CheckIfUserIsOwner(plexSettings.PlexAuthToken, username))
{ {
Log.Debug("User is the account owner"); Log.Debug("User is the account owner");
authenticated = true; authenticated = true;

18
PlexRequests.UI/Modules/UserManagementModule.cs
View file

@ -18,13 +18,13 @@ namespace PlexRequests.UI.Modules
{ {
public class UserManagementModule : BaseModule public class UserManagementModule : BaseModule
{ {
public UserManagementModule(ISettingsService<PlexRequestSettings> pr, ICustomUserMapper m, IPlexApi plexApi, ISettingsService<AuthenticationSettings> auth) : base("usermanagement", pr) public UserManagementModule(ISettingsService<PlexRequestSettings> pr, ICustomUserMapper m, IPlexApi plexApi, ISettingsService<PlexSettings> plex) : base("usermanagement", pr)
{ {
//this.RequiresClaims(UserClaims.Admin); //this.RequiresClaims(UserClaims.Admin);
UserMapper = m; UserMapper = m;
PlexApi = plexApi; PlexApi = plexApi;
AuthSettings = auth; PlexSettings = plex;
Get["/"] = x => Load(); Get["/"] = x => Load();
@ -36,7 +36,7 @@ namespace PlexRequests.UI.Modules
private ICustomUserMapper UserMapper { get; } private ICustomUserMapper UserMapper { get; }
private IPlexApi PlexApi { get; } private IPlexApi PlexApi { get; }
private ISettingsService<AuthenticationSettings> AuthSettings { get; } private ISettingsService<PlexSettings> PlexSettings { get; }
private Negotiator Load() private Negotiator Load()
{ {
@ -63,11 +63,11 @@ namespace PlexRequests.UI.Modules
}); });
} }
var authSettings = await AuthSettings.GetSettingsAsync(); var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(authSettings.PlexAuthToken)) if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{ {
//Get Plex Users //Get Plex Users
var plexUsers = PlexApi.GetUsers(authSettings.PlexAuthToken); var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
foreach (var u in plexUsers.User) foreach (var u in plexUsers.User)
{ {
@ -116,11 +116,11 @@ namespace PlexRequests.UI.Modules
private async Task<Response> PlexDetails(int id) private async Task<Response> PlexDetails(int id)
{ {
var authSettings = await AuthSettings.GetSettingsAsync(); var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(authSettings.PlexAuthToken)) if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{ {
//Get Plex Users //Get Plex Users
var plexUsers = PlexApi.GetUsers(authSettings.PlexAuthToken); var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
var selectedUser = plexUsers.User?.FirstOrDefault(x => x.Id == id); var selectedUser = plexUsers.User?.FirstOrDefault(x => x.Id == id);
if (selectedUser != null) if (selectedUser != null)

1
PlexRequests.UI/PlexRequests.UI.csproj
View file

@ -222,7 +222,6 @@
<Compile Include="Modules\CultureModule.cs" /> <Compile Include="Modules\CultureModule.cs" />
<Compile Include="Modules\IssuesModule.cs" /> <Compile Include="Modules\IssuesModule.cs" />
<Compile Include="Modules\LandingPageModule.cs" /> <Compile Include="Modules\LandingPageModule.cs" />
<Compile Include="Modules\PlexUsersModule.cs" />
<Compile Include="Modules\UpdateCheckerModule.cs" /> <Compile Include="Modules\UpdateCheckerModule.cs" />
<Compile Include="NinjectModules\ApiModule.cs" /> <Compile Include="NinjectModules\ApiModule.cs" />
<Compile Include="NinjectModules\ConfigurationModule.cs" /> <Compile Include="NinjectModules\ConfigurationModule.cs" />

47
PlexRequests.UI/Views/Admin/Authentication.cshtml
View file

@ -48,29 +48,6 @@
</div> </div>
</div> </div>
<div class="form-group">
<label for="authToken" class="control-label">Plex Authorization Token</label>
<div class="">
<input type="text" class="form-control-custom form-control" id="authToken" name="PlexAuthToken" placeholder="Plex Auth Token" value="@Model.PlexAuthToken">
</div>
</div>
<div class="form-group">
<label for="username" class="control-label">Username and Password</label>
<div>
<input type="text" class="form-control form-control-custom" id="username" name="Username" placeholder="username">
</div>
<br/>
<div>
<input type="password" class="form-control form-control-custom" id="password" name="Password" placeholder="Password">
</div>
</div>
<div class="form-group">
<div class="">
<button id="requestToken" class="btn btn-primary-outline">Request Token <i class="fa fa-key"></i></button>
</div>
</div>
<br /> <br />
<br /> <br />
@ -120,29 +97,7 @@
loadUserList(); loadUserList();
}); });
$('#requestToken').click(function (e) {
e.preventDefault();
var $form = $("#mainForm");
$.ajax({
type: $form.prop("method"),
url: "requestauth",
data: $form.serialize(),
dataType: "json",
success: function (response) {
console.log(response);
if (response.result === true) {
generateNotify("Success!", "success");
$('#authToken').val(response.authToken);
} else {
generateNotify(response.message, "warning");
}
},
error: function (e) {
console.log(e);
generateNotify("Something went wrong!", "danger");
}
});
});

48
PlexRequests.UI/Views/Admin/Plex.cshtml
View file

@ -68,6 +68,30 @@
<input type="text" class="form-control form-control-custom " id="SubDir" name="SubDir" value="@Model.SubDir"> <input type="text" class="form-control form-control-custom " id="SubDir" name="SubDir" value="@Model.SubDir">
</div> </div>
</div> </div>
<div class="form-group">
<label for="authToken" class="control-label">Plex Authorization Token</label>
<div class="">
<input type="text" class="form-control-custom form-control" id="authToken" name="PlexAuthToken" placeholder="Plex Auth Token" value="@Model.PlexAuthToken">
</div>
</div>
<div class="form-group">
<label for="username" class="control-label">Username and Password</label>
<div>
<input type="text" class="form-control form-control-custom" id="username" name="Username" placeholder="username">
</div>
<br />
<div>
<input type="password" class="form-control form-control-custom" id="password" name="Password" placeholder="Password">
</div>
</div>
<div class="form-group">
<div class="">
<button id="requestToken" class="btn btn-primary-outline">Request Token <i class="fa fa-key"></i></button>
</div>
</div>
<div class="form-group"> <div class="form-group">
<div> <div>
<button id="testPlex" type="submit" class="btn btn-primary-outline">Test Connectivity <div id="spinner"></div></button> <button id="testPlex" type="submit" class="btn btn-primary-outline">Test Connectivity <div id="spinner"></div></button>
@ -121,6 +145,30 @@
}); });
}); });
$('#requestToken').click(function (e) {
e.preventDefault();
var $form = $("#mainForm");
$.ajax({
type: $form.prop("method"),
url: "requestauth",
data: $form.serialize(),
dataType: "json",
success: function (response) {
console.log(response);
if (response.result === true) {
generateNotify("Success!", "success");
$('#authToken').val(response.authToken);
} else {
generateNotify(response.message, "warning");
}
},
error: function (e) {
console.log(e);
generateNotify("Something went wrong!", "danger");
}
});
});
$('#save').click(function (e) { $('#save').click(function (e) {
e.preventDefault(); e.preventDefault();
var port = $('#portNumber').val(); var port = $('#portNumber').val();