protected override void Seed(WebApplicationNew.DB.DemoDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data. E.g.
//
// context.People.AddOrUpdate(
// p => p.FullName,
// new Person { FullName = "Andrew Peters" },
// new Person { FullName = "Brice Lambson" },
// new Person { FullName = "Rowan Miller" }
// );
//
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
context.Database.CreateIfNotExists();
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
manager.Create(new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
}, "User111");
var user1 = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(user1.Id, new string[] { "User" });
manager.Create(new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
}, "Admin1");
var admin = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(admin.Id, new string[] { "Admin" });
base.Seed(context);
}
// POST: api/User/Registration
public object Registration([FromBody] RegistrationModel model)
{
if (model != null)
{
var user = new User
{
UserName = model.UserName,
FirstName = model.FirstName,
SecondName = model.SecondName,
LastName = model.LastName,
Password = model.Password,
Email = model.Email,
RegistrationDate = DateTime.UtcNow.ToString()
};
try
{
var isCreated = _userManager.CreateUser(user);
if (!isCreated)
{
return(BadRequest(new { message = "User with such [Email] or [UserName] already exists" }));
}
_userManager.AddToRoles(user.Email, model.Roles.ToList());
return(Ok(_userManager.GetByEmail(user.Email)));
}
catch (Exception e)
{
throw e;
}
}
return(BadRequest(new { message = "Bad model json" }));
}
public IdentityResult Update([FromUri()] string name, [FromUri()] int flag, [FromUri()] string param)
{
var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext()); // because ApplicationDbContext
var manager = new UserManager <ApplicationUser>(userStore); // use the manager to control
var user = manager.FindByName(name); // find the user by username
switch (flag)
{
case 1:
manager.AddToRoles(user.Id, "Admin"); // change the role to Admin
break;
case 2:
manager.AddToRoles(user.Id, "Consumer"); // change the role to Consumer
break;
case 3:
user.FirstName = param;
break;
case 4:
user.LastName = param;
break;
case 5:
manager.PasswordValidator = new PasswordValidator
{
RequiredLength = 3
};
break;
case 6:
user.Email = param;
break;
case 7:
user.UserName = param;
break;
case 8:
//user.Roles.ToArray()[0].RoleId = "2";
//System.Web.Security.Roles.AddUserToRole(name, "Consumer");
if (param.Equals("Admin"))
{
manager.AddToRole(user.Id, "Consumer");
}
else
{
manager.AddToRole(user.Id, "Admin");
}
break;
}
IdentityResult result = manager.Update(user);
return(result);
}
protected override void Seed(examRepeat1617.Models.ApplicationDbContext context)
{
var manager =
new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var roleManager =
new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
roleManager.Create(new IdentityRole {
Name = "Lecturer"
});
roleManager.Create(new IdentityRole {
Name = "StudentRole"
});
context.Users.AddOrUpdate(u => u.Email, new ApplicationUser
{
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = "******",
PasswordHash = new PasswordHasher().HashPassword("Ss1234567$1"),
lecturerId = 1,
SecurityStamp = Guid.NewGuid().ToString(),
});
context.Users.AddOrUpdate(u => u.Email, new ApplicationUser
{
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = "******",
PasswordHash = new PasswordHasher().HashPassword("SS00000001$1"),
studentId = "s0001",
SecurityStamp = Guid.NewGuid().ToString(),
});
context.SaveChanges();
ApplicationUser lecturer = manager.FindByEmail("*****@*****.**");
if (lecturer != null)
{
manager.AddToRoles(lecturer.Id, new string[] { "Lecturer" });
}
else
{
throw new Exception {
Source = "Did not find Lecturer"
};
}
ApplicationUser StudentRole = manager.FindByEmail("*****@*****.**");
if (manager.FindByEmail("*****@*****.**") != null)
{
manager.AddToRoles(StudentRole.Id, new string[] { "StudentRole" });
}
}
protected override void Seed(Portfolio_Blog.Models.ApplicationDbContext context)
{
var roleManager = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Admin"))
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
}
if (!context.Roles.Any(r => r.Name == "Mod"))
{
roleManager.Create(new IdentityRole {
Name = "Mod"
});
}
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Allison",
LastName = "Tsatsa",
DisplayName = "Big Al"
};
userManager.Create(user, "ABC456");
userManager.AddToRoles(user.Id, "Admin");
}
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Drew",
LastName = "Russell",
DisplayName = "Prof"
};
userManager.Create(user, "123456");
userManager.AddToRoles(user.Id, "Mod");
}
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
}
protected override void Seed(WebApplication1.Models.ApplicationDbContext context)
{
var manager =
new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var roleManager =
new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
context.Roles.AddOrUpdate(r => r.Name,
new IdentityRole {
Name = "Librarian"
}
);
context.Roles.AddOrUpdate(r => r.Name,
new IdentityRole {
Name = "Member"
}
);
PasswordHasher ps = new PasswordHasher();
context.Users.AddOrUpdate(u => u.UserName,
new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
DateJoined = DateTime.Now,
SecurityStamp = Guid.NewGuid().ToString(),
PasswordHash = ps.HashPassword("ITSligo$1")
});
context.Users.AddOrUpdate(u => u.UserName,
new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
DateJoined = DateTime.Now,
SecurityStamp = Guid.NewGuid().ToString(),
PasswordHash = ps.HashPassword("ITSligo$2")
});
context.SaveChanges();
//librarian role
ApplicationUser Librarian = manager.FindByEmail("*****@*****.**");
if (Librarian != null)
{
manager.AddToRoles(Librarian.Id, new string[] { "Librarian", "Member" });
}
//member role
ApplicationUser Member = manager.FindByEmail("*****@*****.**");
if (Member != null)
{
manager.AddToRoles(Member.Id, new string[] { "Librarian", "Member" });
}
}
protected override void Seed(bie.evgestao.ui.mvc.Models.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
context.Roles.AddOrUpdate(r => r.Name,
new IdentityRole {
Name = "Secretaria"
},
new IdentityRole {
Name = "Financeiro"
},
new IdentityRole {
Name = "Pastor"
},
new IdentityRole {
Name = "Conselho"
},
new IdentityRole {
Name = "Lider"
},
new IdentityRole {
Name = "Supervisor"
},
new IdentityRole {
Name = "Administrador"
},
new IdentityRole {
Name = "Superadmin"
}
);
#region criarSuperadmin
if (!(context.Users.Any(u => u.UserName == "*****@*****.**")))
{
using (UserStore <ApplicationUser> userStore = new UserStore <ApplicationUser>(context))
{
using (UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(userStore))
{
var userToInsert = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
PhoneNumber = "*****@*****.**",
Nome = "Super Admin",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
userManager.Create(userToInsert, "P@ssw0rd");
userManager.AddToRoles(userToInsert.Id, "Administrador");
userManager.AddToRoles(userToInsert.Id, "Superadmin");
}
}
}
#endregion
}
protected override void Seed(ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
var manager = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(new ApplicationDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Taiseer",
LastName = "Joudeh",
Level = 1,
JoinDate = DateTime.Now.AddYears(-3)
};
manager.Create(user, "MySuperP@ssword!");
//add myself as admin
var admin = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Max",
LastName = "Wu",
Level = 1,
JoinDate = DateTime.Now.AddYears(-2)
};
manager.Create(admin, "123456");
var roleManager = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(new ApplicationDbContext()));
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "SuperAdmin"
});
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByName("SuperPowerUser");
manager.AddToRoles(adminUser.Id, new string[] { "SuperAdmin", "Admin" });
var newAdmin = manager.FindByName("MyAdmin");
manager.AddToRoles(newAdmin.Id, new string[] { "Admin" });
}
protected override void Seed(WebDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new WebDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new WebDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Nguyen Van"
};
manager.Create(user, "123654$");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
var user1 = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Nguyen Van"
};
manager.Create(user1, "123654$");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser1 = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "User" });
}
protected override void Seed(Web.Models.ApplicationDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "Retail"
});
roleManager.Create(new IdentityRole {
Name = "Wholesale"
});
}
// Create Admin user
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(user, "Admin-1234");
var admin = manager.FindByName("*****@*****.**");
manager.AddToRoles(admin.Id, new string[] { "Admin" });
// Create Retail User
var user2 = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(user2, "Retail-1234");
var retail = manager.FindByName("*****@*****.**");
manager.AddToRoles(retail.Id, new string[] { "Retail" });
// Create Wholesale User
var user3 = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(user3, "Wholesale-1234");
var wholesale = manager.FindByName("*****@*****.**");
manager.AddToRoles(wholesale.Id, new string[] { "Wholesale" });
}
protected override void Seed(Logistics.Infrastructures.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "SA"
});
roleManager.Create(new IdentityRole {
Name = "Requestor"
});
roleManager.Create(new IdentityRole {
Name = "Administrator"
});
}
;
var admin = new ApplicationUser
{
PhoneNumber = "+62818271214",
PhoneNumberConfirmed = true,
UserName = "******",
Email = "*****@*****.**",
FullName = "Alex Budiyanto",
Institution = "ACCI",
Title = "CEO"
};
if (manager.FindByName("*****@*****.**") == null)
{
manager.Create(admin, "Volunteer@2020");
manager.AddToRoles(admin.Id, new string[] { "Administrator", "SA" });
}
var user = new ApplicationUser
{
PhoneNumber = "+62818271214",
PhoneNumberConfirmed = true,
UserName = "******",
Email = "*****@*****.**",
FullName = "Alex Budiyanto",
Institution = "ACCI",
Title = "CEO"
};
if (manager.FindByName("*****@*****.**") == null)
{
manager.Create(user, "User@2020");
manager.AddToRoles(user.Id, new string[] { "Requestor" });
}
}
// We're seeding a few test users to test authentication and roles
public static void seedTestUsers(ApplicationDbContext context, UserManager <ApplicationUser> manager)
{
PasswordHasher hasher = new PasswordHasher();
context.Users.AddOrUpdate(new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "mod",
SecondName = "mod",
PasswordHash = hasher.HashPassword("mod$1"),
SecurityStamp = Guid.NewGuid().ToString()
});
context.Users.AddOrUpdate(new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "contributor",
SecondName = "contributor",
PasswordHash = hasher.HashPassword("contributor$1"),
SecurityStamp = Guid.NewGuid().ToString()
});
context.Users.AddOrUpdate(new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "member",
SecondName = "member",
PasswordHash = hasher.HashPassword("member$1"),
SecurityStamp = Guid.NewGuid().ToString()
});
context.SaveChanges();
ApplicationUser contributor = manager.FindByEmail("*****@*****.**");
if (contributor != null)
{
manager.AddToRoles(contributor.Id, new string[] { "Contributor" });
}
ApplicationUser Moderator = manager.FindByEmail("*****@*****.**");
if (Moderator != null)
{
manager.AddToRoles(Moderator.Id, new string[] { "Moderator" });
}
ApplicationUser member = manager.FindByEmail("*****@*****.**");
if (member != null)
{
manager.AddToRoles(member.Id, new string[] { "Member", "Lecturer" });
}
}
protected override void Seed(Falcon_Blog.Models.ApplicationDbContext context)
{
var roleManager = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Admin"))
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
}
if (!context.Roles.Any(r => r.Name == "Moderator"))
{
roleManager.Create(new IdentityRole {
Name = "Moderator"
});
}
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Josh",
LastName = "Casteel",
DisplayName = "Josh Casteel"
};
userManager.Create(user, "Abc&123!");
userManager.AddToRoles(user.Id, "Admin");
}
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Andrew",
LastName = "Russell",
DisplayName = "Andrew Russell"
};
userManager.Create(user, "Abc&123!");
userManager.AddToRoles(user.Id, "Moderator");
}
}
private static void seedUserRoles(string User, string Tech, string Admin, string Root, string User2, string User3, ApplicationDbContext db)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
manager.AddToRole(User, Roles.CUSTOMER);
manager.AddToRoles(Tech, Roles.TECH, Roles.CUSTOMER);
manager.AddToRoles(Admin, Roles.ADMIN, Roles.TECH, Roles.CUSTOMER);
manager.AddToRoles(Root, Roles.ROOT, Roles.ADMIN, Roles.TECH, Roles.CUSTOMER);
manager.AddToRole(User2, Roles.CUSTOMER);
manager.AddToRole(User3, Roles.CUSTOMER);
}
protected override void Seed(AspNetIdentity.WebApi.Infrastructure.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var user001 = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Ashokan",
LastName = "Sivapragasam",
Level = 1,
JoinDate = DateTime.Now.AddYears(-3)
};
manager.Create(user001, "MySuperP@ss!");
var user002 = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "User",
LastName = "002",
Level = 3,
JoinDate = DateTime.Now.AddYears(-3)
};
manager.Create(user002, "MySuperP@ss!");
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "SuperAdmin"
});
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByName(user001.UserName);
manager.AddToRoles(adminUser.Id, new string[] { "SuperAdmin", "Admin" });
var normalUser = manager.FindByName(user002.UserName);
manager.AddToRoles(normalUser.Id, new string[] { "User" });
}
protected override void Seed(Training38.Models.ApplicationDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "Customer"
});
roleManager.Create(new IdentityRole {
Name = "Administrator"
});
}
;
var administrator = new ApplicationUser
{
PhoneNumber = "+62818271214",
PhoneNumberConfirmed = true,
UserName = "******",
Email = "*****@*****.**"
};
if (manager.FindByName("*****@*****.**") == null)
{
manager.Create(administrator, "Training@2020!!");
manager.AddToRoles(administrator.Id, new string[] { "Administrator", "Customer" });
}
var customer = new ApplicationUser
{
PhoneNumber = "+62818111111",
PhoneNumberConfirmed = true,
UserName = "******",
Email = "*****@*****.**"
};
if (manager.FindByName("*****@*****.**") == null)
{
manager.Create(customer, "Customer@2020!!");
manager.AddToRoles(customer.Id, new string[] { "Customer" });
}
//TO:DO
//Buat 2 akun user dengan role Administrator dan Customer
//Implement otorisasi dan role nya di Controller dan Action yang pernah dibuat
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
}
public ActionResult Edit([Bind(Exclude = null)] UserViewModel u)
{
TempData["EditMsg"] = "Edit fail!";
if (ModelState.IsValid)
{
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
//Get user
var edituser = UserManager.FindById(u.Id);
//Get Role id
if (edituser.Roles.Count() == 0)
{
UserManager.AddToRoles(u.Id, u.Role);
goto h;
}
var oldroleid = edituser.Roles.SingleOrDefault().RoleId;
//Get Role Name
var oldrolename = roleManager.Roles.SingleOrDefault(x => x.Id == oldroleid).Name;
// Update it with the values from the view model
if (u.Id != oldrolename && oldrolename != "Admin")
{
UserManager.RemoveFromRole(u.Id, oldrolename);
if (u.Role != null)
{
UserManager.AddToRoles(u.Id, u.Role);
}
}
h:
edituser.UserName = u.UserName;
edituser.Email = u.Email;
edituser.PhoneNumber = u.PhoneNumber;
edituser.LockoutEnabled = u.Lockout;
edituser.LockoutEndDateUtc = u.LockoutEndDate;
edituser.AccessFailedCount = u.AccessFailedCount;
// Apply the changes if any to the db
if (UserManager.Update(edituser).Succeeded)
{
TempData["EditMsg"] = "Edit user success";
}
else
{
TempData["EditMsg"] = "Edit fail!";
}
return(RedirectToAction("Index"));
}
return(View(u));
}
protected override void Seed(UserContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new UserContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new UserContext()));
// tre roller oprettes
roleManager.Create(new IdentityRole {
Name = "Desk"
});
roleManager.Create(new IdentityRole {
Name = "Librarian"
});
roleManager.Create(new IdentityRole {
Name = "Administrator"
});
// Databasen seedes med 2 brugere
var user1 = new ApplicationUser()
{
UserName = "******",
Email = null,
EmailConfirmed = true,
FirstName = "Nikolaj",
LastName = "Strands",
JoinDate = DateTime.Now.AddYears(-3),
LastLogin = DateTime.Now
};
manager.Create(user1, "123456");
var adminUser = manager.FindByName("admin");
manager.AddToRoles(adminUser.Id, new string[] { "Administrator" });
var user2 = new ApplicationUser()
{
UserName = "******",
Email = null,
EmailConfirmed = true,
FirstName = "Test",
LastName = "Testesen",
JoinDate = DateTime.Now.AddYears(-2),
LastLogin = DateTime.Now
};
manager.Create(user2, "123456");
var deskUser = manager.FindByName("nikolajstrands");
manager.AddToRoles(deskUser.Id, new string[] { "Desk" });
}
protected override void Seed(WebSchedule.Infrastructure.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var admin = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
var teacher = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
var student = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "Teacher"
});
roleManager.Create(new IdentityRole {
Name = "Student"
});
}
manager.Create(admin, "1234567890");
manager.Create(teacher, "1234567890");
manager.Create(student, "1234567890");
var adminUser = manager.FindByName("Admin");
var teacherUser = manager.FindByName("Teacher");
var studentUser = manager.FindByName("Student");
manager.AddToRoles(adminUser.Id, new string[] { "Admin" });
manager.AddToRoles(teacherUser.Id, new string[] { "Teacher" });
manager.AddToRoles(studentUser.Id, new string[] { "Student" });
}
private static void SeedUsers(ApplicationDbContext contex)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(contex));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(contex));
var marty = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(marty, "bobcat_01");
var julie = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(julie, "bobcat_01");
var peter = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true
};
manager.Create(peter, "bobcat_01");
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var admin = manager.FindByName("Admin");
var userJulie = manager.FindByName("Julie");
var userPeter = manager.FindByName("Peter");
manager.AddToRoles(admin.Id, new string[] { "Admin", "User" });
manager.AddToRoles(userJulie.Id, new string[] { "User" });
manager.AddToRoles(userPeter.Id, new string[] { "User" });
}
protected override void Seed(Quản_Lý_Coffee.Models.QuanLyCoffeeDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new QuanLyCoffeeDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new QuanLyCoffeeDbContext()));
var user = new Models.ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
};
manager.Create(user, "Hieu1122");
var user1 = new Models.ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
};
manager.Create(user1, "Hieu1122");
if (roleManager.Roles.Count() == 0)
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "Mod"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByName("Admin_Manager");
manager.AddToRoles(adminUser.Id, new string[] { "Mod", "Admin" });
var adminUser1 = manager.FindByName("XuanHieu");
manager.AddToRoles(adminUser.Id, new string[] { "Mod" });
}
protected override void Seed(ApplicationDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
DateOfBirth = new DateTime(1987, 12, 13),
Fitness = FitnessType.OnceAWeek,
Job = JobTypes.Easy,
Gender = GenderType.Male
};
manager.Create(user, "Test1234");
user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
DateOfBirth = new DateTime(1993, 7, 4),
Fitness = FitnessType.HighPerformanceAthletes,
Job = JobTypes.Easy,
Gender = GenderType.Male
};
manager.Create(user, "Test1234");
// Added Roles
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var stefan = manager.FindByName("Stefan");
var kevin = manager.FindByName("Kevin");
manager.AddToRoles(stefan.Id, "User", "Admin");
manager.AddToRoles(kevin.Id, "User", "Admin");
}
private static void seedUserRoles(string Admin, string User, ApplicationDbContext db)
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
manager.AddToRoles(Admin, Roles.ADMIN);
manager.AddToRole(User, Roles.USER);
}
/// <summary>
/// Adds user to a AspNetRole and all other roles that are lower in the Roles Enum hierarchy
/// </summary>
/// <param name="user">Application User</param>
/// <param name="role">Roles enum role</param>
public static void AddUserToRole(ApplicationUser user, Roles role)
{
var context = new ApplicationDbContext();
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
List<string> roles = new List<string>();
if (roleManager.RoleExists(role.ToString()))
{
//ascertain level, add to this role and every role beneath it
int level = (int)role;
foreach (Roles roleVal in Enum.GetValues(typeof(Roles)))
{
if ((int)roleVal >= level)
{
roles.Add(roleVal.ToString());
}
}
UserManager.AddToRoles(user.Id, roles.ToArray());
}
else
{
throw new Exception("Role does not exist");
}
}
public void Seed(ApplicationDbContext context)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (!context.Users.Any(u => u.UserName == "IvkoBivko"))
{
var user = new ApplicationUser
{
Email = "*****@*****.**",
UserName = "******",
CreatedOn = DateTime.Now
};
userManager.Create(user, "123456");
userManager.AddToRoles(
user.Id,
ApplicationRoles.Admin,
ApplicationRoles.Artist,
ApplicationRoles.Designer,
ApplicationRoles.Regular,
ApplicationRoles.Seller,
ApplicationRoles.Student,
ApplicationRoles.Trainer);
}
}
private void CreateUser(TeduShopDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new TeduShopDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new TeduShopDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Technology Education"
};
if (manager.Users.Count(x => x.UserName == "tedu") == 0)
{
manager.Create(user, "123654$");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
}
}
protected override void Seed(ApplicationDbContext context)
{
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var roleNames = new[] { Role.Admin, Role.Editor };
foreach (var roleName in roleNames)
{
if (context.Roles.Any(r => r.Name == roleName))
{
continue;
}
// Create role
var role = new IdentityRole {
Name = roleName
};
var result = roleManager.Create(role);
if (!result.Succeeded)
{
throw new Exception(string.Join("\n", result.Errors));
}
}
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
var emails = new[] { "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**" };
foreach (var email in emails)
{
if (context.Users.Any(u => u.UserName == email))
{
continue;
}
// Create user
var user = new ApplicationUser {
UserName = email, Email = email
};
var result = userManager.Create(user, "foobar");
if (!result.Succeeded)
{
throw new Exception(string.Join("\n", result.Errors));
}
}
var adminUser = userManager.FindByName("*****@*****.**");
userManager.AddToRole(adminUser.Id, Role.Admin);
var editorUser = userManager.FindByName("*****@*****.**");
userManager.AddToRole(editorUser.Id, Role.Editor);
var dimitris = userManager.FindByName("*****@*****.**");
userManager.AddToRoles(dimitris.Id, Role.Admin, Role.Editor);
}
private void CreateUser(ShopBackDbContext context)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ShopBackDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ShopBackDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Trinh Duc Hoang Anh"
};
if (manager.Users.Count(x => x.UserName == "hoanganh") == 0)
{
manager.Create(user, "123123");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
}
}
protected override void Seed(TeduShop.Data.TeduShopDbContext context)
{
CreateProductCategorySample(context);
// This method will be called after migrating to the latest version.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new TeduShopDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new TeduShopDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Technology Education"
};
manager.Create(user, "123654$");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
}
private void CreateUser(HLShopDbContext context)
{
if (!context.Users.Any())
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new HLShopDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new HLShopDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
Fullname = "Nguyen Huu Lam"
};
manager.Create(user, "1234564$");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
}
}
protected override void Seed(OnlineShop.Data.OnlineShopDbContext context)
{
CreateProductCategorySample(context);
// This method will be called after migrating to the latest version.
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new OnlineShopDbContext()));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new OnlineShopDbContext()));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDay = DateTime.Now,
FullName = "Hung doan Software"
};
manager.Create(user, "123456");
if (!roleManager.Roles.Any())
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
roleManager.Create(new IdentityRole {
Name = "User"
});
}
var adminUser = manager.FindByEmail("*****@*****.**");
manager.AddToRoles(adminUser.Id, new string[] { "Admin", "User" });
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
}
public async Task <IHttpActionResult> CreateUser(string tenant, AnonymousAdmin aUser)
{
if (ModelState.IsValid)
{
var user = new Users()
{
Email = aUser.Email,
FirstName = aUser.FirstName,
LastName = aUser.LastName,
PasswordHash = aUser.Password,
Organization = tenant,
UserName = aUser.Email
};
IdentityResult addUserResult = await this.userManager.CreateAsync(user, aUser.Password);
if (addUserResult.Succeeded)
{
var manager = new UserManager <Users>(new UserStore <Users>(new TaskManagerContext()));
manager.AddToRoles(user.Id, new string[] { "Admin" });
return(Created(new Uri(Url.Link("GetRegdUser", new { id = user.Id })), new { Message = "Admin has been registered successfully" }));
}
else
{
return(GetErrorResult(addUserResult));
}
}
else
{
return(BadRequest(ModelState));
}
}
public IdentityResult Register(AccountModel model)
{
var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext());
var manager = new UserManager <ApplicationUser>(userStore);
var user = new ApplicationUser()
{
UserName = model.UserName, Email = model.Email
};
manager.PasswordValidator = new PasswordValidator
{
RequiredLength = 3
};
IdentityResult result = manager.Create(user, model.Password);
if (result.Succeeded != false)
{
manager.AddToRoles(user.Id, model.Role);
var modifiedUser = new ModifiedUser()
{
UserName = model.UserName,
Email = model.Email,
Role = model.Role,
DateTime = model.DateTime
};
_context.ModifiedUsers.Add(modifiedUser);
_context.SaveChanges();
}
return(result);
}
public ActionResult Create([Bind(Include = "FirstName,LastName,Email,PhoneNumber,UserName")] ApplicationUser applicationUser)
{
if (ModelState.IsValid)
{
var userStore = new UserStore<ApplicationUser>(db);
var userManager = new UserManager<ApplicationUser>(userStore);
var user = userManager.FindByName(applicationUser.UserName);
if (user == null)
{
userManager.Create(applicationUser);
userManager.SetLockoutEnabled(applicationUser.Id, false);
userManager.AddToRoles(applicationUser.Id, Request["Role"]);
return RedirectToAction("Index");
}
}
return View(applicationUser);
}
private static void seedUserRoles(string User, string Tech, string Admin, string Root, string User2, string User3, ApplicationDbContext db)
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
manager.AddToRole(User, Roles.CUSTOMER);
manager.AddToRoles(Tech, Roles.TECH, Roles.CUSTOMER);
manager.AddToRoles(Admin, Roles.ADMIN, Roles.TECH, Roles.CUSTOMER);
manager.AddToRoles(Root, Roles.ROOT, Roles.ADMIN, Roles.TECH, Roles.CUSTOMER);
manager.AddToRole(User2, Roles.CUSTOMER);
manager.AddToRole(User3, Roles.CUSTOMER);
}
public async Task<IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var createUser = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
var user = new ApplicationUser()
{
UserName = createUserModel.Username,
Email = createUserModel.Email,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
Level = 3,
JoinDate = DateTime.Now.Date,
};
IdentityResult addUserResult = await this.AppUserManager.CreateAsync(user, createUserModel.Password);
if (!addUserResult.Succeeded)
{
return GetErrorResult(addUserResult);
}
string code = await this.AppUserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code = code }));
await this.AppUserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
var adminUser = createUser.FindByName(user.UserName);
createUser.AddToRoles(adminUser.Id, new string[] { "User" });
return Created(locationHeader, TheModelFactory.Create(user));
}
public ActionResult Edit([Bind(Include = "FirstName,LastName,Email,PhoneNumber,UserName")] ApplicationUser applicationUser)
{
if (ModelState.IsValid)
{
var userStore = new UserStore<ApplicationUser>(db);
var userManager = new UserManager<ApplicationUser>(userStore);
string userId = userManager.FindByName(applicationUser.UserName).Id;
userManager.RemoveFromRoles(userId, userManager.GetRoles(userId).ToArray());
userManager.AddToRoles(userId, Request["Role"].Split(','));
userManager.Update(applicationUser);
return RedirectToAction("Index");
}
return View(applicationUser);
}
