public async Task <ActionResult> Add(Admin admin)
{
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <Admin>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByNameAsync("admin");
var isUserExist = userRepository.IsUserExistAsync(admin.UserName);
if (await isUserExist)
{
TempData["error"] = "Account with this name already exist!";
return(View("Create", admin));
}
Admin _admin = new Admin()
{
UserName = admin.UserName,
Email = admin.Email,
Role = await role,
PasswordHash = ApplicationPasswordHasher.HashPasword(admin.PasswordHash),
FirstName = admin.FirstName,
LastName = admin.LastName
};
new ApplicationUserRepository <Admin>().Create(_admin);
TempData["success"] = "Admin account was added";
}
else
{
return(View("Create", admin));
}
return(RedirectToAction("Admins"));
}
public static ApplicationRoleRepository GetApplicationRoleRepository(IUnitOfWork unitOfWork)
{
var repository = new ApplicationRoleRepository();
repository.UnitOfWork = unitOfWork;
return(repository);
}
public void TestApplicationRoleWithNewRoleDoesNotSave()
{
ApplicationRole applicationRole = null;
try
{
#region Arrange
applicationRole = GetValid(9);
applicationRole.Role = new Role();
#endregion Arrange
#region Act
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.EnsurePersistent(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
#endregion Act
}
catch (Exception ex)
{
Assert.IsNotNull(applicationRole);
Assert.IsNotNull(ex);
Assert.AreEqual("object references an unsaved transient instance - save the transient instance before flushing. Type: Catbert4.Core.Domain.Role, Entity: Catbert4.Core.Domain.Role", ex.Message);
throw;
}
}
public IActionResult EditUser(int id)
{
ApplicationUserRepository userRepo;
ApplicationRoleRepository roleRepo;
ApplicationUserViewModel view = new ApplicationUserViewModel()
{
User = null, Roles = null
};
try
{
userRepo = new ApplicationUserRepository(settings, logger, dbc);
roleRepo = new ApplicationRoleRepository(settings, logger, dbc);
view.User = userRepo.FindByPKView(new PrimaryKey()
{
Key = id, IsIdentity = true
});
view.Roles = roleRepo.FindAll();
// Update the RoleBadges
foreach (ApplicationUserClaim uc in view.User.Claims.Where(uc => uc.UserId == view.User.Id && uc.ClaimType == ClaimTypes.Role))
{
view.User.RoleBadges += String.Format("{0}-{1}|", uc.Id, uc.ClaimValue);
}
}
catch (Exception ex)
{
throw (Exception)Activator.CreateInstance(ex.GetType(), ex.Message + ex.StackTrace);
}
return(View("EditUser", view));
}
public void TestApplicationRoleDeleteDoesNotCascadeToRole()
{
#region Arrange
RoleRepository.DbContext.BeginTransaction();
LoadRoles(3);
RoleRepository.DbContext.CommitTransaction();
var applicationRole = GetValid(9);
applicationRole.Role = RoleRepository.GetById(2);
var applicationRoleCount = ApplicationRoleRepository.Queryable.Count();
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.EnsurePersistent(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
Assert.IsNotNull(applicationRole.Role);
Assert.IsFalse(applicationRole.IsTransient());
Assert.IsTrue(applicationRole.IsValid());
Assert.AreEqual(applicationRoleCount + 1, ApplicationRoleRepository.Queryable.Count());
#endregion Arrange
#region Act
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.Remove(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(applicationRoleCount, ApplicationRoleRepository.Queryable.Count());
Assert.AreEqual(3, RoleRepository.Queryable.Count());
#endregion Assert
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
User = new ApplicationUserRepository(context);
Role = new ApplicationRoleRepository(context);
UserRole = new ApplicationUserRoleRepository(context);
}
//private System.Web.Security.SqlRoleProvider sqlManager;
public UsersController()
{
//sqlManager = new System.Web.Security.SqlRoleProvider();
context = new ApplicationDbContext();
applicationUserRepository = new ApplicationUserRepository(context);
applicationRoleRepository = new ApplicationRoleRepository(context);
raceRepository = new RaceRepository(context);
unitOfWork = new UnitOfWork(context);
userStore = new UserStore <ApplicationUser>(context);
userManager = new UserManager <ApplicationUser>(userStore);
}
public async Task <ActionResult> RegisterTester(Tester tester)
{
ModelState.Remove(nameof(tester.FirstName));
ModelState.Remove(nameof(tester.LastName));
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <ApplicationUser>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByNameAsync("tester");
var isUserExist = userRepository.IsUserExistAsync(tester.UserName);
if (await isUserExist)
{
TempData["error"] = "Account with this name already exist!";
return(View("Tester"));
}
Tester _tester = new Tester()
{
UserName = tester.UserName,
Email = tester.Email,
Role = await role,
PasswordHash = ApplicationPasswordHasher.HashPasword(tester.PasswordHash)
};
_tester.Address = new Address()
{
User = _tester
};
new ApplicationUserRepository <Tester>().Create(_tester);
ClaimsIdentity identity = await AppUserManager.CreateIdentityAsync(_tester, DefaultAuthenticationTypes.ApplicationCookie);
identity.AddClaim(new Claim(ClaimTypes.Role, _tester.Role.Name));
AuthManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = false,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
}, identity);
return(RedirectToAction("Index", "Home", new { area = "Testing" }));
}
return(View("Tester"));
}
public ActionResult Delete(IList <Admin> rows)
{
var adminRepo = new ApplicationUserRepository <Admin>();
var roleRepo = new ApplicationRoleRepository();
foreach (var row in rows)
{
row.Role = roleRepo.GetByName("admin");
adminRepo.Delete(row);
}
TempData["success"] = "User/s was deleted!";
return(View("Admins"));
}
public IActionResult Roles()
{
ApplicationRoleRepository roleRepo;
ICollection <ApplicationRole> roles;
try
{
roleRepo = new ApplicationRoleRepository(settings, logger, dbc);
roles = roleRepo.FindAll();
}
catch (Exception ex)
{
throw (Exception)Activator.CreateInstance(ex.GetType(), ex.Message + ex.StackTrace);
}
return(View("Roles", roles));
}
public async Task <ActionResult> RegisterCompany(Company company)
{
ModelState.Remove(nameof(company.Rating));
ModelState.Remove(nameof(company.Reviews));
ModelState.Remove(nameof(company.CompanyName));
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <ApplicationUser>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByNameAsync("company");
var isUserExist = userRepository.IsUserExistAsync(company.UserName);
if (await isUserExist)
{
TempData["error"] = "Account with this name already exist!";
return(View("Company"));
}
Company _company = new Company()
{
UserName = company.UserName,
Email = company.Email,
Role = await role,
PasswordHash = ApplicationPasswordHasher.HashPasword(company.PasswordHash),
Address = new Address()
};
new ApplicationUserRepository <Company>().Create(_company);
ClaimsIdentity identity = await AppUserManager.CreateIdentityAsync(_company, DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AuthManager.SignIn(new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = false,
ExpiresUtc = DateTime.UtcNow.AddMinutes(10)
}, identity);
return(RedirectToAction("Index", "Home", new { area = "Testing" }));
}
return(View("Company"));
}
public void TestApplicationRoleWithMinValueSaves()
{
#region Arrange
var applicationRole = GetValid(9);
applicationRole.Level = int.MinValue;
#endregion Arrange
#region Act
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.EnsurePersistent(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(int.MinValue, applicationRole.Level);
Assert.IsFalse(applicationRole.IsTransient());
Assert.IsTrue(applicationRole.IsValid());
#endregion Assert
}
public void TestApplicationRoleWithNullRoleSaves()
{
#region Arrange
var applicationRole = GetValid(9);
applicationRole.Role = null;
#endregion Arrange
#region Act
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.EnsurePersistent(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsNull(applicationRole.Role);
Assert.IsFalse(applicationRole.IsTransient());
Assert.IsTrue(applicationRole.IsValid());
#endregion Assert
}
public UserService(IRepository <ApplicationUser> clientRepository)
{
_clientRepository = clientRepository;
ApplicationContext db = new ApplicationContext("DefaultConnection");
var provider = new DpapiDataProtectionProvider("Sample");
UserManager = new ApplicationUserRepository(new UserStore <ApplicationUser,
CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(db));
UserManager.UserTokenProvider = new DataProtectorTokenProvider <ApplicationUser, int>(provider.Create("EmailConfirmation"));
RoleManager = new ApplicationRoleRepository(new RoleStore <ApplicationRole>(db));
var currentUser = _clientRepository.Get(HttpContext.Current.User.Identity.GetUserId <int>());
if (!ReferenceEquals(currentUser, null))
{
HttpContext.Current.Session["isPerformer"] = currentUser.IsPerformer;
HttpContext.Current.Session["adminStatus"] = currentUser.AdminStatus;
}
}
public UnitOfWork(ApplicationDbContext db)
{
_db = db;
Wehicle = new WehicleRepository(_db);
BusStop = new BusStopRepository(_db);
LineName = new LineNameRepository(_db);
BusStopList = new BusStopListRepository(_db);
Holidays = new HolidaysRepository(_db);
Messages = new MessagesRepository(_db);
OperatingDays = new OperatingDaysRepository(_db);
TicketPrice = new TicketPriceRepository(_db);
ArrivalsDepartures = new ArrivalDeparturesRepository(_db);
Timetable = new TimetableRepository(_db);
BusRoute = new BusRouteRepository(_db);
Tickets = new TicketsRepository(_db);
Payment = new PaymentRepository(_db);
ApplicationUser = new ApplicationUserRepository(_db);
ApplicationRole = new ApplicationRoleRepository(_db);
BankAccount = new BankAccountRepository(_db);
}
public ActionResult Update(Admin admin)
{
ModelState.Remove(nameof(admin.PasswordConfirmationHash));
if (ModelState.IsValid)
{
var userRepository = new ApplicationUserRepository <Admin>();
var roleRepository = new ApplicationRoleRepository();
var role = roleRepository.GetByName("admin");
admin.Role = role;
userRepository.Update(admin);
TempData["success"] = "Admin account was edited";
}
else
{
return(View("Edit", admin));
}
return(RedirectToAction("Admins"));
}
public void TestApplicationRoleWithExistingRoleSaves()
{
#region Arrange
RoleRepository.DbContext.BeginTransaction();
LoadRoles(1);
RoleRepository.DbContext.CommitTransaction();
var applicationRole = GetValid(9);
applicationRole.Role = RoleRepository.GetById(1);
#endregion Arrange
#region Act
ApplicationRoleRepository.DbContext.BeginTransaction();
ApplicationRoleRepository.EnsurePersistent(applicationRole);
ApplicationRoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsNotNull(applicationRole.Role);
Assert.AreEqual("Name1", applicationRole.Role.Name);
Assert.IsFalse(applicationRole.IsTransient());
Assert.IsTrue(applicationRole.IsValid());
#endregion Assert
}
public ApplicationRoleRepositoryTests(PubsContextInMemoryDatabaseFixture fixture)
{
_repository = new ApplicationRoleRepository(fixture.PubsDbContext);
}
public RoleService(ApplicationRoleRepository _repo)
{
repo = _repo;
}
public ApplicationRoleController()
{
context = new ApplicationDbContext();
applicationRoleRepository = new ApplicationRoleRepository(context);
unitOfWork = new UnitOfWork(context);
}
public async Task <ActionResult> EditUser(ApplicationUserViewModel view)
{
ApplicationUserRepository userRepo;
ApplicationRoleRepository roleRepo;
ApplicationUserClaimRepository userClaimRepo;
ApplicationAuditLogRepository logRepo;
ApplicationUserClaim userClaim = null;
IList <string> currentRoles = null;
string role = String.Empty;
int claimId = 0;
int rows = 0;
const string issuer = "Local Authority";
const string claimTypesDepartment = "Department";
bool isCurrentUser = view.User.UserName.ToUpper() == HttpContext.User.Identity.Name.ToUpper() ? true : false;
try
{
userRepo = new ApplicationUserRepository(settings, logger, dbc);
userClaimRepo = new ApplicationUserClaimRepository(settings, logger, dbc);
roleRepo = new ApplicationRoleRepository(settings, logger, dbc);
logRepo = new ApplicationAuditLogRepository(settings, logger, dbc);
if (ModelState.IsValid)
{
// Update the user in the database
userRepo.Update(view.User);
//Add DOB claim to database and to claims list of the current user, if applicable
userClaim = (userClaimRepo.FindAll()).FirstOrDefault(uc => uc.UserId == view.User.Id && uc.ClaimType == ClaimTypes.DateOfBirth);
if (userClaim != null)
{
if (userClaim.ClaimValue != view.User.DOB.ToString("yyyy-MM-dd hh:mm:ss"))
{
userClaim.ModifiedDt = DateTime.Now;
userClaim.ClaimValue = view.User.DOB.ToString("yyyy-MM-dd hh:mm:ss");
// Update the database
userClaimRepo.Update(userClaim);
logger.LogInformation($"Updated claim({ClaimTypes.DateOfBirth}) for user account: {view.User.UserName}");
}
else
{
// Nothing changed, so no need to update the database
}
}
else
{
// Add DOB claim to the database
userClaim = new ApplicationUserClaim()
{
UserId = view.User.Id,
ClaimType = ClaimTypes.DateOfBirth, ClaimValue = view.User.DOB.ToString("yyyy-MM-dd hh:mm:ss"), ClaimIssuer = issuer,
Active = true, ModifiedDt = DateTime.Now, CreateDt = DateTime.Now
};
userClaimRepo.Add(userClaim);
logger.LogInformation($"Added new claim({ClaimTypes.DateOfBirth}) to user account: {view.User.UserName}");
}
//TODO: Department still has issues when transitioning from null to not null
//Add Department claim to database and to claims list of the user
userClaim = (userClaimRepo.FindAll()).FirstOrDefault(uc => uc.UserId == view.User.Id && uc.ClaimType == claimTypesDepartment);
if (userClaim != null)
{
if (view.User.Department != null && userClaim.ClaimValue != view.User.Department)
{
userClaim.ModifiedDt = DateTime.Now;
userClaim.ClaimValue = view.User.Department;
userClaimRepo.Update(userClaim);
logger.LogInformation($"Updated claim({claimTypesDepartment}) for user account: {view.User.UserName}");
}
else
{
// Nothing changed, so no need to update the database
}
}
else
{
if (view.User.Department != null)
{
userClaim = new ApplicationUserClaim()
{
UserId = view.User.Id,
ClaimType = claimTypesDepartment, ClaimValue = view.User.Department, ClaimIssuer = issuer,
Active = true, ModifiedDt = DateTime.Now, CreateDt = DateTime.Now
};
userClaimRepo.Add(userClaim);
logger.LogInformation($"Assigned new claim({claimTypesDepartment}) to user account: {view.User.UserName}");
}
}
//Add Role claim to database and to claims list of the user
// Process the roles and update the role store
currentRoles = (userClaimRepo.FindAll()).Where(uc => uc.UserId == view.User.Id && uc.ClaimType == ClaimTypes.Role).Select(r => r.ClaimValue).ToList();;
if (view.User.RoleBadges != null)
{
foreach (string r in view.User.RoleBadges.Split("|"))
{
if (r != String.Empty)
{
role = r.Substring(r.IndexOf('-') + 1, r.Length - r.IndexOf('-') - 1);
// Add, if it's a new role
if (!currentRoles.Contains(role))
{
claimId = (int)userClaimRepo.Add(new ApplicationUserClaim()
{
UserId = view.User.Id,
ClaimType = ClaimTypes.Role, ClaimValue = role, ClaimIssuer = issuer,
Active = true, ModifiedDt = DateTime.Now, CreateDt = DateTime.Now
});
if (claimId > 0)
{
logger.LogInformation($"Assigned role({role}) to user account: {view.User.UserName}");
}
else
{
logger.LogError($"Error assigning role({role}) to user account: {view.User.UserName}");
}
}
}
}
}
// Remove any roles of which the user is no longer a member
foreach (string r in currentRoles)
{
if (!view.User.RoleBadges.Contains(r))
{
claimId = (userClaimRepo.FindAll()).FirstOrDefault(c => c.ClaimType == ClaimTypes.Role && c.UserId == view.User.Id).Id;
rows = userClaimRepo.Delete(new PrimaryKey()
{
Key = (int)claimId, IsIdentity = true
});
if (rows > 0)
{
logger.LogInformation($"Removed role({r}) from user account: {view.User.UserName}");
}
else
{
logger.LogError($"Error removing role({r}) from account: {view.User.UserName}");
}
}
}
// If we've updated the claims for the currently signed-in user,
// then refresh Cookie by recreating the User Security Principal from the database
if (isCurrentUser)
{
await identityManager.RefreshClaimsAsync(view.User, userClaimRepo.FindAll().Where(uc => uc.UserId == view.User.Id).ToList());
logRepo.Add(new ApplicationAuditLog()
{
CategoryId = 1, Description = $"User ({view.User.UserName}) logged into application with refreshed claims."
});
logger.LogInformation($"Refreshed cookie for user: {view.User.UserName}");
}
return(RedirectToAction("Index", "Account"));
}
else
{
userClaimRepo = new ApplicationUserClaimRepository(settings, logger, dbc);
userRepo = new ApplicationUserRepository(settings, logger, dbc);
view.User = userRepo.FindByPKView(new PrimaryKey()
{
Key = view.User.Id, IsIdentity = true
});
view.Roles = roleRepo.FindAll();
// Update the RoleBadges
foreach (ApplicationUserClaim uc in view.User.Claims.Where(uc => uc.UserId == view.User.Id))
{
view.User.RoleBadges += String.Format("{0}-{1}|", uc.Id, uc.ClaimType);
}
return(View("EditUser", view));
}
}
catch (Exception ex)
{
throw (Exception)Activator.CreateInstance(ex.GetType(), ex.Message + ex.StackTrace);
}
}
public ApplicationRoleRepositoryTests()
{
_repository = new ApplicationRoleRepository(Context);
}
