/// <summary>
/// Create data in database
/// </summary>
/// <param name="userRole">Data</param>
/// <returns>insert data</returns>
public UserRole Create(UserRole userRole)
{
if (userRole == null || string.IsNullOrEmpty(userRole.UserId) || string.IsNullOrEmpty(userRole.RoleId))
return null;
var row = new IdentityUserRole<string>();
UserRoleTransformer.ToRow(userRole, row);
_dbContext.UserRoles.Add(row);
_dbContext.SaveChanges();
return UserRoleTransformer.ToBean(row);
}
private static Category<ObjectId> CreateCategory(string name
, IdentityUserRole editRole, IdentityUserRole? viewRole
, ObjectId? id = null, ObjectId? parentID = null)
{
var category = new Category<ObjectId>()
{
Name = name,
Permissions = new List<KeyValuePair<int, string>>()
{
new KeyValuePair<int, string>((int)CategoryPermission.Insert, editRole.ToString()),
new KeyValuePair<int, string>((int)CategoryPermission.Edit, editRole.ToString()),
new KeyValuePair<int, string>((int)CategoryPermission.Delete, editRole.ToString()),
}
};
if (viewRole != null)
{
category.Permissions.Add(
new KeyValuePair<int, string>((int)CategoryPermission.View, viewRole.Value.ToString()));
}
category.CategoryID = id ?? ObjectId.GenerateNewId();
category.ParentCategoryID = parentID;
return category;
}
public override void Import(BGTouristGuideDbContext db)
{
PasswordHasher hasher = new PasswordHasher();
User admin = new User
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Admin",
LastName = "Admin",
PasswordHash = hasher.HashPassword("admin"),
RegistrationDate = DateTime.Now,
SecurityStamp = Guid.NewGuid().ToString()
};
db.Users.Add(admin);
IdentityUserRole adminRole = new IdentityUserRole();
var dbadminRole = db.Roles.Where(r => r.Name == DatabaseConstants.AdminUserRole).FirstOrDefault();
adminRole.UserId = admin.Id;
adminRole.RoleId = dbadminRole.Id;
dbadminRole.Users.Add(adminRole);
db.SaveChanges();
}
public User CreateUserAsClinicOwner(string username, string password)
{
var user = new User
{
UserName = username,
Email = username,
PasswordHash = new PasswordHasher().HashPassword(password),
SecurityStamp = Guid.NewGuid().ToString()
};
var db = new VetSystemDbContext();
var clinicOwnerRole = db.Roles.Where(r => r.Name == "ClinicOwner").FirstOrDefault();
var role = new IdentityUserRole
{
RoleId = clinicOwnerRole.Id
};
this.users.Add(user);
user.Roles.Add(role);
db.Dispose();
this.users.Save();
return user;
}
public IdentityUserRole Convert()
{
var role = new IdentityUserRole();
role.RoleId = this.RoleId;
role.UserId = this.UserId;
return role;
}
public static bool IsRole(IdentityUserRole userRole, RoleId roleId)
{
if (userRole.RoleId == null)
return false;
var currRole = (RoleId) Enum.Parse(typeof(RoleId), userRole.RoleId);
if (currRole == roleId)
return true;
return true;
}
public ActionResult MemberToevoegen(string RoleId, string SelectUser)
{
ApplicationDbContext context = new ApplicationDbContext();
var user = context.Users.FirstOrDefault(u => u.Id == SelectUser);
var role = context.Roles.FirstOrDefault(r => r.Id == RoleId);
if (user != null && role != null)
{
IdentityUserRole userrole = new IdentityUserRole();
userrole.RoleId = RoleId; userrole.UserId = SelectUser;
user.Roles.Add(userrole); context.SaveChanges();
}
return RedirectToAction("RoleDetail", "User", new { id = RoleId });
}
public ActionResult Promote(String id)
{
try
{
String roleIdAdmin = (from role in db.Roles
where role.Name == "Administrator"
select role.Id).SingleOrDefault();
String roleId = (from role in db.Roles
where role.Name == "Moderator"
select role.Id).Single();
var rol = (from roles in db.UserRoles
where roles.UserId == id
select roles).FirstOrDefault();
if (roleIdAdmin == rol.RoleId)
{
TempData["errorDemote"] = "true";
return(RedirectToAction("ListUsers"));
}
Debug.WriteLine(rol.UserId);
db.UserRoles.Remove(rol);
IdentityUserRole identity = new IdentityUserRole {
UserId = id, RoleId = roleId
};
db.UserRoles.Add(identity);
db.SaveChanges();
String currentUserId = User.Identity.GetUserId();
ApplicationUser currentUser = db.Users.FirstOrDefault(x => x.Id == currentUserId);
var roleName = (from userroles in db.UserRoles
join roles in db.Roles on userroles.RoleId equals roles.Id
where userroles.UserId == currentUserId
select roles.Name).FirstOrDefault();
ViewBag.roleAccount = roleName;
}
catch (Exception e)
{
Debug.WriteLine("An error occured: " + e);
}
return(RedirectToAction("ListUsers"));
}
public ActionResult VerwijderMemberFromRole(string userid, string roleid)
{
var user = context.Users.FirstOrDefault(u => u.Id == userid);
var role = context.Roles.FirstOrDefault(r => r.Id == roleid);
if (user != null && role != null)
{
IdentityUserRole userrole = user.Roles.SingleOrDefault(ur => (ur.UserId == userid && ur.RoleId == roleid));
user.Roles.Remove(userrole);
context.SaveChanges();
}
return(RedirectToAction("RoleDetail", "User", new { id = roleid }));
}
public bool AddUserRole(IdentityUserRole <string> userRole)
{
try
{
var res = _context.UserRoles.Add(userRole);
_context.SaveChanges();
return(true);
}
catch (Exception e)
{
_logger.LogError(e, "Failed to connect to the database server to add user role");
return(false);
}
}
/// <summary>
/// Własna implementacja usuwania użytkownika o danej roli
/// </summary>
/// <param name="user"></param>
/// <param name="role"></param>
/// <returns></returns>
private async Task <bool> DeleteRoleAsync(User user, int roleId)
{
var userRole = new IdentityUserRole <int>
{
UserId = user.Id,
RoleId = roleId
};
_context.UserRoles.Remove(userRole);
await _context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Ime,Priimek,Naslov,Telefon,DatumRojstva,DatumZaposlitve,Spol,Kadrovanje")] Zaposlen zaposlen)
{
if (id != zaposlen.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{ IdentityRole role;
if (zaposlen.Kadrovanje)
{
role = await _context.Roles.FirstOrDefaultAsync(m => m.Name == "Manager");
}
else
{
role = await _context.Roles.FirstOrDefaultAsync(m => m.Name == "Worker");
}
var user = await _context.Users.FirstOrDefaultAsync(m => m.Zaposlen.ID == id);
var userRole = await _context.UserRoles.FirstOrDefaultAsync(m => m.UserId == user.Id);
if (userRole != null)
{
_context.UserRoles.Remove(userRole);
}
var userRoleNew = new IdentityUserRole <string> {
UserId = user.Id, RoleId = role.Id
};
_context.UserRoles.Add(userRoleNew);
_context.Update(zaposlen);
await _context.SaveChangesAsync(); }
catch (DbUpdateConcurrencyException)
{
if (!ZaposlenExists(zaposlen.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(zaposlen));
}
public async Task <IActionResult> Index()
{
IEnumerable <ApplicationUser> userList = await _unitOfWork.ApplicationUser.GetAllAsync();
IEnumerable <ApplicationUser> searchUserList = _unitOfWork.ApplicationUser.Search(SearchTerm);
var userRole = _unitOfWork.ApplicationUser.UserRole();
var roles = _unitOfWork.ApplicationUser.Role();
foreach (var user in userList)
{
IdentityUserRole <string> first = null;
foreach (var u in userRole)
{
if (u.UserId == user.Id)
{
first = u;
break;
}
}
var roleId = first.RoleId;
IdentityRole first1 = null;
foreach (var r in roles)
{
if (r.Id == roleId)
{
first1 = r;
break;
}
}
user.Role = first1.Name;
}
UserVM userVm = new UserVM()
{
ApplicationUser = userList,
SearchTerm = SearchTerm
};
if (userVm.SearchTerm != null)
{
userVm.ApplicationUser = searchUserList;
return(View(userVm));
}
return(View(userVm));
}
public Dictionary <string, object> MakeAdminUser(string userId, string adminId)
{
var flag = false;
if (userId != adminId)
{
var userRoleId = this.context.Roles.FirstOrDefault(r => r.Name == "User").Id;
var userRole = this.context.UserRoles.FirstOrDefault(ur => ur.UserId == userId);
if (userRole == null)
{
userRole = new IdentityUserRole <string>();
userRole.UserId = userId;
userRole.RoleId = userRoleId;
this.context.UserRoles.Add(userRole);
this.context.SaveChanges();
}
else
{
this.context.UserRoles.Remove(userRole);
var newUserRole = new IdentityUserRole <string>();
newUserRole.UserId = userId;
newUserRole.RoleId = userRoleId;
this.context.UserRoles.Add(newUserRole);
this.context.SaveChanges();
}
flag = true;
}
AllUsersViewModel model = new AllUsersViewModel();
var returnMoodel = this.GetUsers(model);
Dictionary <string, object> result = new Dictionary <string, object>();
result.Add("model", result);
if (flag == true)
{
result.Add("message", "Успешно променени права на потребител!");
var message = $"Вашите права бяха променени на потребителски!";
this.notificationService.AddNotificationAtDB(userId, message);
}
else
{
result.Add("message", "Не може да променяте собствените си права!");
}
return(result);
}
protected override void Seed(Twitter.Data.TwitterDbContext context)
{
if (!context.Roles.Any())
{
context.Roles.Add(new IdentityRole {
Name = "Administrator"
});
context.SaveChanges();
}
if (!context.Users.Where(u => u.UserName == "*****@*****.**").Any())
{
var admin = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
PasswordHash = new PasswordHasher().HashPassword("admin"),
SecurityStamp = Guid.NewGuid().ToString()
};
context.Users.Add(admin);
var role = context.Roles.Where(r => r.Name == "Administrator").FirstOrDefault();
var adminRole = new IdentityUserRole
{
RoleId = role.Id
};
admin.Roles.Add(adminRole);
context.SaveChanges();
}
if (!context.Users.Where(u => u.UserName == "*****@*****.**").Any())
{
for (int i = 1; i <= 2; i++)
{
var user = new ApplicationUser
{
UserName = $"user{i}@site.com",
Email = $"user{i}@site.com",
PasswordHash = new PasswordHasher().HashPassword($"user{i}"),
SecurityStamp = Guid.NewGuid().ToString()
};
context.Users.Add(user);
context.SaveChanges();
}
}
}
private async Task SeedUsersAndRoles(ApplicationDbContext context)
{
var adminRole = new ApplicationRole
{
Id = "adminRoleId",
Name = GlobalConstants.AdministratorRoleName,
};
var userRole = new ApplicationRole
{
Id = "userRoleId",
Name = GlobalConstants.UserRoleName,
};
var userOne = new ApplicationUser
{
Id = "userOneId",
UserName = "******",
};
var userTwo = new ApplicationUser
{
Id = "userTwoId",
UserName = "******",
LockoutEnd = DateTimeOffset.UtcNow.AddYears(100),
};
await context.Users.AddRangeAsync(userOne, userTwo);
await context.Roles.AddRangeAsync(adminRole, userRole);
await context.SaveChangesAsync();
var adminUserRole = new IdentityUserRole <string>
{
UserId = "userOneId",
RoleId = "adminRoleId",
};
var userUserRole = new IdentityUserRole <string>
{
UserId = "userTwoId",
RoleId = "userRoleId",
};
await context.UserRoles.AddRangeAsync(adminUserRole, userUserRole);
await context.SaveChangesAsync();
}
public void RemoveFromRole(ApplicationUserDto user, string roleName)
{
var role = Context.Set <IdentityRole>().SingleOrDefault(r => r.Name == roleName);
if (role != null)
{
var roleToDelete = new IdentityUserRole <string>
{
RoleId = role.Id,
UserId = user.Id
};
Context.Entry(roleToDelete).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
SaveChanges();
}
}
public async Task <ActionResult> inserirFuncao(IdentityUserRole <string> userRole)
{
IdentityUserRole <string> alvo = dbContext.UserRoles.SingleOrDefault(u => u.UserId == userRole.UserId && u.RoleId == userRole.RoleId);
if (ModelState.IsValid && alvo == null)
{
dbContext.UserRoles.Add(userRole);
await dbContext.SaveChangesAsync();
ModelState.Clear();
return(GetUserToUpdate(userRole.UserId));
}
ViewData["Erro"] = "Já existe esta função para o usuário.";
return(GetUserToUpdate(userRole.UserId));
}
public async Task <bool> RoleCheck(string id, string role)
{
string roleId = await db.Roles.Where(x => x.Name == role).Select(x => x.Id).FirstOrDefaultAsync();
IdentityUserRole <string> ur = await db.UserRoles.Where(x => x.RoleId == roleId && x.UserId == id).FirstOrDefaultAsync();
if (ur != null)
{
return(true);
}
else
{
return(false);
}
}
public ActionResult MemberToevoegen(string RoleId, string SelectUser)
{
var user = context.Users.FirstOrDefault(u => u.Id == SelectUser);
var role = context.Roles.FirstOrDefault(r => r.Id == RoleId);
if (user != null && role != null)
{
IdentityUserRole userrole = new IdentityUserRole();
userrole.RoleId = RoleId;
userrole.UserId = SelectUser;
user.Roles.Add(userrole);
context.SaveChanges();
}
return(RedirectToAction("RoleDetail", "User", new { id = RoleId }));
}
public void DemoteUser(string id)
{
var record = _context.UserRoles.FirstOrDefault(x => x.UserId == id);
if (record != null)
{
_context.UserRoles.Remove(record);
var userRole = _context.Roles.Where(x => x.Name == "User").FirstOrDefault();
var newUserRole = new IdentityUserRole <string> {
RoleId = userRole.Id, UserId = id
};
_context.UserRoles.Add(newUserRole);
_context.SaveChanges();
}
}
public async Task DeleteUser(string id)
{
var record = _context.UserRoles.FirstOrDefault(x => x.UserId == id);
if (record != null)
{
_context.UserRoles.Remove(record);
var inactiveRole = _context.Roles.Where(x => x.Name == "Inactive").FirstOrDefault();
var newUserRole = new IdentityUserRole <string> {
RoleId = inactiveRole.Id, UserId = id
};
_context.UserRoles.Add(newUserRole);
await _context.SaveChangesAsync();
}
}
private static void AddUserRoles(ApplicationDbContext dbContext)
{
if (dbContext.UserRoles.Any())
{
return;
}
var userRole = new IdentityUserRole <string>
{
UserId = dbContext.Users.Single(r => r.Email == AdminEmail).Id,
RoleId = dbContext.Roles.Single(r => r.Name == ApplicationRoles.Admin).Id
};
dbContext.UserRoles.Add(userRole);
dbContext.SaveChanges();
}
private void RemoveUserToRole(TARUser tARUser, string RoleName)
{
using (var scope = new TransactionScope())
{
IdentityUserRole userRole = new IdentityUserRole();
IdentityRole role = _unitOfWork.RoleRepository.GetWithInclude(m => m.Name == RoleName, "Users").First();
userRole = tARUser.Roles.FirstOrDefault(m => m.RoleId == role.Id);
if (userRole != null)
{
role.Users.Remove(userRole);
}
_unitOfWork.Save();
scope.Complete();
}
}
public async Task <IHttpActionResult> PutApplicationUser(AppUserViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (viewModel.Id == null)
{
return(BadRequest());
}
// IdentityResult result = await manager.UpdateAsync(applicationUser);
db = Request.GetOwinContext().Get <SecurityDbContext>();
manager = Request.GetOwinContext().Get <ApplicationUserManager>(); ApplicationUser user = manager.FindByEmail(viewModel.Email);
user.Id = viewModel.Id;
user.Email = viewModel.Email;
user.FirstName = viewModel.FirstName;
user.LastName = viewModel.LastName;
user.IsActive = true;
user.EmailConfirmed = true;
user.PhoneNumber = viewModel.PhoneNumber;
user.ShopId = viewModel.ShopId;
user.UserName = viewModel.Email;
db.Entry(user).State = EntityState.Modified;
try
{
IdentityUserRole entity = db.ApplicationUserRoles.FirstOrDefault(x => x.UserId == user.Id);
db.ApplicationUserRoles.Remove(entity);
db.SaveChanges();
var identityUserRole = db.ApplicationUserRoles.Add(new IdentityUserRole {
RoleId = viewModel.RoleId, UserId = user.Id
});
int i = await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ApplicationUserExists(user.Id))
{
return(NotFound());
}
throw;
}
return(Ok(user));
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
using (UserManager <IdentityUser> userManager = _userManagerFactory()) {
IdentityUser user = await userManager.FindAsync(context.UserName, context.Password);
WVCUserManager wvcUserManager = new WVCUserManager();
IdentityManager identityManager = new IdentityManager();
wvc_user wvcUser = null;
IdentityUserRole userRole = null;
IdentityRole role = null;
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
else
{
userRole = user.Roles.FirstOrDefault();
if (userRole == null)
{
context.SetError("invalid_grant", "The user is inactive (no rules assigned). Contact administrator.");
return;
}
role = identityManager.GetRoleById(userRole.RoleId);
// check wvc user active;
wvcUser = wvcUserManager.FindUser(user.Id);
if (wvcUser == null)
{
context.SetError("invalid_grant", "The user is inactive. Contact administrator.");
return;
}
}
// Add claims
ClaimsIdentity oAuthIdentity = await userManager.CreateIdentityAsync(user, context.Options.AuthenticationType);
oAuthIdentity.AddClaim(new Claim(Authentication.IDKey, wvcUser.id.ToString()));
oAuthIdentity.AddClaim(new Claim(Authentication.RoleKey, role.Name));
ClaimsIdentity cookiesIdentity = await userManager.CreateIdentityAsync(user, CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = CreateProperties(user, role, wvcUser);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties);
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(cookiesIdentity);
}
}
public async Task GetAppointmentRequestsForTrainerShouldNotThrow()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var appointmentsRepository = new EfDeletableEntityRepository <Appointment>(db);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(db);
var notificationsService = new Mock <INotificationsService>();
var service = new AppointmentsService(
appointmentsRepository,
usersRepository,
notificationsService.Object);
var client = new ApplicationUser();
var trainer = new ApplicationUser();
var role = new ApplicationRole(GlobalConstants.TrainerRoleName);
var identityRole = new IdentityUserRole <string>()
{
RoleId = role.Id,
UserId = trainer.Id,
};
trainer.Roles.Add(identityRole);
await usersRepository.AddAsync(trainer);
await usersRepository.AddAsync(client);
await usersRepository.SaveChangesAsync();
var inputModel = new AddAppointmentInputModel()
{
StartTime = DateTime.UtcNow,
EndTime = DateTime.UtcNow.AddDays(2),
ClientId = client.Id,
TrainerId = trainer.Id,
IsApproved = true,
Notes = "Plamen",
Type = AppointmentType.Consultation,
};
var appointment = await service.AddAppoinmentAsync(inputModel);
var result = await service.GetAppointmentRequestsForTrainer <TestAppointmentModel>(trainer.Id);
Assert.Empty(result);
}
public async Task <IHttpActionResult> Register(VozacBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//string[] s = Roles.GetAllRoles();
Polovi p; Enum.TryParse(model.Pol, out p);
TipoviAutomobila t; Enum.TryParse(model.TipAutomobila, out t);
Automobil automobil = new Automobil(int.Parse(model.BrojTaksiVozila), int.Parse(model.GodisteAutomobila), model.KorisnickoIme, model.BrojRegistarskeOznake, t);
DataBase.automobili.Add(automobil.BrojTaksiVozila, automobil);
Vozac m = new Vozac()
{
KorisnickoIme = model.KorisnickoIme,
Ime = model.Ime,
Prezime = model.Prezime,
Lozinka = model.Password,
Pol = p,
Jmbg = model.Jmbg,
KontaktTelefon = model.KontaktTelefon,
Email = model.Email,
Uloga = Uloge.Vozac,
VoznjeID = new List <int>(),
AutomobilID = automobil.BrojTaksiVozila
};
DataBase.Korisnici.Add(m.KorisnickoIme, m);
var user = new ApplicationUser()
{
UserName = m.KorisnickoIme, Email = m.Email, PhoneNumber = m.KontaktTelefon
};
IdentityUserRole r = new IdentityUserRole();
r.UserId = user.Id;
r.RoleId = "2";
user.Roles.Add(r);
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task SeedAsync(ApplicationDbContext ctx)
{
if (ctx.Users.Any())
{
return;
}
var roles = GetDefaultRoles();
ctx.Roles.AddRange(roles);
await ctx.SaveChangesAsync();
var position = new Position
{
Name = SystemPositions.LABOR_SAFETY_OFFICER,
IsSystem = false
};
ctx.Positions.Add(position);
await ctx.SaveChangesAsync();
var user = new User
{
Id = "308872d9-b307-490b-97f5-cae0e1766bfd",
UserName = "******",
NormalizedUserName = "******",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
FirstName = "Admin",
LastName = "Pcholka",
PositionId = position.Id,
SecurityStamp = Guid.NewGuid().ToString("D")
};
user.PasswordHash = _hasher.HashPassword(user, "admin");
ctx.Users.Add(user);
await ctx.SaveChangesAsync();
var userRole = new IdentityUserRole <string>
{
UserId = user.Id,
RoleId = ctx.Roles.Single(x => x.Name == Roles.ADMIN).Id
};
ctx.UserRoles.Add(userRole);
await ctx.SaveChangesAsync();
}
private void SeedDb()
{
this.TruncateRolesTable();
this.TruncateUserRolesTable();
this.TruncateUsersTable();
var user = new ForumUser {
Id = TestsConstants.TestId, UserName = TestsConstants.TestUsername1
};
var secondUser = new ForumUser {
Id = TestsConstants.TestId1, UserName = TestsConstants.TestUsername2
};
var thirdUser = new ForumUser {
Id = TestsConstants.TestId2, UserName = TestsConstants.TestUsername3
};
this.dbService.DbContext.Users.Add(user);
this.dbService.DbContext.Users.Add(secondUser);
this.dbService.DbContext.Users.Add(thirdUser);
this.dbService.DbContext.SaveChanges();
var ownerRole = new IdentityRole {
Id = TestsConstants.TestId1, Name = Common.Role.Owner
};
var adminRole = new IdentityRole {
Id = TestsConstants.TestId2, Name = Common.Role.Administrator
};
var userRole = new IdentityRole {
Id = TestsConstants.TestId3, Name = Common.Role.User
};
this.dbService.DbContext.Roles.Add(ownerRole);
this.dbService.DbContext.Roles.Add(adminRole);
this.dbService.DbContext.Roles.Add(userRole);
this.dbService.DbContext.SaveChanges();
for (int i = 0; i < this.dbService.DbContext.Users.Count(); i++)
{
var currentRoleId = this.dbService.DbContext.Roles.ToList()[i].Id;
var currentuserId = this.dbService.DbContext.Users.ToList()[i].Id;
var newUserRole = new IdentityUserRole <string> {
RoleId = currentRoleId, UserId = currentuserId
};
this.dbService.DbContext.UserRoles.Add(newUserRole);
this.dbService.DbContext.SaveChanges();
}
}
internal static void AddRoleToUser(OnlineStoreDbContext dbContext, User user, IdentityRole role)
{
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.SaveChanges();
var dbUserRole = new IdentityUserRole <string>()
{
UserId = user.Id,
RoleId = role.Id
};
dbContext.UserRoles.Add(dbUserRole);
dbContext.SaveChanges();
}
public void Configure(EntityTypeBuilder <IdentityUserRole <string> > builder)
{
IdentityUserRole <string> iur = new IdentityUserRole <string>
{
RoleId = Constants.AdminRoleId,
UserId = Constants.AdminUserId
};
IdentityUserRole <string> vur = new IdentityUserRole <string>
{
RoleId = Constants.VisitorRoleId,
UserId = Constants.VisitorUserId
};
builder.HasData(iur, vur);
}
public void Configure(EntityTypeBuilder <IdentityUserRole <Guid> > builder)
{
IdentityUserRole <Guid> adminInRole = new IdentityUserRole <Guid>
{
RoleId = RoleConfiguration.administratorRoleId,
UserId = UsersSeedConfiguration.adminId
};
IdentityUserRole <Guid> managerInRole = new IdentityUserRole <Guid>
{
RoleId = RoleConfiguration.managerRoleId,
UserId = UsersSeedConfiguration.managerId
};
builder.HasData(adminInRole, managerInRole);
}
public static bool IsRole(IdentityUserRole userRole, RoleId roleId)
{
if (userRole.RoleId == null)
{
return(false);
}
var currRole = (RoleId)Enum.Parse(typeof(RoleId), userRole.RoleId);
if (currRole == roleId)
{
return(true);
}
return(true);
}
public IActionResult Remove(RoleDTO role)
{
if (this.User != null && this.User.Identity.IsAuthenticated)
{
IdentityUserRole <int> userRole = new IdentityUserRole <int>()
{
RoleId = role.RoleId,
UserId = role.UserId
};
this.context.UserRoles.Remove(userRole);
this.context.SaveChanges();
}
return(RedirectToAction(nameof(Index)));
}
private void AddUserToRole(TARUser tARUser, string RoleName)
{
using (var scope = new TransactionScope())
{
IdentityUserRole userRole = new IdentityUserRole();
string roleid = _unitOfWork.RoleRepository.GetFirst(m => m.Name == RoleName)?.Id;
userRole.RoleId = roleid;
userRole.UserId = tARUser.Id;
if (!tARUser.Roles.Any(m => m.RoleId == roleid))
{
tARUser.Roles.Add(userRole);
}
_unitOfWork.Save();
scope.Complete();
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
ApplicationDbContext db = new ApplicationDbContext();
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email,
Ime = Input.Ime, Prezime = Input.Prezime, DatumRodjenja = Input.DatumRodjenja,
Adresa = Input.Adresa, brojTelefona = Input.brojTelefona, GradID = Input.GradID
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
var userRole = new IdentityUserRole <int>();
userRole.UserId = user.Id;
userRole.RoleId = 2;
db.UserRoles.Add(userRole);
db.SaveChanges();
db.Dispose();
_logger.LogInformation("User created a new account with password.");
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { userId = user.Id, code = code },
// protocol: Request.Scheme);
//await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
// $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public IHttpActionResult AddRole(string username, RoleBindingModel roleBinding)
{
var user = this.Data.Users.Read().FirstOrDefault(u => u.UserName == username);
if (user == null)
{
return this.NotFound();
}
if (roleBinding == null)
{
return this.BadRequest("Role is null.");
}
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var role = this.Data.Roles.Read().FirstOrDefault(r => r.Name == roleBinding.Name);
if (role == null)
{
role = new IdentityRole
{
Name = roleBinding.Name
};
this.Data.Roles.Create(role);
this.Data.SaveChanges();
}
var userRole = role.Users.FirstOrDefault(r => r.UserId == user.Id);
if (userRole == null)
{
userRole = new IdentityUserRole
{
UserId = user.Id,
RoleId = role.Id
};
role.Users.Add(userRole);
}
this.Data.SaveChanges();
return this.Ok();
}
public IHttpActionResult AddRole(string username, IdentityRole roleToAdd)
{
string loggedUserId = this.userIdProvider.GetUserId();
var existingUser = this.data
.Users
.All()
.FirstOrDefault(u => u.UserName == username);
if (existingUser == null)
{
return this.BadRequest("User does not exist - invalid username.");
}
var loggedUser = this.data.Users.Find(loggedUserId);
if (loggedUser == null)
{
return this.BadRequest("Invalid session token.");
}
var role = this.data
.Roles
.All()
.FirstOrDefault(r => r.Name == roleToAdd.Name);
if (role == null)
{
role = new IdentityRole
{
Name = roleToAdd.Name
};
this.data.Roles.Add(role);
}
IdentityUserRole userRole = new IdentityUserRole
{
UserId = existingUser.Id,
RoleId = role.Id
};
existingUser.Roles.Add(userRole);
this.data.Save();
return this.Ok();
}
// GET: Users/Delete/5
public ActionResult Delete(string id,string username)
{
var user = db.Users.Where(r => r.UserName.Equals(username)).FirstOrDefault();
var role = db.Roles.Where(r => r.Name.Equals(id)).FirstOrDefault();
var userRole = new IdentityUserRole();
foreach(IdentityUserRole tempIdRole in user.Roles)
{
if(tempIdRole.RoleId == role.Id)
{
userRole = tempIdRole;
break;
}
}
user.Roles.Remove(userRole);
db.SaveChanges();
ViewBag.ResultMessage = "User Deleted";
return View("Index", db.Users.ToList());
}
protected void CreateUser_Click(object sender, EventArgs e)
{
var manager = Context.GetOwinContext().GetUserManager<ApplicationUserManager>();
var signInManager = Context.GetOwinContext().Get<ApplicationSignInManager>();
var user = new User() { UserName = Email.Text, Email = Email.Text, FirstName = FirstName.Text, LastName = LastName.Text, Country = Country.Text, About = About.Text };
var role = this.Data.Roles.FirstOrDefault(x => x.Name == "User");
var userRole = new IdentityUserRole() { RoleId = role.Id, UserId = user.Id };
user.Roles.Add(userRole);
IdentityResult result = manager.Create(user, Password.Text);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
//string code = manager.GenerateEmailConfirmationToken(user.Id);
//string callbackUrl = IdentityHelper.GetUserConfirmationRedirectUrl(code, user.Id, Request);
//manager.SendEmail(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>.");
signInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
IdentityHelper.RedirectToReturnUrl(Request.QueryString["ReturnUrl"], Response);
}
else
{
ErrorMessage.Text = result.Errors.FirstOrDefault();
}
}
public ActionResult Update(string Role_Id, string User_Id)
{
var user = db.Users.Find(User_Id);
try
{
var userRole = user.Roles.Single(p => p.RoleId == Role_Id);
user.Roles.Remove(userRole);
return Content("Remove");
}
catch
{
var userRole = new IdentityUserRole
{
RoleId = Role_Id,
UserId = User_Id
};
user.Roles.Add(userRole);
return Content("Add");
}
finally
{
db.SaveChanges();
}
}
/// <summary>
/// Método para agregar un usuario a un rol
/// </summary>
/// <param name="nombreRol"></param>
/// <param name="userName"></param>
/// <param name="mensaje"></param>
/// <returns>devuelve verdadero si se agrega correctamente y falso si existen algún tipo de error.
/// Si existe algún error, el error queda registrado en el mensaje.</returns>
public bool AgregarUsuarioARol(string nombreRol, string userName, out string mensaje)
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
IdentityUser usuario = db.Users.Where(x => x.UserName == userName).FirstOrDefault();
if (usuario == null)
{
mensaje = "No se ha encontrado el usuario";
db.Dispose();
return false;
}
IdentityRole rol = db.Roles.Where(x => x.Name == nombreRol).FirstOrDefault();
if (rol == null)
{
mensaje = "No se ha encontrado el rol";
db.Dispose();
return false;
}
IdentityUserRole<string> usuarioRol = new IdentityUserRole<string>
{
RoleId = rol.Id,
UserId = usuario.Id
};
db.UserRoles.Add(usuarioRol);
db.SaveChanges();
mensaje = "Operación realizada con éxito";
db.Dispose();
return true;
}
}
public RoleView( IdentityUserRole Role )
: base(Guid.Parse( Role.RoleId ))
{
this.Name = Role.Role.Name;
}
public async Task<ActionResult> Edit([Bind(Include = "UserName,Email,Id")]EditUserRoleViewModel editUser, params string[] selectedRole)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(editUser.Id);
if (user == null)
{
return HttpNotFound();
}
//不允许修改用户名
user.Email = editUser.Email;
//更新用户信息
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return View();
}
//更新角色
//删除现有角色
var userRoles = user.Roles.ToList();
userRoles.ForEach(t => _db.Set<IdentityUserRole>().Remove(t));
//添加所选角色
selectedRole = selectedRole ?? new string[] { };
selectedRole.Each(roleId =>
{
var userRole = new IdentityUserRole { RoleId = roleId, UserId = user.Id };
_db.Set<IdentityUserRole>().Add(userRole);
});
_db.SaveChanges();
return RedirectToAction("Index");
}
ModelState.AddModelError("", "操作失败。");
return View();
}
public void StoreSetup()
{
Guid userIdentifier = Guid.NewGuid();
this.fakeUserFromDb = new IdentityUser
{
Id = userIdentifier,
EmailAddress = RandomData.GetEmailAddress(),
PasswordHash =
RandomData.GetString(18, 24, RandomData.StringIncludes.Lowercase | RandomData.StringIncludes.Numbers) + "==",
FirstName = RandomData.GetStringPersonFirstName(),
LastName = RandomData.GetStringPersonLastName(),
IsConfirmed = true,
CreatedDate = RandomData.GetDateTimeInPast(),
SecurityStamp = Guid.NewGuid().ToString("D"),
Logins =
new List<IdentityUserLogin>
{
new IdentityUserLogin
{
LoginProvider = "Yahoo",
ProviderKey = RandomData.GetStringNumber(18),
UserId = userIdentifier
}
},
Roles = new List<IdentityUserRole>(),
Claims =
new List<IdentityUserClaim>
{
new IdentityUserClaim
{
ClaimId = RandomData.GetInteger(1000, 9999),
ClaimType = "FavoriteActress",
ClaimValue = "Sandra Bullock",
UserId = userIdentifier
}
}
};
List<IdentityUser> userList = new List<IdentityUser> { this.fakeUserFromDb };
var role = new IdentityUserRole { RoleId = RandomData.GetInteger(1000, 9999), RoleName = RandomData.GetStringWord(), Users = userList };
this.fakeUserFromDb.Roles.Add(role);
this.dbHelperMock = new Mock<ISecurityDataHelper>();
this.dbHelperMock.Setup(mock => mock.GetUserAggregate(It.IsAny<Expression<Func<IdentityUser, bool>>>()))
.Returns<Expression<Func<IdentityUser, bool>>>(predicate => userList.FirstOrDefault(predicate.Compile()));
this.dbHelperMock.Setup(mock => mock.GetById<IdentityUser, Guid>(It.IsAny<Guid>())).Returns((Guid userId) => userList.FirstOrDefault(u => u.Id == userId));
this.store = new IdentityStore<ApplicationUser>(this.dbHelperMock.Object);
}
public ActionResult Create(UserViewModel user)
{
if (ModelState.IsValid)
{
var hasher = new PasswordHasher();
var hashedPassword = hasher.HashPassword(user.PasswordHash);
var newUser = new User()
{
UserName = user.UserName,
Email = user.Email,
EmailConfirmed = false,
PasswordHash = hashedPassword,
SecurityStamp = Guid.NewGuid().ToString(),
PhoneNumber = user.PhoneNumber,
PhoneNumberConfirmed = false,
TwoFactorEnabled = user.TwoFactorEnabled,
LockoutEnabled = true,
IsAdmin = user.IsAdmin,
ProtopopiateId = user.ProtopopiateId
};
if (newUser.IsAdmin)
{
var roleId = this.Data.IdentityRoles
.All()
.FirstOrDefault(r => r.Name == "Admin")
.Id;
var identityUserRole = new IdentityUserRole()
{
RoleId = roleId,
UserId = newUser.Id
};
this.Data.IdentityUserRoles.Add(identityUserRole);
}
this.Data.Users.Add(newUser);
this.Data.SaveChanges();
return RedirectToAction("Index");
}
return View(user);
}
public ActionResult Edit(UserViewModel user)
{
if (ModelState.IsValid)
{
var userFromDb = this.Data.Users
.All()
.FirstOrDefault(u => u.Id == user.Id);
if (userFromDb.IsAdmin != user.IsAdmin)
{
userFromDb.IsAdmin = user.IsAdmin;
var roleId = this.Data.IdentityRoles
.All()
.FirstOrDefault(r => r.Name == "Admin")
.Id;
if (user.IsAdmin)
{
var identityUserRole = new IdentityUserRole()
{
RoleId = roleId,
UserId = userFromDb.Id
};
this.Data.IdentityUserRoles.Add(identityUserRole);
}
else
{
var identityUserRoles = this.Data.IdentityUserRoles
.All()
.FirstOrDefault(r => r.RoleId == roleId && r.UserId == userFromDb.Id);
this.Data.IdentityUserRoles.Delete(identityUserRoles);
}
}
userFromDb.UserName = user.UserName;
userFromDb.Email = user.Email;
userFromDb.PhoneNumber = user.PhoneNumber;
userFromDb.ProtopopiateId = user.ProtopopiateId;
if (user.PasswordHash != "")
{
var hasher = new PasswordHasher();
var hashedPassword = hasher.HashPassword(user.PasswordHash);
userFromDb.PasswordHash = hashedPassword;
}
this.Data.SaveChanges();
return RedirectToAction("Index");
}
return View(user);
}
public static bool IsInRole(this IPrincipal principal, IdentityUserRole role)
{
return ClaimsUtility.GetCurrentUserRoles().Any(p => (IdentityUserRole)p == role);
}
public async Task<ActionResult> Register(RegisterViewModel model, string Rol,string area)
{
EntitiesLogueo db;
if (ModelState.IsValid)
{
db = new EntitiesLogueo();
var user = new ApplicationUser { UserName = model.UserName, Email = model.Email ,PhoneNumber = area };
IdentityUserRole iur = new IdentityUserRole();
iur.RoleId = Rol;
iur.UserId = user.Id;
user.Roles.Add(iur);
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
db = new EntitiesLogueo();
ViewBag.Rol = new SelectList(db.AspNetRoles, "Id", "Name");
GProyEntities bd = new GProyEntities();
ViewBag.area = new SelectList(bd.Area.Select(a => a.name).ToList());
// If we got this far, something failed, redisplay form
return View(model);
}
public bool IsUserInRole(string name, IdentityUserRole role)
{
var roles = getUserRoles(name);
return roles.SingleOrDefault(r => r.RoleId == role.RoleId) != null;
}
public IdentityUserRoleWrapper(IdentityUserRole role)
{
this.RoleId = role.RoleId;
this.UserId = role.UserId;
}
public ActionResult Edit([Bind(Include = "Id,Name,Lastname,Email,UserName,Roles,SkypeName")] ApplicationUser user, string roleId)
{
var roles = db.Users.Where(r => r.Id == user.Id).Select(r => r.Roles).ToList();
var role1 = roles.ElementAt(0);
var role2 = role1.ElementAt(0);
var role = role2.RoleId;
var currentRoleName = db.Roles.Where(r => r.Id == role).SingleOrDefault().Name;
var newRoleName = db.Roles.Where(r => r.Id == roleId).SingleOrDefault().Name;
if (currentRoleName == "Student")
{
ViewBag.RoleId = new SelectList(db.Roles.Where(x => x.Name == "Student"), "Id", "Name");
}
if (currentRoleName == "Admin")
{
ViewBag.RoleId = new SelectList(db.Roles.Where(x => x.Name == "Admin"), "Id", "Name");
}
if (currentRoleName == "Mentor" || currentRoleName == "Teacher")
{
ViewBag.RoleId = new SelectList(db.Roles.Where(x => x.Name == "Mentor" || x.Name == "Teacher"), "Id", "Name");
}
if (!CustomUserManager.CanChangeToRole(currentRoleName,newRoleName))
{
return View(user);
}
if (ModelState.IsValid)
{
var toSave = db.Users.Find(user.Id);
toSave.Name = user.Name;
toSave.Lastname = user.Lastname;
toSave.Email = user.Email;
toSave.SkypeName = user.SkypeName;
toSave.Roles.Clear();
//ovu "najbolju validaciju ikad" mijenjat u svakom slucaju, sad za sad neka stoji
if (String.IsNullOrWhiteSpace(toSave.Email))
return Redirect("Edit?userId=" + user.Id);
if (toSave.Email.Contains(" "))
return Redirect("Edit?userId=" + user.Id);
if(toSave.Email.StartsWith("@bitcamp.ba"))
return Redirect("Edit?userId=" + user.Id);
int count = toSave.Email.Split('@').Length;
string userID = db.Users.Find(user.Id).ToString();
if (count > 2 || toSave.Email.EndsWith("@bitcamp.ba") == false || String.IsNullOrWhiteSpace(toSave.Name) || String.IsNullOrWhiteSpace(toSave.Lastname))
{
return Redirect("Edit?userId=" + user.Id);
}
IdentityUserRole newRole = new IdentityUserRole();
newRole.RoleId = roleId;
newRole.UserId = toSave.Id;
toSave.Roles.Add(newRole);
db.Entry(toSave).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
return View(user);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
var userRole = new IdentityUserRole() {RoleId=Convert.ToString((int)ViewModels.Enums.Role.Customer),UserId=user.Id };
var cart = new Cart { CartItems = new List<CartItem>()};
var myUser = new User { Email = user.Email,Cart=cart };
myContext.Entry(cart).State = System.Data.Entity.EntityState.Added;
myContext.Carts.Add(cart);
db.Entry(userRole).State = System.Data.Entity.EntityState.Added;
user.Roles.Add(userRole);
myContext.Users.Add(myUser);
myContext.Entry(myUser).State = System.Data.Entity.EntityState.Added;
myContext.SaveChanges();
db.SaveChanges();
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
private IdentityUserRole PopulateRoleFromDataReader(SqlDataReader dr)
{
IdentityUserRole role = new IdentityUserRole();
if (dr["RoleID"] != DBNull.Value)
{
role.RoleId = dr["RoleID"].ToString();
}
return role;
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User { UserName = model.UserName, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var dbContext = new Issues.Data.IssuesDbContext();
var role = user.UserName == "root" ? "Admin" : "Regular";
var newRole = dbContext.Roles.FirstOrDefault(r => r.Name == role);
if(newRole == null)
{
newRole = new IdentityRole(role);
dbContext.Roles.Add(newRole);
dbContext.SaveChanges();
}
var identityUserRole = new IdentityUserRole();
identityUserRole.UserId = user.Id;
identityUserRole.RoleId = newRole.Id;
newRole.Users.Add(identityUserRole);
dbContext.SaveChanges();
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
public ActionResult Kullanicilar(string Users, string RolList)
{
var role = new IdentityUserRole
{
RoleId = RolList,
UserId = Users
};
if (role != null)
{
db.UserRoles.Add(role);
db.SaveChanges();
}
ViewBag.RolList = new SelectList(db.Roles, "Id", "Name");
ViewBag.Users = new SelectList(db.Users, "Id", "UserName");
return View(db.Users.ToList());
}
//public static bool UserIsInRole(this HttpContext httpContext, string role)
//{
// if (httpContext == null) return false;
// if (httpContext.User == null) return false;
// var res = httpContext.User.IsInRole(role);
// return res;
//}
public static bool UserIsInRole(this HttpContext httpContext, IdentityUserRole role)
{
if (httpContext == null) return false;
if (httpContext.User == null) return false;
var res = (DependencyResolver.Current.GetService<IIdentityManager>()).IsUserInRole(httpContext.User.Identity.Name,role);
return res;
}
public string AddUserRole(string id, string value)
{
UserContext ctx = new UserContext();
ApplicationUser user = ctx.Users.Find(id);
//giver ikke mening endnu
IdentityUserRole role = new IdentityUserRole();
role.RoleId = value;
role.UserId = id;
user.Roles.Add(role);
ctx.SaveChanges();
return "done";
}
public ActionResult Edit(string id, FormCollection collection)
{
try
{
// TODO: Add update logic here
var user = db.Users.Where(r => r.UserName.Equals(id, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
var role = new IdentityRole();
foreach(IdentityUserRole tempUserRole in user.Roles)
{
if(collection["validRoles"] == tempUserRole.RoleId)
{
ViewBag.ResultMessage = "Role already added to the user";
return View("Index", db.Users.ToList());
}
}
foreach (IdentityRole tempRole in db.Roles)
{
if (collection["validRoles"] == tempRole.Id)
{
role = tempRole;
}
}
var idRole = new IdentityUserRole()
{
UserId = user.Id,
RoleId = role.Id
};
user.Roles.Add(idRole);
if (collection["LockoutEnabled"] == "true,false")
{
user.LockoutEnabled = true;
}
else
{
user.LockoutEnabled = false;
}
db.SaveChanges();
return View("Index", db.Users.ToList());
}
catch
{
//ViewBag.ResultMessage = "ERROR";
return View("Index", db.Users.ToList());
}
}
