private async Task <UserViewModel> GetUserWithRoles(OmbiUser user)
{
var userRoles = await UserManager.GetRolesAsync(user);
var vm = new UserViewModel
{
Alias = user.Alias,
UserName = user.UserName,
Id = user.Id,
EmailAddress = user.Email,
UserType = (Core.Models.UserType)(int) user.UserType,
Claims = new List <ClaimCheckboxes>(),
LastLoggedIn = user.LastLoggedIn,
HasLoggedIn = user.LastLoggedIn.HasValue,
EpisodeRequestLimit = user.EpisodeRequestLimit ?? 0,
MovieRequestLimit = user.MovieRequestLimit ?? 0,
MusicRequestLimit = user.MusicRequestLimit ?? 0,
};
foreach (var role in userRoles)
{
vm.Claims.Add(new ClaimCheckboxes
{
Value = role,
Enabled = true
});
}
// Add the missing claims
var allRoles = await RoleManager.Roles.ToListAsync();
var missing = allRoles.Select(x => x.Name).Except(userRoles);
foreach (var role in missing)
{
vm.Claims.Add(new ClaimCheckboxes
{
Value = role,
Enabled = false
});
}
if (vm.EpisodeRequestLimit > 0)
{
vm.EpisodeRequestQuota = await TvRequestEngine.GetRemainingRequests(user);
}
if (vm.MovieRequestLimit > 0)
{
vm.MovieRequestQuota = await MovieRequestEngine.GetRemainingRequests(user);
}
if (vm.MusicRequestLimit > 0)
{
vm.MusicRequestQuota = await MusicRequestEngine.GetRemainingRequests(user);
}
// Get the quality profiles
vm.UserQualityProfiles = await _userQualityProfiles.GetAll().FirstOrDefaultAsync(x => x.UserId == user.Id);
if (vm.UserQualityProfiles == null)
{
vm.UserQualityProfiles = new UserQualityProfiles
{
UserId = user.Id
};
}
return(vm);
}
public async Task <OmbiIdentityResult> CreateUser([FromBody] UserViewModel user)
{
if (!EmailValidator.IsValidEmail(user.EmailAddress))
{
return(Error($"The email address {user.EmailAddress} is not a valid format"));
}
if (!CanModifyUser(user.Claims.Select(x => x.Value)))
{
return(Error("You do not have the correct permissions to create this user"));
}
var ombiUser = new OmbiUser
{
Alias = user.Alias,
Email = user.EmailAddress,
UserName = user.UserName,
UserType = UserType.LocalUser,
MovieRequestLimit = user.MovieRequestLimit,
EpisodeRequestLimit = user.EpisodeRequestLimit,
MusicRequestLimit = user.MusicRequestLimit,
UserAccessToken = Guid.NewGuid().ToString("N"),
};
var userResult = await UserManager.CreateAsync(ombiUser, user.Password);
if (!userResult.Succeeded)
{
// We did not create the user
return(new OmbiIdentityResult
{
Errors = userResult.Errors.Select(x => x.Description).ToList()
});
}
var roleResult = await AddRoles(user.Claims, ombiUser);
if (roleResult.Any(x => !x.Succeeded))
{
var messages = new List <string>();
foreach (var errors in roleResult.Where(x => !x.Succeeded))
{
messages.AddRange(errors.Errors.Select(x => x.Description).ToList());
}
return(new OmbiIdentityResult
{
Errors = messages
});
}
// Add the quality profiles
if (user.UserQualityProfiles != null)
{
user.UserQualityProfiles.UserId = ombiUser.Id;
await _userQualityProfiles.Add(user.UserQualityProfiles);
}
else
{
user.UserQualityProfiles = new UserQualityProfiles
{
UserId = ombiUser.Id
};
}
return(new OmbiIdentityResult
{
Successful = true
});
}
private async Task <List <IdentityResult> > AddRoles(IEnumerable <ClaimCheckboxes> roles, OmbiUser ombiUser)
{
var roleResult = new List <IdentityResult>();
foreach (var role in roles)
{
if (role.Enabled)
{
roleResult.Add(await UserManager.AddToRoleAsync(ombiUser, role.Value));
}
}
return(roleResult);
}
private async Task <SaveWizardResult> SaveWizardUser(CreateUserWizardModel user, OmbiUser userToCreate)
{
IdentityResult result;
var retVal = new SaveWizardResult();
// When creating the admin as the plex user, we do not pass in the password.
if (user.Password.HasValue())
{
result = await UserManager.CreateAsync(userToCreate, user.Password);
}
else
{
result = await UserManager.CreateAsync(userToCreate);
}
if (result.Succeeded)
{
_log.LogInformation("Created User {0}", userToCreate.UserName);
await CreateRoles();
_log.LogInformation("Created the roles");
var roleResult = await UserManager.AddToRoleAsync(userToCreate, OmbiRoles.Admin);
if (!roleResult.Succeeded)
{
LogErrors(roleResult);
}
else
{
_log.LogInformation("Added the Admin role");
}
}
if (!result.Succeeded)
{
LogErrors(result);
retVal.Errors.AddRange(result.Errors.Select(x => x.Description));
}
// Update the wizard flag
var settings = await OmbiSettings.GetSettingsAsync();
settings.Wizard = true;
await OmbiSettings.SaveSettingsAsync(settings);
retVal.Result = result.Succeeded;
return(retVal);
}
protected async Task <OmbiUser> GetUser()
{
return(_user ?? (_user = await UserManager.Users.FirstOrDefaultAsync(x => x.UserName == Username)));
}
public async Task Start()
{
var userManagementSettings = await _userManagementSettings.GetSettingsAsync();
if (!userManagementSettings.ImportPlexUsers)
{
return;
}
var settings = await _plexSettings.GetSettingsAsync();
if (!settings.Enable)
{
return;
}
var allUsers = await _userManager.Users.Where(x => x.UserType == UserType.PlexUser).ToListAsync();
foreach (var server in settings.Servers)
{
if (string.IsNullOrEmpty(server.PlexAuthToken))
{
continue;
}
await ImportAdmin(userManagementSettings, server, allUsers);
var users = await _api.GetUsers(server.PlexAuthToken);
foreach (var plexUser in users.User)
{
// Check if we should import this user
if (userManagementSettings.BannedPlexUserIds.Contains(plexUser.Id))
{
// Do not import these, they are not allowed into the country.
continue;
}
// Check if this Plex User already exists
// We are using the Plex USERNAME and Not the TITLE, the Title is for HOME USERS
var existingPlexUser = allUsers.FirstOrDefault(x => x.ProviderUserId == plexUser.Id);
if (existingPlexUser == null)
{
if (!plexUser.Username.HasValue())
{
_log.LogInformation("Could not create Plex user since the have no username, PlexUserId: {0}", plexUser.Id);
continue;
}
// Create this users
// We do not store a password against the user since they will authenticate via Plex
var newUser = new OmbiUser
{
UserType = UserType.PlexUser,
UserName = plexUser?.Username ?? plexUser.Id,
ProviderUserId = plexUser.Id,
Email = plexUser?.Email ?? string.Empty,
Alias = string.Empty,
MovieRequestLimit = userManagementSettings.MovieRequestLimit,
EpisodeRequestLimit = userManagementSettings.EpisodeRequestLimit
};
_log.LogInformation("Creating Plex user {0}", newUser.UserName);
var result = await _userManager.CreateAsync(newUser);
if (!LogResult(result))
{
continue;
}
if (userManagementSettings.DefaultRoles.Any())
{
// Get the new user object to avoid any concurrency failures
var dbUser =
await _userManager.Users.FirstOrDefaultAsync(x => x.UserName == newUser.UserName);
foreach (var defaultRole in userManagementSettings.DefaultRoles)
{
await _userManager.AddToRoleAsync(dbUser, defaultRole);
}
}
}
else
{
// Do we need to update this user?
existingPlexUser.Email = plexUser.Email;
existingPlexUser.UserName = plexUser.Username;
await _userManager.UpdateAsync(existingPlexUser);
}
}
}
}
protected async Task <OmbiUser> GetUser()
{
return(_user ?? (_user = await UserManager.Users.FirstOrDefaultAsync(x => x.UserName.Equals(Username, StringComparison.CurrentCultureIgnoreCase))));
}
private NotificationMessageContent ParseTemplate(NotificationTemplates template, CustomizationSettings settings, OmbiUser username)
{
var resolver = new NotificationMessageResolver();
var curlys = new NotificationMessageCurlys();
curlys.SetupNewsletter(settings, username);
return(resolver.ParseMessage(template, curlys));
}
public async Task <RequestQuotaCountModel> GetRemainingTvRequests(OmbiUser user, DateTime now = default)
{
if (now == default)
{
now = DateTime.UtcNow;
}
if (user == null)
{
user = await GetUser();
// If user is still null after attempting to get the logged in user, return null.
if (user == null)
{
return(null);
}
}
int limit = user.EpisodeRequestLimit ?? 0;
if (limit <= 0)
{
return(new RequestQuotaCountModel()
{
HasLimit = false,
Limit = 0,
Remaining = 0,
NextRequest = DateTime.Now,
});
}
IQueryable <RequestLog> log = _requestLog.GetAll().Where(x => x.UserId == user.Id && x.RequestType == RequestType.TvShow);
int count = 0;
DateTime oldestRequestedAt = DateTime.Now;
DateTime nextRequest = DateTime.Now;
IQueryable <RequestLog> filteredLog;
int zeroEpisodeCount;
int episodeCount;
if (!user.EpisodeRequestLimitType.HasValue)
{
filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.AddDays(-7));
// Needed, due to a bug which would cause all episode counts to be 0
zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
count = limit - (zeroEpisodeCount + episodeCount);
oldestRequestedAt = await log
.Where(x => x.RequestDate >= now.AddDays(-7))
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
return(new RequestQuotaCountModel()
{
HasLimit = true,
Limit = limit,
Remaining = count < 0 ? 0 : count,
NextRequest = DateTime.SpecifyKind(oldestRequestedAt.AddDays(7), DateTimeKind.Utc).Date,
});
}
switch (user.EpisodeRequestLimitType)
{
case RequestLimitType.Day:
filteredLog = log.Where(x => x.RequestDate >= DateTime.UtcNow.Date);
// Needed, due to a bug which would cause all episode counts to be 0
zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
count = limit - (zeroEpisodeCount + episodeCount);
oldestRequestedAt = await log.Where(x => x.RequestDate >= now.Date)
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = oldestRequestedAt.AddDays(1).Date;
break;
case RequestLimitType.Week:
var fdow = now.FirstDateInWeek().Date;
filteredLog = log.Where(x => x.RequestDate >= now.Date.AddDays(-7));
// Needed, due to a bug which would cause all episode counts to be 0
zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
count = limit - (zeroEpisodeCount + episodeCount);
oldestRequestedAt = await log.Where(x => x.RequestDate >= now.Date.AddDays(-7))
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = fdow.AddDays(7).Date;
break;
case RequestLimitType.Month:
var firstDayOfMonth = new DateTime(now.Year, now.Month, 1);
filteredLog = log.Where(x => x.RequestDate >= now.Date.AddMonths(-1));
// Needed, due to a bug which would cause all episode counts to be 0
zeroEpisodeCount = await filteredLog.Where(x => x.EpisodeCount == 0).Select(x => x.EpisodeCount).CountAsync();
episodeCount = await filteredLog.Where(x => x.EpisodeCount != 0).Select(x => x.EpisodeCount).SumAsync();
count = limit - (zeroEpisodeCount + episodeCount);
oldestRequestedAt = await log.Where(x => x.RequestDate >= now.Date.AddMonths(-1))
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = firstDayOfMonth.AddMonths(1).Date;
break;
}
return(new RequestQuotaCountModel()
{
HasLimit = true,
Limit = limit,
Remaining = count < 0 ? 0 : count,
NextRequest = DateTime.SpecifyKind(nextRequest, DateTimeKind.Utc),
});
}
public async Task UserPassedIn_MovieLimit_Set_Limit_MultipleRequests()
{
var user = new OmbiUser
{
NormalizedUserName = "******",
MovieRequestLimit = 2,
Id = "id1"
};
var yesterday = new DateTime(2020, 09, 05).AddDays(-1);
var log = new List <RequestLog>
{
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday,
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-2),
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-3), // Yesterday
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-4), // Yesterday
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-5), // Yesterday
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-6), // Yesterday
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-7), // Yesterday
},
new RequestLog
{
UserId = "id1",
RequestType = RequestType.Movie,
RequestDate = yesterday.AddDays(-8), // Yesterday
},
};
var repoMock = _mocker.GetMock <IRepository <RequestLog> >();
repoMock.Setup(x => x.GetAll()).Returns(log.AsQueryable().BuildMock().Object);
var result = await _subject.GetRemainingMovieRequests(user);
Assert.That(result, Is.InstanceOf <RequestQuotaCountModel>()
.With.Property(nameof(RequestQuotaCountModel.HasLimit)).EqualTo(true)
.And.Property(nameof(RequestQuotaCountModel.Limit)).EqualTo(2)
.And.Property(nameof(RequestQuotaCountModel.Remaining)).EqualTo(0)
.And.Property(nameof(RequestQuotaCountModel.NextRequest)).EqualTo(yesterday.AddDays(1))
);
}
private static async Task <RequestQuotaCountModel> CalculateBasicRemaingRequests(OmbiUser user, int limit, RequestLimitType type, IQueryable <RequestLog> log, DateTime now)
{
int count = 0;
DateTime oldestRequestedAt = DateTime.Now;
DateTime nextRequest = DateTime.Now;
switch (type)
{
case RequestLimitType.Day:
count = limit - await log.CountAsync(x => x.RequestDate >= now.Date);
oldestRequestedAt = await log.Where(x => x.RequestDate >= now.Date)
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = oldestRequestedAt.AddDays(1).Date;
break;
case RequestLimitType.Week:
var fdow = now.FirstDateInWeek().Date;
count = limit - await log.CountAsync(x => x.RequestDate >= fdow);
oldestRequestedAt = await log.Where(x => x.RequestDate >= fdow)
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = fdow.AddDays(7).Date;
break;
case RequestLimitType.Month:
var firstDayOfMonth = new DateTime(now.Year, now.Month, 1);
count = limit - await log.CountAsync(x => x.RequestDate >= firstDayOfMonth);
oldestRequestedAt = await log.Where(x => x.RequestDate >= firstDayOfMonth)
.OrderBy(x => x.RequestDate)
.Select(x => x.RequestDate)
.FirstOrDefaultAsync();
nextRequest = firstDayOfMonth.AddMonths(1).Date;
break;
}
return(new RequestQuotaCountModel()
{
HasLimit = true,
Limit = limit,
Remaining = count < 0 ? 0 : count,
NextRequest = DateTime.SpecifyKind(nextRequest, DateTimeKind.Utc),
});
}
public void SetUser(OmbiUser user)
{
_user = user;
}
public async Task <IdentityResult> DeleteUser(OmbiUser userToDelete)
{
var userId = userToDelete.Id;
// We need to delete all the requests first
var moviesUserRequested = _movieRepository.GetAll().Where(x => x.RequestedUserId == userId);
var tvUserRequested = _tvRepository.GetChild().Where(x => x.RequestedUserId == userId);
var musicRequested = _musicRepository.GetAll().Where(x => x.RequestedUserId == userId);
var notificationPreferences = _userNotificationPreferences.GetAll().Where(x => x.UserId == userId);
var userQuality = await _userQualityProfiles.GetAll().FirstOrDefaultAsync(x => x.UserId == userId);
if (moviesUserRequested.Any())
{
await _movieRepository.DeleteRange(moviesUserRequested);
}
if (tvUserRequested.Any())
{
await _tvRepository.DeleteChildRange(tvUserRequested);
}
if (musicRequested.Any())
{
await _musicRepository.DeleteRange(musicRequested);
}
if (notificationPreferences.Any())
{
await _userNotificationPreferences.DeleteRange(notificationPreferences);
}
if (userQuality != null)
{
await _userQualityProfiles.Delete(userQuality);
}
// Delete any issues and request logs
var issues = _issuesRepository.GetAll().Where(x => x.UserReportedId == userId);
var issueComments = _issueCommentsRepository.GetAll().Where(x => x.UserId == userId);
var requestLog = _requestLogRepository.GetAll().Where(x => x.UserId == userId);
if (issueComments.Any())
{
await _issueCommentsRepository.DeleteRange(issueComments);
}
if (issues.Any())
{
var extraComments = new List <IssueComments>();
var issueIds = issues.Select(x => x.Id).Distinct();
foreach (var issue in issueIds)
{
// Get all the comments for this issue and delete them, since the issue will be deleted
var extra = _issueCommentsRepository.GetAll().Where(x => x.IssuesId == issue);
extraComments.AddRange(extra.ToList());
}
await _issuesRepository.DeleteRange(issues);
}
if (requestLog.Any())
{
await _requestLogRepository.DeleteRange(requestLog);
}
// Delete the Subscriptions and mobile notification ids
var subs = _requestSubscriptionRepository.GetAll().Where(x => x.UserId == userId);
var mobileIds = _notificationRepository.GetAll().Where(x => x.UserId == userId);
var votes = _voteRepository.GetAll().Where(x => x.UserId == userId);
var newMobiles = _mobileDevicesRepository.GetAll().Where(x => x.UserId == userId);
if (subs.Any())
{
await _requestSubscriptionRepository.DeleteRange(subs);
}
if (mobileIds.Any())
{
await _notificationRepository.DeleteRange(mobileIds);
}
if (votes.Any())
{
await _voteRepository.DeleteRange(votes);
}
if (newMobiles.Any())
{
await _mobileDevicesRepository.DeleteRange(newMobiles);
}
var result = await _userManager.DeleteAsync(userToDelete);
return(result);
}
/// <summary> /// Only used for background tasks /// </summary> public void SetUser(OmbiUser user) => CurrentUser.SetUser(user);
public async Task Execute(IJobExecutionContext job)
{
var userManagementSettings = await _userManagementSettings.GetSettingsAsync();
if (!userManagementSettings.ImportJellyfinUsers)
{
return;
}
var settings = await _jellyfinSettings.GetSettingsAsync();
if (!settings.Enable)
{
return;
}
Api = _apiFactory.CreateClient(settings);
await _notification.Clients.Clients(NotificationHub.AdminConnectionIds)
.SendAsync(NotificationHub.NotificationEvent, $"Jellyfin User Importer Started");
var allUsers = await _userManager.Users.Where(x => x.UserType == UserType.JellyfinUser).ToListAsync();
foreach (var server in settings.Servers)
{
if (string.IsNullOrEmpty(server.ApiKey))
{
continue;
}
var jellyfinUsers = await Api.GetUsers(server.FullUri, server.ApiKey);
foreach (var jellyfinUser in jellyfinUsers)
{
// Check if we should import this user
if (userManagementSettings.BannedJellyfinUserIds.Contains(jellyfinUser.Id))
{
// Do not import these, they are not allowed into the country.
continue;
}
// Check if this Jellyfin User already exists
var existingJellyfinUser = allUsers.FirstOrDefault(x => x.ProviderUserId == jellyfinUser.Id);
if (existingJellyfinUser == null)
{
if (!jellyfinUser.Name.HasValue())
{
_log.LogInformation("Could not create Jellyfin user since the have no username, JellyfinUserId: {0}", jellyfinUser.Id);
continue;
}
// Create this users
var newUser = new OmbiUser
{
UserName = jellyfinUser.Name,
UserType = UserType.JellyfinUser,
ProviderUserId = jellyfinUser.Id,
MovieRequestLimit = userManagementSettings.MovieRequestLimit,
EpisodeRequestLimit = userManagementSettings.EpisodeRequestLimit,
StreamingCountry = userManagementSettings.DefaultStreamingCountry
};
_log.LogInformation("Creating Jellyfin user {0}", newUser.UserName);
var result = await _userManager.CreateAsync(newUser);
if (!result.Succeeded)
{
foreach (var identityError in result.Errors)
{
_log.LogError(LoggingEvents.JellyfinUserImporter, identityError.Description);
}
continue;
}
if (userManagementSettings.DefaultRoles.Any())
{
foreach (var defaultRole in userManagementSettings.DefaultRoles)
{
await _userManager.AddToRoleAsync(newUser, defaultRole);
}
}
}
else
{
// Do we need to update this user?
existingJellyfinUser.UserName = jellyfinUser.Name;
await _userManager.UpdateAsync(existingJellyfinUser);
}
}
}
await _notification.Clients.Clients(NotificationHub.AdminConnectionIds)
.SendAsync(NotificationHub.NotificationEvent, "Jellyfin User Importer Finished");
}
public async Task Start()
{
var userManagementSettings = await _userManagementSettings.GetSettingsAsync();
if (!userManagementSettings.ImportEmbyUsers)
{
return;
}
var settings = await _embySettings.GetSettingsAsync();
if (!settings.Enable)
{
return;
}
var allUsers = await _userManager.Users.Where(x => x.UserType == UserType.EmbyUser).ToListAsync();
foreach (var server in settings.Servers)
{
if (string.IsNullOrEmpty(server.ApiKey))
{
continue;
}
var embyUsers = await _api.GetUsers(server.FullUri, server.ApiKey);
foreach (var embyUser in embyUsers)
{
// Check if we should import this user
if (userManagementSettings.BannedEmbyUserIds.Contains(embyUser.Id))
{
// Do not import these, they are not allowed into the country.
continue;
}
// Check if this Plex User already exists
// We are using the Plex USERNAME and Not the TITLE, the Title is for HOME USERS
var existingEmbyUser = allUsers.FirstOrDefault(x => x.ProviderUserId == embyUser.Id);
if (existingEmbyUser == null)
{
if (!embyUser.ConnectUserName.HasValue() && !embyUser.Name.HasValue())
{
_log.LogInformation("Could not create Emby user since the have no username, PlexUserId: {0}", embyUser.Id);
continue;
}
// Create this users
// We do not store a password against the user since they will authenticate via Plex
var newUser = new OmbiUser
{
UserType = UserType.EmbyUser,
UserName = embyUser.ConnectUserName.HasValue() ? embyUser.ConnectUserName : embyUser.Name,
ProviderUserId = embyUser.Id,
Alias = string.Empty,
EmbyConnectUserId = embyUser.ConnectUserId.HasValue() ? embyUser.ConnectUserId : string.Empty,
MovieRequestLimit = userManagementSettings.MovieRequestLimit,
EpisodeRequestLimit = userManagementSettings.EpisodeRequestLimit
};
var result = await _userManager.CreateAsync(newUser);
if (!result.Succeeded)
{
foreach (var identityError in result.Errors)
{
_log.LogError(LoggingEvents.EmbyUserImporter, identityError.Description);
}
continue;
}
if (userManagementSettings.DefaultRoles.Any())
{
foreach (var defaultRole in userManagementSettings.DefaultRoles)
{
await _userManager.AddToRoleAsync(newUser, defaultRole);
}
}
}
else
{
// Do we need to update this user?
existingEmbyUser.UserName = embyUser.Name;
existingEmbyUser.EmbyConnectUserId =
embyUser.ConnectUserId.HasValue() ? embyUser.ConnectUserId : string.Empty;
if (existingEmbyUser.IsEmbyConnect)
{
// Note: We do not have access to any of the emby connect details e.g. email
// Since we need the username and password to connect to emby connect,
// We update the email address in the OmbiUserManager when the emby connect user logs in
existingEmbyUser.UserName = embyUser.ConnectUserName;
}
await _userManager.UpdateAsync(existingEmbyUser);
}
}
}
}
public void Setup(OmbiUser user, CustomizationSettings s)
{
ApplicationUrl = (s?.ApplicationUrl.HasValue() ?? false) ? s.ApplicationUrl : string.Empty;
ApplicationName = string.IsNullOrEmpty(s?.ApplicationName) ? "Ombi" : s?.ApplicationName;
RequestedUser = user.UserName;
}
public async Task Execute(IJobExecutionContext job)
{
var userManagementSettings = await _userManagementSettings.GetSettingsAsync();
if (!userManagementSettings.ImportEmbyUsers)
{
return;
}
var settings = await _embySettings.GetSettingsAsync();
if (!settings.Enable)
{
return;
}
Api = _apiFactory.CreateClient(settings);
await _notification.Clients.Clients(NotificationHub.AdminConnectionIds)
.SendAsync(NotificationHub.NotificationEvent, $"Emby User Importer Started");
var allUsers = await _userManager.Users.Where(x => x.UserType == UserType.EmbyUser || x.UserType == UserType.EmbyConnectUser).ToListAsync();
foreach (var server in settings.Servers)
{
if (string.IsNullOrEmpty(server.ApiKey))
{
continue;
}
var embyUsers = await Api.GetUsers(server.FullUri, server.ApiKey);
foreach (var embyUser in embyUsers)
{
// Check if we should import this user
if (userManagementSettings.BannedEmbyUserIds.Contains(embyUser.Id))
{
// Do not import these, they are not allowed into the country.
continue;
}
// Check if this Emby User already exists
var existingEmbyUser = allUsers.FirstOrDefault(x => x.ProviderUserId == embyUser.Id);
if (existingEmbyUser == null)
{
if (!embyUser.ConnectUserName.HasValue() && !embyUser.Name.HasValue())
{
_log.LogInformation("Could not create Emby user since the have no username, PlexUserId: {0}", embyUser.Id);
continue;
}
var isConnectUser = embyUser.ConnectUserName.HasValue();
// Create this users
var newUser = new OmbiUser
{
UserType = isConnectUser ? UserType.EmbyConnectUser : UserType.EmbyUser,
UserName = isConnectUser ? embyUser.ConnectUserName : embyUser.Name,
ProviderUserId = embyUser.Id,
Alias = isConnectUser ? embyUser.Name : string.Empty,
MovieRequestLimit = userManagementSettings.MovieRequestLimit,
EpisodeRequestLimit = userManagementSettings.EpisodeRequestLimit,
StreamingCountry = userManagementSettings.DefaultStreamingCountry
};
var result = await _userManager.CreateAsync(newUser);
if (!result.Succeeded)
{
foreach (var identityError in result.Errors)
{
_log.LogError(LoggingEvents.EmbyUserImporter, identityError.Description);
}
continue;
}
if (userManagementSettings.DefaultRoles.Any())
{
foreach (var defaultRole in userManagementSettings.DefaultRoles)
{
await _userManager.AddToRoleAsync(newUser, defaultRole);
}
}
}
else
{
// Do we need to update this user?
existingEmbyUser.UserName = embyUser.Name;
if (existingEmbyUser.IsEmbyConnect)
{
// Note: We do not have access to any of the emby connect details e.g. email
// Since we need the username and password to connect to emby connect,
// We update the email address in the OmbiUserManager when the emby connect user logs in
existingEmbyUser.UserName = embyUser.ConnectUserName;
existingEmbyUser.Alias = embyUser.Name;
}
await _userManager.UpdateAsync(existingEmbyUser);
}
}
}
await _notification.Clients.Clients(NotificationHub.AdminConnectionIds)
.SendAsync(NotificationHub.NotificationEvent, "Emby User Importer Finished");
}
private async Task <OmbiUser> FindLinkedUserByNotificationPreferencesAsync(string userUniqueId, JSONOmbiUser[] allOmbiUsers, OmbiUser ombiUser)
{
await Task.WhenAll(allOmbiUsers.Select(async x =>
{
try
{
var notifResponse = await HttpGetAsync($"{BaseURL}/api/v1/Identity/notificationpreferences/{x.id.ToString()}");
var jsonNotifResponse = await notifResponse.Content.ReadAsStringAsync();
await notifResponse.ThrowIfNotSuccessfulAsync("OmbiFindUserNotificationPreferences failed", x => x.error);
IEnumerable <dynamic> notificationPreferences = JArray.Parse(jsonNotifResponse);
var matchingDiscordNotification = notificationPreferences.FirstOrDefault(n => n.agent == 1 && n.value.ToString().Trim().Equals(userUniqueId.Trim(), StringComparison.InvariantCultureIgnoreCase));
if (matchingDiscordNotification != null)
{
ombiUser = new OmbiUser
{
Username = x.userName,
ApiAlias = !string.IsNullOrWhiteSpace(x.alias) ? x.alias : x.userName,
CanRequestMovies = x.CanRequestMovie,
MoviesQuotaRemaining = x.movieRequestQuota == null || !x.movieRequestQuota.hasLimit ? int.MaxValue : x.movieRequestQuota.remaining,
CanRequestTvShows = x.CanRequestTv,
TvEpisodeQuotaRemaining = x.episodeRequestQuota == null || !x.episodeRequestQuota.hasLimit ? int.MaxValue : x.episodeRequestQuota.remaining,
};
}
}
catch (System.Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}));
return(ombiUser);
}
