private bool CheckIfUserIsInPlexFriends(string username, string authToken)
{
var users = PlexApi.GetUsers(authToken);
var allUsers = users?.User?.Where(x => !string.IsNullOrEmpty(x.Title));
return(allUsers != null && allUsers.Any(x => x.Title.Equals(username, StringComparison.CurrentCultureIgnoreCase)));
}
private string GetUserIdIsInPlexFriends(string username, string authToken)
{
var users = PlexApi.GetUsers(authToken);
var allUsers = users?.User?.Where(x => !string.IsNullOrEmpty(x.Title));
return(allUsers?.Where(x => x.Title.Equals(username, StringComparison.CurrentCultureIgnoreCase)).Select(x => x.Id).FirstOrDefault());
}
public async Task <PlexLibrariesLiteResponse> GetPlexLibraries(string machineId)
{
try
{
var s = await PlexSettings.GetSettingsAsync();
var settings = s.Servers.FirstOrDefault(x => x.MachineIdentifier == machineId);
var libs = await PlexApi.GetLibrariesForMachineId(settings.PlexAuthToken, machineId);
return(new PlexLibrariesLiteResponse
{
Successful = true,
Data = libs.Server.Section
});
}
catch (Exception e)
{
_log.LogWarning(e, "Error thrown when attempting to obtain the plex libs");
var message = e.InnerException != null ? $"{e.Message} - {e.InnerException.Message}" : e.Message;
return(new PlexLibrariesLiteResponse
{
Successful = false,
Message = message
});
}
}
private Response RequestAuthToken()
{
var user = this.Bind <PlexAuth>();
if (string.IsNullOrEmpty(user.username) || string.IsNullOrEmpty(user.password))
{
return(Response.AsJson(new { Result = false, Message = "Please provide a valid username and password" }));
}
var model = PlexApi.SignIn(user.username, user.password);
if (model?.user == null)
{
return(Response.AsJson(new { Result = false, Message = "Incorrect username or password!" }));
}
var oldSettings = AuthService.GetSettings();
if (oldSettings != null)
{
oldSettings.PlexAuthToken = model.user.authentication_token;
AuthService.SaveSettings(oldSettings);
}
else
{
var newModel = new AuthenticationSettings
{
PlexAuthToken = model.user.authentication_token
};
AuthService.SaveSettings(newModel);
}
return(Response.AsJson(new { Result = true, AuthToken = model.user.authentication_token }));
}
private Response GetUsers()
{
var settings = AuthService.GetSettings();
var token = settings?.PlexAuthToken;
if (token == null)
{
return(Response.AsJson(new { Result = true, Users = string.Empty }));
}
try {
var users = PlexApi.GetUsers(token);
if (users == null)
{
return(Response.AsJson(string.Empty));
}
if (users.User == null || users.User?.Length == 0)
{
return(Response.AsJson(string.Empty));
}
var usernames = users.User.Select(x => x.Title);
return(Response.AsJson(new { Result = true, Users = usernames }));
} catch (Exception ex) {
Log.Error(ex);
if (ex is WebException || ex is ApiRequestException)
{
return(Response.AsJson(new { Result = false, Message = "Could not load the user list! We have connectivity problems connecting to Plex, Please ensure we can access Plex.Tv, The error has been logged." }));
}
return(Response.AsJson(new { Result = false, Message = ex.Message }));
}
}
private Response GetUsers()
{
var settings = AuthService.GetSettings();
var token = settings?.PlexAuthToken;
if (token == null)
{
return(Response.AsJson(string.Empty));
}
var users = PlexApi.GetUsers(token);
if (users == null)
{
return(Response.AsJson(string.Empty));
}
if (users.User == null || users.User?.Length == 0)
{
return(Response.AsJson(string.Empty));
}
var usernames = users.User.Select(x => x.Username);
return(Response.AsJson(usernames));
}
private Response PlexTest()
{
var plexSettings = this.Bind<PlexSettings>();
var valid = this.Validate(plexSettings);
if (!valid.IsValid)
{
return Response.AsJson(valid.SendJsonError());
}
var settings = AuthSettings.GetSettings();
if (settings?.PlexAuthToken == null)
{
return Response.AsJson(new JsonResponseModel { Result = false, Message = "Plex is not setup yet, you need to update your Authentication settings" });
}
try
{
var status = PlexApi.GetStatus(settings.PlexAuthToken, plexSettings.FullUri);
return status != null
? 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." });
}
catch (Exception e) // Exceptions are expected, if we cannot connect so we will just log and swallow them.
{
Log.Warn("Exception thrown when attempting to get Plex's status: ");
Log.Warn(e);
var message = $"Could not connect to Plex, please check your settings. <strong>Exception Message:</strong> {e.Message}";
if (e.InnerException != null)
{
message = $"Could not connect to Plex, please check your settings. <strong>Exception Message:</strong> {e.InnerException.Message}";
}
return Response.AsJson(new JsonResponseModel { Result = false, Message = message });
}
}
private Response PlexAuth()
{
var user = this.Bind <PlexAuth>();
if (string.IsNullOrEmpty(user.username) || string.IsNullOrEmpty(user.password))
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Please provide a valid username and password"
}));
}
var model = PlexApi.SignIn(user.username, user.password);
if (model?.user == null)
{
return(Response.AsJson(new JsonResponseModel {
Result = false, Message = "Incorrect username or password!"
}));
}
// Set the auth token in the session so we can use it in the next form
Session[SessionKeys.UserWizardPlexAuth] = model.user.authentication_token;
var servers = PlexApi.GetServer(model.user.authentication_token);
var firstServer = servers.Server.FirstOrDefault();
return(Response.AsJson(new { Result = true, firstServer?.Port, Ip = firstServer?.LocalAddresses, firstServer?.Scheme }));
}
private async Task <Response> SavePlex()
{
var plexSettings = this.Bind <PlexSettings>();
var valid = this.Validate(plexSettings);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
//Lookup identifier
var server = PlexApi.GetServer(plexSettings.PlexAuthToken);
plexSettings.MachineIdentifier = server.Server.FirstOrDefault(x => x.AccessToken == plexSettings.PlexAuthToken)?.MachineIdentifier;
var result = await PlexService.SaveSettingsAsync(plexSettings);
return(Response.AsJson(result
? new JsonResponseModel {
Result = true, Message = "Successfully Updated the Settings for Plex!"
}
: new JsonResponseModel {
Result = false, Message = "Could not update the settings, take a look at the logs."
}));
}
public async Task NotifyUsers(IEnumerable <RequestedModel> modelChanged, string apiKey, NotificationType type)
{
try
{
var plexUser = PlexApi.GetUsers(apiKey);
var userAccount = PlexApi.GetAccount(apiKey);
var adminUsername = userAccount.Username ?? string.Empty;
var users = UserHelper.GetUsersWithFeature(Features.RequestAddedNotification).ToList();
Log.Debug("Notifying Users Count {0}", users.Count);
foreach (var model in modelChanged)
{
var selectedUsers = new List <string>();
foreach (var u in users)
{
var requestUser = model.RequestedUsers.FirstOrDefault(
x => x.Equals(u.Username, StringComparison.CurrentCultureIgnoreCase) || x.Equals(u.UserAlias, StringComparison.CurrentCultureIgnoreCase));
if (string.IsNullOrEmpty(requestUser))
{
continue;
}
selectedUsers.Add(requestUser);
}
//var selectedUsers = users.Select(x => x.Username).Intersect(model.RequestedUsers, StringComparer.CurrentCultureIgnoreCase);
foreach (var user in selectedUsers)
{
Log.Info("Notifying user {0}", user);
if (user.Equals(adminUsername, StringComparison.CurrentCultureIgnoreCase))
{
Log.Info("This user is the Plex server owner");
await PublishUserNotification(userAccount.Username, userAccount.Email, model.Title, model.PosterPath, type);
return;
}
var email = plexUser.User.FirstOrDefault(x => x.Username.Equals(user, StringComparison.CurrentCultureIgnoreCase));
if (string.IsNullOrEmpty(email?.Email))
{
Log.Info("There is no email address for this Plex user, cannot send notification");
// We do not have a plex user that requested this!
continue;
}
Log.Info("Sending notification to: {0} at: {1}, for title: {2}", email.Username, email.Email, model.Title);
await PublishUserNotification(email.Username, email.Email, model.Title, model.PosterPath, type);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
}
public async Task <PlexAuthentication> SignIn([FromBody] UserRequest request)
{
try
{
// Do we already have settings?
_log.LogDebug("OK, signing into Plex");
var settings = await PlexSettings.GetSettingsAsync();
if (!settings.Servers?.Any() ?? false)
{
return(null);
}
_log.LogDebug("This is our first time, good to go!");
var result = await PlexApi.SignIn(request);
_log.LogDebug("Attempting to sign in to Plex.Tv");
if (!string.IsNullOrEmpty(result.user?.authentication_token))
{
_log.LogDebug("Sign in successful");
_log.LogDebug("Getting servers");
var server = await PlexApi.GetServer(result.user.authentication_token);
var servers = server.Server.FirstOrDefault();
if (servers == null)
{
_log.LogWarning("Looks like we can't find any Plex Servers");
}
_log.LogDebug("Adding first server");
settings.Enable = true;
settings.Servers = new List <PlexServers> {
new PlexServers
{
PlexAuthToken = result.user.authentication_token,
Id = new Random().Next(),
Ip = servers?.LocalAddresses?.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries)?.FirstOrDefault() ?? string.Empty,
MachineIdentifier = servers?.MachineIdentifier ?? string.Empty,
Port = int.Parse(servers?.Port ?? "0"),
Ssl = (servers?.Scheme ?? "http") != "http",
Name = "Server 1",
}
};
await PlexSettings.SaveSettingsAsync(settings);
}
_log.LogDebug("Finished");
return(result);
}
catch (Exception e)
{
_log.LogCritical(e, "Error when trying to sign into Plex.tv");
throw;
}
}
private bool CheckIfUserIsOwner(string authToken, string userName)
{
var userAccount = PlexApi.GetAccount(authToken);
if (userAccount == null)
{
return(false);
}
return(userAccount.Username != null && userAccount.Username.Equals(userName, StringComparison.CurrentCultureIgnoreCase));
}
private string GetOwnerId(string authToken, string userName)
{
var userAccount = PlexApi.GetAccount(authToken);
if (userAccount == null)
{
return(string.Empty);
}
return(userAccount.Id);
}
private async Task <Response> LoadUsers()
{
var localUsers = await UserMapper.GetUsersAsync();
var plexDbUsers = await PlexUsersRepository.GetAllAsync();
var model = new List <UserManagementUsersViewModel>();
var userLogins = UserLoginsRepo.GetAll().ToList();
foreach (var user in localUsers)
{
var userDb = userLogins.FirstOrDefault(x => x.UserId == user.UserGuid);
model.Add(MapLocalUser(user, userDb?.LastLoggedIn ?? DateTime.MinValue));
}
var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{
//Get Plex Users
var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
if (plexUsers != null && plexUsers.User != null)
{
foreach (var u in plexUsers.User)
{
var dbUser = plexDbUsers.FirstOrDefault(x => x.PlexUserId == u.Id);
var userDb = userLogins.FirstOrDefault(x => x.UserId == u.Id);
// We don't have the user in the database yet
if (dbUser == null)
{
model.Add(MapPlexUser(u, null, userDb?.LastLoggedIn ?? DateTime.MinValue));
}
else
{
// The Plex User is in the database
model.Add(MapPlexUser(u, dbUser, userDb?.LastLoggedIn ?? DateTime.MinValue));
}
}
}
// Also get the server admin
var account = PlexApi.GetAccount(plexSettings.PlexAuthToken);
if (account != null)
{
var dbUser = plexDbUsers.FirstOrDefault(x => x.PlexUserId == account.Id);
var userDb = userLogins.FirstOrDefault(x => x.UserId == account.Id);
model.Add(MapPlexAdmin(account, dbUser, userDb?.LastLoggedIn ?? DateTime.MinValue));
}
}
return(Response.AsJson(model));
}
public async Task <bool> Plex([FromBody] PlexServers settings)
{
try
{
var result = await PlexApi.GetStatus(settings.PlexAuthToken, settings.FullUri);
return(result?.MediaContainer?.version != null);
}
catch (Exception e)
{
Log.LogError(LoggingEvents.Api, e, "Could not test Plex");
return(false);
}
}
/// <summary>
/// Gets all the library sections.
/// If the user has specified only certain libraries then we will only look for those
/// If they have not set the settings then we will monitor them all
/// </summary>
/// <param name="plexSettings">The plex settings.</param>
/// <param name="recentlyAddedSearch"></param>
/// <returns></returns>
private async Task <List <Mediacontainer> > GetAllContent(PlexServers plexSettings, bool recentlyAddedSearch)
{
var sections = await PlexApi.GetLibrarySections(plexSettings.PlexAuthToken, plexSettings.FullUri);
var libs = new List <Mediacontainer>();
if (sections != null)
{
foreach (var dir in sections.MediaContainer.Directory ?? new List <Directory>())
{
if (plexSettings.PlexSelectedLibraries.Any())
{
if (plexSettings.PlexSelectedLibraries.Any(x => x.Enabled))
{
// Only get the enabled libs
var keys = plexSettings.PlexSelectedLibraries.Where(x => x.Enabled)
.Select(x => x.Key.ToString()).ToList();
if (!keys.Contains(dir.key))
{
Logger.LogDebug("Lib {0} is not monitored, so skipping", dir.key);
// We are not monitoring this lib
continue;
}
}
}
if (recentlyAddedSearch)
{
var container = await PlexApi.GetRecentlyAdded(plexSettings.PlexAuthToken, plexSettings.FullUri,
dir.key);
if (container != null)
{
libs.Add(container.MediaContainer);
}
}
else
{
var lib = await PlexApi.GetLibrary(plexSettings.PlexAuthToken, plexSettings.FullUri, dir.key);
if (lib != null)
{
libs.Add(lib.MediaContainer);
}
}
}
}
return(libs);
}
private async Task<Response> LoadUsers()
{
var localUsers = await UserMapper.GetUsersAsync();
var model = new List<UserManagementUsersViewModel>();
foreach (var user in localUsers)
{
var claims = ByteConverterHelper.ReturnObject<string[]>(user.Claims);
var claimsString = string.Join(", ", claims);
var userProps = ByteConverterHelper.ReturnObject<UserProperties>(user.UserProperties);
model.Add(new UserManagementUsersViewModel
{
Id = user.UserGuid,
Claims = claimsString,
Username = user.UserName,
Type = UserType.LocalUser,
EmailAddress = userProps.EmailAddress,
ClaimsArray = claims
});
}
var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{
//Get Plex Users
var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
foreach (var u in plexUsers.User)
{
model.Add(new UserManagementUsersViewModel
{
Username = u.Username,
Type = UserType.PlexUser,
Id = u.Id,
Claims = "Requestor",
EmailAddress = u.Email,
PlexInfo = new UserManagementPlexInformation
{
Thumb = u.Thumb
}
});
}
}
return Response.AsJson(model);
}
public async Task CheckPassword_PlexUser_UserNameLogin_InvalidPassword()
{
var user = new OmbiUser
{
UserType = UserType.PlexUser,
EmailLogin = false,
Email = "*****@*****.**",
UserName = "******"
};
PlexApi.Setup(x => x.SignIn(It.IsAny <UserRequest>()))
.ReturnsAsync(new PlexAuthentication());
var result = await _um.CheckPasswordAsync(user, "pass");
Assert.That(result, Is.False);
PlexApi.Verify(x => x.SignIn(It.Is <UserRequest>(c => c.login == "heyhey")), Times.Once);
}
private async Task <Response> PlexDetails(string id)
{
var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{
//Get Plex Users
var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
var selectedUser = plexUsers.User?.FirstOrDefault(x => x.Id.ToString() == id);
if (selectedUser != null)
{
return(Response.AsJson(selectedUser));
}
}
return(Nancy.Response.NoBody);
}
private async Task <Response> CheckStatus()
{
var plexSettings = await PlexSettings.GetSettingsAsync();
if (string.IsNullOrEmpty(plexSettings.PlexAuthToken) || string.IsNullOrEmpty(plexSettings.Ip))
{
return(Response.AsJson(false));
}
try
{
var status = PlexApi.GetStatus(plexSettings.PlexAuthToken, plexSettings.FullUri);
return(Response.AsJson(status != null));
}
catch (Exception)
{
return(Response.AsJson(false));
}
}
private void NotifyUsers(IEnumerable <RequestedModel> modelChanged, string apiKey)
{
try
{
var plexUser = PlexApi.GetUsers(apiKey);
var userAccount = PlexApi.GetAccount(apiKey);
var adminUsername = userAccount.Username ?? string.Empty;
var users = UserNotifyRepo.GetAll().ToList();
Log.Debug("Notifying Users Count {0}", users.Count);
foreach (var model in modelChanged)
{
var selectedUsers = users.Select(x => x.Username).Intersect(model.RequestedUsers);
Log.Debug("Selected Users {0}", selectedUsers.DumpJson());
foreach (var user in selectedUsers)
{
Log.Info("Notifying user {0}", user);
if (user == adminUsername)
{
Log.Info("This user is the Plex server owner");
PublishUserNotification(userAccount.Username, userAccount.Email, model.Title);
return;
}
var email = plexUser.User.FirstOrDefault(x => x.Username == user);
if (email == null)
{
Log.Info("There is no email address for this Plex user, cannot send notification");
// We do not have a plex user that requested this!
continue;
}
Log.Info("Sending notification to: {0} at: {1}, for title: {2}", email.Username, email.Email, model.Title);
PublishUserNotification(email.Username, email.Email, model.Title);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
}
private async Task <Response> Plex()
{
var form = this.Bind <PlexSettings>();
var valid = this.Validate(form);
if (!valid.IsValid)
{
return(Response.AsJson(valid.SendJsonError()));
}
form.PlexAuthToken = Session[SessionKeys.UserWizardPlexAuth].ToString();
// Set the auth token from the previous form
// Get the machine ID from the settings (This could have changed)
try
{
var servers = PlexApi.GetServer(form.PlexAuthToken);
var firstServer = servers.Server.FirstOrDefault(x => x.AccessToken == form.PlexAuthToken);
Session[SessionKeys.UserWizardMachineId] = firstServer?.MachineIdentifier;
form.MachineIdentifier = firstServer?.MachineIdentifier;
}
catch (Exception e)
{
// Probably bad settings, just continue
Log.Error(e);
}
var result = await PlexSettings.SaveSettingsAsync(form);
if (result)
{
return(Response.AsJson(new JsonResponseModel {
Result = true
}));
}
return
(Response.AsJson(new JsonResponseModel
{
Result = false,
Message = "Could not save the settings to the database, please try again."
}));
}
private List <PlexSearch> GetLibraries(PlexSettings plexSettings)
{
var sections = PlexApi.GetLibrarySections(plexSettings.PlexAuthToken, plexSettings.FullUri);
var libs = new List <PlexSearch>();
if (sections != null)
{
foreach (var dir in sections.Directories ?? new List <Directory>())
{
var lib = PlexApi.GetLibrary(plexSettings.PlexAuthToken, plexSettings.FullUri, dir.Key);
if (lib != null)
{
libs.Add(lib);
}
}
}
return(libs);
}
private async Task <Response> LoadUsers()
{
var localUsers = await UserMapper.GetUsersAsync();
var model = new List <UserManagementUsersViewModel>();
var usersDb = UserLoginsRepo.GetAll().ToList();
foreach (var user in localUsers)
{
var userDb = usersDb.FirstOrDefault(x => x.UserId == user.UserGuid);
model.Add(MapLocalUser(user, userDb?.LastLoggedIn ?? DateTime.MinValue));
}
var plexSettings = await PlexSettings.GetSettingsAsync();
if (!string.IsNullOrEmpty(plexSettings.PlexAuthToken))
{
//Get Plex Users
var plexUsers = PlexApi.GetUsers(plexSettings.PlexAuthToken);
foreach (var u in plexUsers.User)
{
var userDb = usersDb.FirstOrDefault(x => x.UserId == u.Id);
model.Add(new UserManagementUsersViewModel
{
Username = u.Username,
Type = UserType.PlexUser,
Id = u.Id,
Claims = "Requestor",
EmailAddress = u.Email,
PlexInfo = new UserManagementPlexInformation
{
Thumb = u.Thumb
},
LastLoggedIn = userDb?.LastLoggedIn ?? DateTime.MinValue,
});
}
}
return(Response.AsJson(model));
}
private async Task <Response> CheckStatus()
{
var plexSettings = await PlexSettings.GetSettingsAsync();
if (plexSettings.Enable)
{
if (string.IsNullOrEmpty(plexSettings.PlexAuthToken) || string.IsNullOrEmpty(plexSettings.Ip))
{
return(Response.AsJson(false));
}
try
{
var status = PlexApi.GetStatus(plexSettings.PlexAuthToken, plexSettings.FullUri);
return(Response.AsJson(status != null));
}
catch (Exception)
{
return(Response.AsJson(false));
}
}
var emby = await EmbySettings.GetSettingsAsync();
if (emby.Enable)
{
if (string.IsNullOrEmpty(emby.AdministratorId) || string.IsNullOrEmpty(emby.Ip))
{
return(Response.AsJson(false));
}
try
{
var status = EmbyApi.GetSystemInformation(emby.ApiKey, emby.FullUri);
return(Response.AsJson(status?.Version != null));
}
catch (Exception)
{
return(Response.AsJson(false));
}
}
return(Response.AsJson(false));
}
public async Task NotifyUsers(RequestedModel model, string apiKey)
{
try
{
var plexUser = PlexApi.GetUsers(apiKey);
var userAccount = PlexApi.GetAccount(apiKey);
var adminUsername = userAccount.Username ?? string.Empty;
var users = UserNotifyRepo.GetAll().ToList();
Log.Debug("Notifying Users Count {0}", users.Count);
var selectedUsers = users.Select(x => x.Username).Intersect(model.RequestedUsers, StringComparer.CurrentCultureIgnoreCase);
foreach (var user in selectedUsers)
{
Log.Info("Notifying user {0}", user);
if (user.Equals(adminUsername, StringComparison.CurrentCultureIgnoreCase))
{
Log.Info("This user is the Plex server owner");
await PublishUserNotification(userAccount.Username, userAccount.Email, model.Title, model.PosterPath);
return;
}
var email = plexUser.User.FirstOrDefault(x => x.Username.Equals(user, StringComparison.CurrentCultureIgnoreCase));
if (email == null)
{
Log.Info("There is no email address for this Plex user, cannot send notification");
// We do not have a plex user that requested this!
continue;
}
Log.Info("Sending notification to: {0} at: {1}, for title: {2}", email.Username, email.Email, model.Title);
await PublishUserNotification(email.Username, email.Email, model.Title, model.PosterPath);
}
}
catch (Exception e)
{
Log.Error(e);
}
}
public async Task <PlexServersViewModel> GetServers([FromBody] UserRequest u)
{
try
{
var signIn = await PlexApi.SignIn(u);
var servers = await PlexApi.GetServer(signIn?.user?.authentication_token);
return(new PlexServersViewModel {
Servers = servers, Success = true
});
}
catch (Exception e)
{
return(new PlexServersViewModel
{
Success = false,
Message = e.Message
});
}
}
/// <summary>
/// Migrates to version1910.
/// </summary>
public void MigrateToVersion1910()
{
try
{
// Get the new machine Identifier
var settings = new SettingsServiceV2 <PlexSettings>(new SettingsJsonRepository(Db, new MemoryCacheProvider()));
var plex = settings.GetSettings();
if (!string.IsNullOrEmpty(plex.PlexAuthToken))
{
var api = new PlexApi(new ApiRequest());
var server = api.GetServer(plex.PlexAuthToken); // Get the server info
plex.MachineIdentifier = server.Server.FirstOrDefault(x => x.AccessToken == plex.PlexAuthToken)?.MachineIdentifier;
settings.SaveSettings(plex); // Save the new settings
}
}
catch (Exception e)
{
Log.Error(e);
}
}
private List<PlexSearch> GetLibraries(AuthenticationSettings authSettings, PlexSettings plexSettings)
{
var sections = PlexApi.GetLibrarySections(authSettings.PlexAuthToken, plexSettings.FullUri);
List<PlexSearch> libs = new List<PlexSearch>();
if (sections != null)
{
foreach (var dir in sections.Directories)
{
Log.Trace("Obtaining results from Plex for the following library section: {0}", dir.Title);
var lib = PlexApi.GetLibrary(authSettings.PlexAuthToken, plexSettings.FullUri, dir.Key);
if (lib != null)
{
libs.Add(lib);
}
}
}
Log.Trace("Returning Plex Libs");
return libs;
}
private void NotifyUsers(IEnumerable<RequestedModel> modelChanged, string apiKey)
{
try
{
var plexUser = PlexApi.GetUsers(apiKey);
if (plexUser?.User == null || plexUser.User.Length == 0)
{
return;
}
var users = UserNotifyRepo.GetAll().ToList();
foreach (var model in modelChanged)
{
var selectedUsers = users.Select(x => x.Username).Intersect(model.RequestedUsers);
foreach (var user in selectedUsers)
{
var email = plexUser.User.FirstOrDefault(x => x.Username == user);
if (email == null)
{
// We do not have a plex user that requested this!
continue;
}
var notificationModel = new NotificationModel
{
User = email.Username,
UserEmail = email.Email,
NotificationType = NotificationType.RequestAvailable,
Title = model.Title
};
// Send the notification to the user.
Notification.Publish(notificationModel);
}
}
}
catch (Exception e)
{
Log.Error(e);
}
}
