private bool BeAnExistingUser(string userId)
{
using (var database = AdminAppIdentityDbContext.Create())
{
return(database.Users.Any(x => x.Id == userId));
}
}
public void Execute(IEditOdsInstanceRegistrationForUserModel model)
{
using (var database = AdminAppIdentityDbContext.Create())
{
var preexistingAssociations = database.UserOdsInstanceRegistrations.Where(x => x.UserId == model.UserId).ToList();
var selectedOdsInstanceRegistrationIds =
model.OdsInstanceRegistrations.Where(x => x.Selected).Select(x => x.OdsInstanceRegistrationId).ToList();
var recordsToAdd = NewAssignments(model.UserId, selectedOdsInstanceRegistrationIds, preexistingAssociations);
if (recordsToAdd.Any())
{
database.UserOdsInstanceRegistrations.AddRange(recordsToAdd);
}
var recordsToRemove = AssignmentsToRemove(selectedOdsInstanceRegistrationIds, preexistingAssociations);
if (recordsToRemove.Any())
{
database.UserOdsInstanceRegistrations.RemoveRange(recordsToRemove);
}
database.SaveChanges();
}
}
private static bool BeAUniqueEmail(string newEmail)
{
using (var database = AdminAppIdentityDbContext.Create())
{
return(database.Users.ToList().All(x => x.Email != newEmail));
}
}
public void ShouldNotRegisterUserIfEmailNotUnique()
{
EnsureZeroUsers();
using (var database = AdminAppIdentityDbContext.Create())
{
var user = new AdminAppUser()
{
Email = "*****@*****.**",
UserName = "******"
};
database.Users.Add(user);
database.SaveChanges();
}
var newUser = new RegisterViewModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var validator = new RegisterViewModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Select(x => x.ErrorMessage).ShouldContain("A user with the email already exists in the database");
}
public async Task ShouldRegisterUserWithRequirePasswordChangeAsFalse()
{
var guidString = Guid.NewGuid().ToString("N");
var newUser = new RegisterViewModel
{
Email = $"test{guidString}@test.com",
Password = "******",
ConfirmPassword = "******"
};
var manager = SetupApplicationUserManager();
var command = new RegisterCommand();
var(adminAppUser, _) = await command.Execute(newUser, manager);
using (var database = AdminAppIdentityDbContext.Create())
{
var addedUser = database.Users.Single(x => x.Id == adminAppUser.Id);
addedUser.UserName.ShouldBe($"test{guidString}@test.com");
addedUser.Email.ShouldBe($"test{guidString}@test.com");
addedUser.RequirePasswordChange.ShouldBe(false);
}
}
private bool EmailIsChanged(EditUserModel model)
{
using (var database = AdminAppIdentityDbContext.Create())
{
return(database.Users.Single(x => x.Id == model.UserId).Email != model.Email);
}
}
public RegisterViewModelValidator(AdminAppIdentityDbContext identity)
{
_identity = identity;
RuleFor(m => m.Email).NotEmpty().EmailAddress().Must(BeAUniqueEmail).WithMessage("A user with the email already exists in the database");
RuleFor(x => x.Password).NotEmpty().Length(6, 100);
RuleFor(x => x.ConfirmPassword).NotEmpty().Equal(x => x.Password).WithMessage("The password and confirmation password do not match.");
}
public static void EnsureDefaultRoles()
{
using (var database = AdminAppIdentityDbContext.Create())
{
var superAdminRole = database.Roles.SingleOrDefault(x => x.Id.Equals(Role.SuperAdmin.Value.ToString()));
var adminRole = database.Roles.SingleOrDefault(x => x.Id.Equals(Role.Admin.Value.ToString()));
var missingRolesToAdd = new List <IdentityRole>();
if (superAdminRole == null)
{
missingRolesToAdd.Add(new IdentityRole
{
Id = Role.SuperAdmin.Value.ToString(),
Name = Role.SuperAdmin.DisplayName
});
}
if (adminRole == null)
{
missingRolesToAdd.Add(new IdentityRole
{
Id = Role.Admin.Value.ToString(),
Name = Role.Admin.DisplayName
});
}
database.Set <IdentityRole>().AddRange(missingRolesToAdd);
database.SaveChanges();
}
}
private bool BeAnExistingRole(string roleId)
{
using (var database = AdminAppIdentityDbContext.Create())
{
return(database.Set <IdentityRole>().Any(x => x.Id == roleId));
}
}
public InstanceContextFilter(InstanceContext instanceContext, AdminAppDbContext adminAppDbContext,
AdminAppIdentityDbContext adminAppIdentityDbContext)
{
_instanceContext = instanceContext;
_adminAppDbContext = adminAppDbContext;
_adminAppIdentityDbContext = adminAppIdentityDbContext;
}
public RegisterOdsInstanceCommand(IOdsInstanceFirstTimeSetupService odsInstanceFirstTimeSetupService
, IDatabaseConnectionProvider connectionProvider
, AdminAppIdentityDbContext identity)
{
_odsInstanceFirstTimeSetupService = odsInstanceFirstTimeSetupService;
_connectionProvider = connectionProvider;
_identity = identity;
}
public Role Execute(string userId)
{
using (var database = AdminAppIdentityDbContext.Create())
{
var userRoleId = database.Set <IdentityUserRole>().SingleOrDefault(x => x.UserId == userId)?.RoleId;
return(userRoleId != null?Role.GetAll().Single(x => x.Value.Equals(int.Parse(userRoleId))) : null);
}
}
public static void SaveAdminAppUser(List <AdminAppUser> users)
{
using (var database = AdminAppIdentityDbContext.Create())
{
database.Set <AdminAppUser>().AddRange(users);
database.SaveChanges();
}
}
private static bool IsUserAuthorizedForInstance(int instanceId, string userId)
{
using (var database = AdminAppIdentityDbContext.Create())
{
return(database.UserOdsInstanceRegistrations.Any(x =>
x.OdsInstanceRegistrationId == instanceId &&
x.UserId == userId));
}
}
public EditOdsInstanceRegistrationForUserModelValidator(AdminAppDbContext database, AdminAppIdentityDbContext identity)
{
_database = database;
_identity = identity;
RuleFor(m => m.UserId).NotEmpty().Must(BeAnExistingUser).WithMessage("The user you are trying to edit does not exist in the database.");
RuleFor(m => m.Email).NotEmpty();
RuleFor(m => m.OdsInstanceRegistrations).NotEmpty().Must(BeAnExistingOdsInstanceRegistration).WithMessage("A selected instance does not exist in the database.");;
}
public RegisterOdsInstanceCommand(IOdsInstanceFirstTimeSetupService odsInstanceFirstTimeSetupService
, AdminAppIdentityDbContext identity
, ISetCurrentSchoolYearCommand setCurrentSchoolYear
, IInferInstanceService inferInstanceService)
{
_odsInstanceFirstTimeSetupService = odsInstanceFirstTimeSetupService;
_identity = identity;
_setCurrentSchoolYear = setCurrentSchoolYear;
_inferInstanceService = inferInstanceService;
}
private static void EnsureOneUser()
{
EnsureZeroUsers();
using (var database = AdminAppIdentityDbContext.Create())
{
database.Users.Add(new AdminAppUser("testUser"));
database.SaveChanges();
}
}
public EditUserModelValidator(AdminAppIdentityDbContext identity)
{
_identity = identity;
RuleFor(m => m.Email)
.NotEmpty()
.EmailAddress().Must(BeAUniqueEmail)
.WithMessage("A user with this email address already exists in the database.")
.When(EmailIsChanged);
}
public DeleteUserModelValidator(AdminAppUserContext userContext, AdminAppIdentityDbContext identity)
{
_userContext = userContext;
_identity = identity;
RuleFor(m => m.UserId)
.NotEmpty()
.Must(BeAnExistingUser).WithMessage("The user you are trying to delete does not exist in the database.")
.Must(NotBeCurrentUser).WithMessage("The user is not allowed to delete themselves.");
RuleFor(m => m.Email).NotEmpty();
}
private static void EnsureZeroUsers()
{
using (var database = AdminAppIdentityDbContext.Create())
{
foreach (var entity in database.Users)
{
database.Users.Remove(entity);
}
database.SaveChanges();
}
}
public static TResult Query <TResult>(Func <DbContext, TResult> query)
{
TResult result;
using (var database = AdminAppIdentityDbContext.Create())
{
result = query(database);
}
return(result);
}
public EditUserRoleModelValidator(AdminAppUserContext userContext, AdminAppIdentityDbContext identity)
{
_userContext = userContext;
_identity = identity;
RuleFor(m => m.UserId).NotEmpty()
.Must(BeAnExistingUser).WithMessage("The user you are trying to edit does not exist in the database.")
.Must(NotBeCurrentUser).WithMessage("The user is not allowed to assign/remove roles as they are logged in as a Super Administrator or have an Administrator role.");
RuleFor(m => m.RoleId).NotEmpty().Must(BeAnExistingRole).WithMessage("The role you are trying to assign does not exist in the database.");
RuleFor(m => m.Email).NotEmpty();
}
private static void RemoveExistingUserRoles(string userId, AdminAppIdentityDbContext dbContext)
{
var existingUserRoles =
dbContext.Set <IdentityUserRole>().Where(x => x.UserId == userId);
if (existingUserRoles.Any())
{
dbContext.Set <IdentityUserRole>().RemoveRange(existingUserRoles);
}
dbContext.SaveChanges();
}
public IEnumerable <OdsInstanceRegistration> Execute(string userId)
{
List <int> instanceRegistrationIds;
using (var context = AdminAppIdentityDbContext.Create())
{
instanceRegistrationIds = context.UserOdsInstanceRegistrations.Where(x => x.UserId == userId).Select(x => x.OdsInstanceRegistrationId).ToList();
}
var odsInstanceRegistrations =
_database.OdsInstanceRegistrations.Where(x => instanceRegistrationIds.Contains(x.Id)).OrderBy(x => x.Name);
return(odsInstanceRegistrations);
}
public void Execute(IDeleteUserModel userModel)
{
using (var dbContext = AdminAppIdentityDbContext.Create())
{
RemoveExistingUserRoles(userModel.UserId, dbContext);
RemoveExistingUserOdsInstanceRegistrations(userModel.UserId, dbContext);
dbContext.Users.Remove(dbContext.Users.Single(x => x.Id == userModel.UserId));
dbContext.SaveChanges();
}
}
public IdentityController(ApplicationConfigurationService applicationConfiguration, RegisterCommand registerCommand, EditUserRoleCommand editUserRoleCommand, IGetOdsInstanceRegistrationsQuery getOdsInstanceRegistrationsQuery,
SignInManager <AdminAppUser> signInManager,
UserManager <AdminAppUser> userManager,
IProductRegistration productRegistration,
AdminAppIdentityDbContext identity)
{
_applicationConfiguration = applicationConfiguration;
_registerCommand = registerCommand;
_editUserRoleCommand = editUserRoleCommand;
_getOdsInstanceRegistrationsQuery = getOdsInstanceRegistrationsQuery;
_signInManager = signInManager;
_userManager = userManager;
_productRegistration = productRegistration;
_identity = identity;
}
private static void RemoveExistingUserOdsInstanceRegistrations(int odsInstanceId)
{
using (var dbContext = AdminAppIdentityDbContext.Create())
{
var existingUserOdsInstanceRegistrations =
dbContext.UserOdsInstanceRegistrations.Where(x => x.OdsInstanceRegistrationId == odsInstanceId);
if (existingUserOdsInstanceRegistrations.Any())
{
dbContext.UserOdsInstanceRegistrations.RemoveRange(existingUserOdsInstanceRegistrations);
}
dbContext.SaveChanges();
}
}
private static bool TryQueryUser(string userId, out AdminAppUser user)
{
AdminAppUser userLookup;
using (var dbContext = AdminAppIdentityDbContext.Create())
{
userLookup = dbContext.Users.Include(x => x.Roles).SingleOrDefault(x => x.Id == userId);
}
if (userLookup != null)
{
user = userLookup;
return(true);
}
user = null;
return(false);
}
public static void SaveUserRoles(List <AdminAppUser> users, Role userRole)
{
var userRoleRecords = new List <IdentityUserRole>();
foreach (var user in users)
{
userRoleRecords.Add(new IdentityUserRole()
{
UserId = user.Id,
RoleId = userRole.Value.ToString()
});
}
using (var database = AdminAppIdentityDbContext.Create())
{
database.Set <IdentityUserRole>().AddRange(userRoleRecords);
database.SaveChanges();
}
}
public void Execute(IEditUserRoleModel model)
{
using (var database = AdminAppIdentityDbContext.Create())
{
var newUserRole = new IdentityUserRole
{
UserId = model.UserId,
RoleId = model.RoleId
};
var currentUserRole = database.Set <IdentityUserRole>().SingleOrDefault(x => x.UserId == model.UserId);
if (currentUserRole != null)
{
database.Set <IdentityUserRole>().Remove(currentUserRole);
}
database.Set <IdentityUserRole>().Add(newUserRole);
database.SaveChanges();
}
}
