public static async Task<IdentityResult> AddUserToRole(string userId, string roleName)
{
var userManager = new UserManager<PlatformUser>(
new UserStore<PlatformUser>(new PlatformUserIdentityDbContext()));
//Allows for use of email address as username:
userManager.UserValidator = new UserValidator<PlatformUser>(userManager) { AllowOnlyAlphanumericUserNames = false };
var result = await userManager.AddToRoleAsync(userId, roleName);
return result;
}
public ActionResult Promote(string id)
{
var store = new UserStore<User>(this.Data.Context);
var manager = new UserManager<User>(store);
manager.AddToRoleAsync(id, GlobalConstants.AdminRole);
this.Notify(GlobalConstants.PromoteUser, NotificationType.success);
return this.RedirectToAction("Manage");
}
public async Task ClaimsIdentityTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var role = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
var user = new IdentityUser("Hao");
UnitTestHelper.IsSuccess(await manager.CreateAsync(user));
UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Admin")));
UnitTestHelper.IsSuccess(await role.CreateAsync(new IdentityRole("Local")));
UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Admin"));
UnitTestHelper.IsSuccess(await manager.AddToRoleAsync(user.Id, "Local"));
Claim[] userClaims =
{
new Claim("Whatever", "Value"),
new Claim("Whatever2", "Value2")
};
foreach (var c in userClaims)
{
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var identity = await manager.CreateIdentityAsync(user, "test");
var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory<IdentityUser, string>;
Assert.NotNull(claimsFactory);
var claims = identity.Claims;
Assert.NotNull(claims);
Assert.True(
claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName));
Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id));
Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin"));
Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local"));
Assert.True(
claims.Any(
c =>
c.Type == ClaimsIdentityFactory<IdentityUser>.IdentityProviderClaimType &&
c.Value == ClaimsIdentityFactory<IdentityUser>.DefaultIdentityProviderClaimValue));
foreach (var cl in userClaims)
{
Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));
}
}
private static async System.Threading.Tasks.Task CreateUserIfNotExist(UserManager<ApplicationUser> userManager, string email, string password, string role, string loginProvider = null, string providerKey = null)
{
var user = await userManager.FindByEmailAsync(email);
if (user == null)
{
user = new ApplicationUser { UserName = email, Email = email };
var result = await userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new ApplicationException(string.Join("\n", result.Errors.Select(a => a.Description).ToArray()));
}
await userManager.AddToRoleAsync(user, role);
if (loginProvider != null && providerKey != null)
{
await userManager.AddLoginAsync(user, new UserLoginInfo(loginProvider, providerKey, ""));
}
}
}
private async void Seed()
{
const string roleName = "administrator";
const string userName = "******";
var userContext = new ApplicationDbContext();
var roleStore = new RoleStore<IdentityRole>(userContext);
var roleManager = new RoleManager<IdentityRole>(roleStore);
if (roleManager.RoleExists(roleName)) return;
await roleManager.CreateAsync(new IdentityRole(roleName));
var userStore = new UserStore<ApplicationUser>(userContext);
var userManager = new UserManager<ApplicationUser>(userStore);
var admin = new ApplicationUser() {UserName = userName};
await userManager.CreateAsync(admin, "Koekoek!IsNummer1");
await userManager.AddToRoleAsync(admin.Id, roleName);
var pandContext = new ExclimmoContext();
pandContext.SeedPanden();
}
private static async Task<ApplicationUser> CreateUserIfNotExist(UserManager<ApplicationUser> userManager, ApplicationUser user, string password, string role, string loginProvider = null, string providerKey = null)
{
//Debugger.Launch();
user.EmailConfirmed = true;
user.Email = user.Email ?? user.UserName;
if (await userManager.FindByEmailAsync(user.Email) == null)
{
var result = await userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new ApplicationException(string.Join("\n", result.Errors.Select(a => a.Description).ToArray()));
}
await userManager.AddToRoleAsync(user, role);
if (loginProvider != null && providerKey != null)
{
await userManager.AddLoginAsync(user, new UserLoginInfo(loginProvider, providerKey, ""));
}
}
return user;
}
public async Task<ActionResult> AddUserToRole(AddUserToRoleViewModel model)
{
if (ModelState.IsValid)
{
using (var ctx = new ApplicationDbContext())
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(ctx));
var identityResult = await userManager.AddToRoleAsync(model.UserId, model.RoleName);
if (identityResult.Succeeded)
{
TempData["Message"] = "User added to role succesfully";
}
else
{
// TODO: add errors to TempData
}
}
}
return RedirectToAction("EditMembers", "Roles", new { Id = model.RoleName});
}
public async Task<IHttpActionResult> UpdateRuoloUtente(UpdateRuoloUtenteModel Model)
{
if (Model == null || !ModelState.IsValid)
return BadRequest(ModelState);
using (var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())))
{
var utente = await userManager.FindByNameAsync(Model.Username);
if (utente == null)
return NotFound();
if (Model.NuovoStato)
{
await userManager.AddToRoleAsync(utente.Id, Model.Ruolo);
}
else
{
await userManager.RemoveFromRoleAsync(utente.Id, Model.Ruolo);
}
}
return Ok();
}
public async Task <IActionResult> PutUser(string id, [Bind("FirstName", "LastName", "IsManager")] UserInfo userInput)
{
if (id != userInput.Id)
{
return(BadRequest());
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{id}'."));
}
user.FirstName = userInput.FirstName;
user.LastName = userInput.LastName;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
var roles = await _userManager.GetRolesAsync(user);
var isInManagerRole = roles.Contains("manager");
var claims = await _userManager.GetClaimsAsync(user);
var hasManagerClaim = claims.FirstOrDefault(c => c.Value == "manager") == null ? false: true;
if (isInManagerRole != hasManagerClaim)
{
return(BadRequest());
}
if (userInput.IsManager == true)
{
if (!isInManagerRole)
{
await _userManager.AddToRoleAsync(user, "manager");
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "manager"));
}
}
else
{
if (isInManagerRole)
{
await _userManager.RemoveFromRoleAsync(user, "manager");
await _userManager.RemoveClaimAsync(user, new Claim(ClaimTypes.Role, "manager"));
}
}
}
else
{
if (!UserExists(id))
{
return(NotFound());
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(NoContent());
}
protected void RoleCheckBox_CheckChanged(object sender, EventArgs e)
{
// Reference the CheckBox that raised this event
CheckBox RoleCheckBox = sender as CheckBox;
// Get the currently selected user and role
string selectedUserName = UserList.SelectedValue;
var um = new UserManager();
var user = um.FindByName(selectedUserName);
string roleName = RoleCheckBox.Text;
// Determine if we need to add or remove the user from this role
if (RoleCheckBox.Checked)
{
// Add the user to the role
um.AddToRoleAsync(user.Id, roleName);
// Display a status message
ActionStatus.Text = string.Format("User {0} was added to role {1}.", selectedUserName, roleName);
}
else
{
// Remove the user from the role
um.RemoveFromRoleAsync(user.Id, roleName);
// Display a status message
ActionStatus.Text = string.Format("User {0} was removed from role {1}.", selectedUserName, roleName);
}
// Refresh the "by role" interface
DisplayUsersBelongingToRole();
}
private async Task AddUserToRoleAsync(ApplicationUser user, string role)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var result = await userManager.AddToRoleAsync(user.Id, role);
}
public static async System.Threading.Tasks.Task SeedAllCustomersAsync(AppDbContext db, IServiceProvider serviceProvider)
{
UserManager <AppUser> _userManager = serviceProvider.GetRequiredService <UserManager <AppUser> >();
if (db.Users.Count() == 51)
{
throw new NotSupportedException("The database already contains all 51 customers!");
}
Int32 intCustomersAdded = 0;
String customerEmail = "Begin"; //helps to keep track of error on repos
List <AppUser> AppUsers = new List <AppUser>();
try
{
AppUser u1 = new AppUser();
u1.UserName = "******";
u1.Email = "*****@*****.**";
u1.PhoneNumber = "5725458641";
u1.FirstName = "Christopher";
u1.LastName = "Baker";
u1.Address = "1898 Schurz Alley";
u1.City = "Austin";
u1.State = "TX";
u1.Zip = "78705";
u1.UserStatus = "Active";
IdentityResult resultu1 = await _userManager.CreateAsync(u1, "bookworm");
if (resultu1.Succeeded)
{
await _userManager.AddToRoleAsync(u1, "Customer");
}
AppUsers.Add(u1);
AppUser u2 = new AppUser();
u2.UserName = "******";
u2.Email = "*****@*****.**";
u2.PhoneNumber = "9867048435";
u2.FirstName = "Michelle";
u2.LastName = "Banks";
u2.Address = "97 Elmside Pass";
u2.City = "Austin";
u2.State = "TX";
u2.Zip = "78712";
u2.UserStatus = "Active";
IdentityResult resultu2 = await _userManager.CreateAsync(u2, "potato");
if (resultu2.Succeeded)
{
await _userManager.AddToRoleAsync(u2, "Customer");
}
AppUsers.Add(u2);
AppUser u3 = new AppUser();
u3.UserName = "******";
u3.Email = "*****@*****.**";
u3.PhoneNumber = "6836109514";
u3.FirstName = "Franco";
u3.LastName = "Broccolo";
u3.Address = "88 Crowley Circle";
u3.City = "Austin";
u3.State = "TX";
u3.Zip = "78786";
u3.UserStatus = "Active";
IdentityResult resultu3 = await _userManager.CreateAsync(u3, "painting");
if (resultu3.Succeeded)
{
await _userManager.AddToRoleAsync(u3, "Customer");
}
AppUsers.Add(u3);
AppUser u4 = new AppUser();
u4.UserName = "******";
u4.Email = "*****@*****.**";
u4.PhoneNumber = "7070911071";
u4.FirstName = "Wendy";
u4.LastName = "Chang";
u4.Address = "56560 Sage Junction";
u4.City = "Eagle Pass";
u4.State = "TX";
u4.Zip = "78852";
u4.UserStatus = "Active";
IdentityResult resultu4 = await _userManager.CreateAsync(u4, "texas1");
if (resultu4.Succeeded)
{
await _userManager.AddToRoleAsync(u4, "Customer");
}
AppUsers.Add(u4);
AppUser u5 = new AppUser();
u5.UserName = "******";
u5.Email = "*****@*****.**";
u5.PhoneNumber = "1488907687";
u5.FirstName = "Lim";
u5.LastName = "Chou";
u5.Address = "60 Lunder Point";
u5.City = "Austin";
u5.State = "TX";
u5.Zip = "78729";
u5.UserStatus = "Active";
IdentityResult resultu5 = await _userManager.CreateAsync(u5, "Anchorage");
if (resultu5.Succeeded)
{
await _userManager.AddToRoleAsync(u5, "Customer");
}
AppUsers.Add(u5);
AppUser u6 = new AppUser();
u6.UserName = "******";
u6.Email = "*****@*****.**";
u6.PhoneNumber = "6899701824";
u6.FirstName = "Shan";
u6.LastName = "Dixon";
u6.Address = "9448 Pleasure Avenue";
u6.City = "Georgetown";
u6.State = "TX";
u6.Zip = "78628";
u6.UserStatus = "Active";
IdentityResult resultu6 = await _userManager.CreateAsync(u6, "aggies");
if (resultu6.Succeeded)
{
await _userManager.AddToRoleAsync(u6, "Customer");
}
AppUsers.Add(u6);
AppUser u7 = new AppUser();
u7.UserName = "******";
u7.Email = "*****@*****.**";
u7.PhoneNumber = "9986825917";
u7.FirstName = "Jim Bob";
u7.LastName = "Evans";
u7.Address = "51 Emmet Parkway";
u7.City = "Austin";
u7.State = "TX";
u7.Zip = "78705";
u7.UserStatus = "Active";
IdentityResult resultu7 = await _userManager.CreateAsync(u7, "hampton1");
if (resultu7.Succeeded)
{
await _userManager.AddToRoleAsync(u7, "Customer");
}
AppUsers.Add(u7);
AppUser u8 = new AppUser();
u8.UserName = "******";
u8.Email = "*****@*****.**";
u8.PhoneNumber = "3464121966";
u8.FirstName = "Lou Ann";
u8.LastName = "Feeley";
u8.Address = "65 Darwin Crossing";
u8.City = "Austin";
u8.State = "TX";
u8.Zip = "78704";
u8.UserStatus = "Active";
IdentityResult resultu8 = await _userManager.CreateAsync(u8, "longhorns");
if (resultu8.Succeeded)
{
await _userManager.AddToRoleAsync(u8, "Customer");
}
AppUsers.Add(u8);
AppUser u9 = new AppUser();
u9.UserName = "******";
u9.Email = "*****@*****.**";
u9.PhoneNumber = "6581357270";
u9.FirstName = "Tesa";
u9.LastName = "Freeley";
u9.Address = "7352 Loftsgordon Court";
u9.City = "College Station";
u9.State = "TX";
u9.Zip = "77840";
u9.UserStatus = "Active";
IdentityResult resultu9 = await _userManager.CreateAsync(u9, "mustangs");
if (resultu9.Succeeded)
{
await _userManager.AddToRoleAsync(u9, "Customer");
}
AppUsers.Add(u9);
AppUser u10 = new AppUser();
u10.UserName = "******";
u10.Email = "*****@*****.**";
u10.PhoneNumber = "3767347949";
u10.FirstName = "Margaret";
u10.LastName = "Garcia";
u10.Address = "7 International Road";
u10.City = "Austin";
u10.State = "TX";
u10.Zip = "78756";
u10.UserStatus = "Active";
IdentityResult resultu10 = await _userManager.CreateAsync(u10, "onetime");
if (resultu10.Succeeded)
{
await _userManager.AddToRoleAsync(u10, "Customer");
}
AppUsers.Add(u10);
AppUser u11 = new AppUser();
u11.UserName = "******";
u11.Email = "*****@*****.**";
u11.PhoneNumber = "2198604221";
u11.FirstName = "Charles";
u11.LastName = "Haley";
u11.Address = "8 Warrior Trail";
u11.City = "Austin";
u11.State = "TX";
u11.Zip = "78746";
u11.UserStatus = "Active";
IdentityResult resultu11 = await _userManager.CreateAsync(u11, "pepperoni");
if (resultu11.Succeeded)
{
await _userManager.AddToRoleAsync(u11, "Customer");
}
AppUsers.Add(u11);
AppUser u12 = new AppUser();
u12.UserName = "******";
u12.Email = "*****@*****.**";
u12.PhoneNumber = "1222185888";
u12.FirstName = "Jeffrey";
u12.LastName = "Hampton";
u12.Address = "9107 Lighthouse Bay Road";
u12.City = "Austin";
u12.State = "TX";
u12.Zip = "78756";
u12.UserStatus = "Active";
IdentityResult resultu12 = await _userManager.CreateAsync(u12, "raiders");
if (resultu12.Succeeded)
{
await _userManager.AddToRoleAsync(u12, "Customer");
}
AppUsers.Add(u12);
AppUser u13 = new AppUser();
u13.UserName = "******";
u13.Email = "*****@*****.**";
u13.PhoneNumber = "5123071976";
u13.FirstName = "John";
u13.LastName = "Hearn";
u13.Address = "59784 Pierstorff Center";
u13.City = "Liberty";
u13.State = "TX";
u13.Zip = "77575";
u13.UserStatus = "Active";
IdentityResult resultu13 = await _userManager.CreateAsync(u13, "jhearn22");
if (resultu13.Succeeded)
{
await _userManager.AddToRoleAsync(u13, "Customer");
}
AppUsers.Add(u13);
AppUser u14 = new AppUser();
u14.UserName = "******";
u14.Email = "*****@*****.**";
u14.PhoneNumber = "1211949601";
u14.FirstName = "Anthony";
u14.LastName = "Hicks";
u14.Address = "932 Monica Way";
u14.City = "San Antonio";
u14.State = "TX";
u14.Zip = "78203";
u14.UserStatus = "Active";
IdentityResult resultu14 = await _userManager.CreateAsync(u14, "hickhickup");
if (resultu14.Succeeded)
{
await _userManager.AddToRoleAsync(u14, "Customer");
}
AppUsers.Add(u14);
AppUser u15 = new AppUser();
u15.UserName = "******";
u15.Email = "*****@*****.**";
u15.PhoneNumber = "1372121569";
u15.FirstName = "Brad";
u15.LastName = "Ingram";
u15.Address = "4 Lukken Court";
u15.City = "New Braunfels";
u15.State = "TX";
u15.Zip = "78132";
u15.UserStatus = "Active";
IdentityResult resultu15 = await _userManager.CreateAsync(u15, "ingram2015");
if (resultu15.Succeeded)
{
await _userManager.AddToRoleAsync(u15, "Customer");
}
AppUsers.Add(u15);
AppUser u16 = new AppUser();
u16.UserName = "******";
u16.Email = "*****@*****.**";
u16.PhoneNumber = "8543163836";
u16.FirstName = "Todd";
u16.LastName = "Jacobs";
u16.Address = "7 Susan Junction";
u16.City = "New York";
u16.State = "NY";
u16.Zip = "10101";
u16.UserStatus = "Active";
IdentityResult resultu16 = await _userManager.CreateAsync(u16, "toddy25");
if (resultu16.Succeeded)
{
await _userManager.AddToRoleAsync(u16, "Customer");
}
AppUsers.Add(u16);
AppUser u17 = new AppUser();
u17.UserName = "******";
u17.Email = "*****@*****.**";
u17.PhoneNumber = "3214163359";
u17.FirstName = "Victoria";
u17.LastName = "Lawrence";
u17.Address = "669 Oak Junction";
u17.City = "Lockhart";
u17.State = "TX";
u17.Zip = "78644";
u17.UserStatus = "Active";
IdentityResult resultu17 = await _userManager.CreateAsync(u17, "something");
if (resultu17.Succeeded)
{
await _userManager.AddToRoleAsync(u17, "Customer");
}
AppUsers.Add(u17);
AppUser u18 = new AppUser();
u18.UserName = "******";
u18.Email = "*****@*****.**";
u18.PhoneNumber = "2505265350";
u18.FirstName = "Erik";
u18.LastName = "Lineback";
u18.Address = "099 Luster Point";
u18.City = "Kingwood";
u18.State = "TX";
u18.Zip = "77325";
u18.UserStatus = "Active";
IdentityResult resultu18 = await _userManager.CreateAsync(u18, "Password1");
if (resultu18.Succeeded)
{
await _userManager.AddToRoleAsync(u18, "Customer");
}
AppUsers.Add(u18);
AppUser u19 = new AppUser();
u19.UserName = "******";
u19.Email = "*****@*****.**";
u19.PhoneNumber = "4070619503";
u19.FirstName = "Ernest";
u19.LastName = "Lowe";
u19.Address = "35473 Hansons Hill";
u19.City = "Beverly Hills";
u19.State = "CA";
u19.Zip = "90210";
u19.UserStatus = "Active";
IdentityResult resultu19 = await _userManager.CreateAsync(u19, "aclfest2017");
if (resultu19.Succeeded)
{
await _userManager.AddToRoleAsync(u19, "Customer");
}
AppUsers.Add(u19);
AppUser u20 = new AppUser();
u20.UserName = "******";
u20.Email = "*****@*****.**";
u20.PhoneNumber = "7358436110";
u20.FirstName = "Chuck";
u20.LastName = "Luce";
u20.Address = "4 Emmet Junction";
u20.City = "Navasota";
u20.State = "TX";
u20.Zip = "77868";
u20.UserStatus = "Active";
IdentityResult resultu20 = await _userManager.CreateAsync(u20, "nothinggood");
if (resultu20.Succeeded)
{
await _userManager.AddToRoleAsync(u20, "Customer");
}
AppUsers.Add(u20);
AppUser u21 = new AppUser();
u21.UserName = "******";
u21.Email = "*****@*****.**";
u21.PhoneNumber = "7240178229";
u21.FirstName = "Jennifer";
u21.LastName = "MacLeod";
u21.Address = "3 Orin Road";
u21.City = "Austin";
u21.State = "TX";
u21.Zip = "78712";
u21.UserStatus = "Active";
IdentityResult resultu21 = await _userManager.CreateAsync(u21, "whatever");
if (resultu21.Succeeded)
{
await _userManager.AddToRoleAsync(u21, "Customer");
}
AppUsers.Add(u21);
AppUser u22 = new AppUser();
u22.UserName = "******";
u22.Email = "*****@*****.**";
u22.PhoneNumber = "2495200223";
u22.FirstName = "Elizabeth";
u22.LastName = "Markham";
u22.Address = "8171 Commercial Crossing";
u22.City = "Austin";
u22.State = "TX";
u22.Zip = "78712";
u22.UserStatus = "Active";
IdentityResult resultu22 = await _userManager.CreateAsync(u22, "snowsnow");
if (resultu22.Succeeded)
{
await _userManager.AddToRoleAsync(u22, "Customer");
}
AppUsers.Add(u22);
AppUser u23 = new AppUser();
u23.UserName = "******";
u23.Email = "*****@*****.**";
u23.PhoneNumber = "4086179161";
u23.FirstName = "Clarence";
u23.LastName = "Martin";
u23.Address = "96 Anthes Place";
u23.City = "Schenectady";
u23.State = "NY";
u23.Zip = "12345";
u23.UserStatus = "Active";
IdentityResult resultu23 = await _userManager.CreateAsync(u23, "whocares");
if (resultu23.Succeeded)
{
await _userManager.AddToRoleAsync(u23, "Customer");
}
AppUsers.Add(u23);
AppUser u24 = new AppUser();
u24.UserName = "******";
u24.Email = "*****@*****.**";
u24.PhoneNumber = "9371927523";
u24.FirstName = "Gregory";
u24.LastName = "Martinez";
u24.Address = "10 Northridge Plaza";
u24.City = "Austin";
u24.State = "TX";
u24.Zip = "78717";
u24.UserStatus = "Active";
IdentityResult resultu24 = await _userManager.CreateAsync(u24, "xcellent");
if (resultu24.Succeeded)
{
await _userManager.AddToRoleAsync(u24, "Customer");
}
AppUsers.Add(u24);
AppUser u25 = new AppUser();
u25.UserName = "******";
u25.Email = "*****@*****.**";
u25.PhoneNumber = "5954063857";
u25.FirstName = "Charles";
u25.LastName = "Miller";
u25.Address = "87683 Schmedeman Circle";
u25.City = "Austin";
u25.State = "TX";
u25.Zip = "78727";
u25.UserStatus = "Active";
IdentityResult resultu25 = await _userManager.CreateAsync(u25, "mydogspot");
if (resultu25.Succeeded)
{
await _userManager.AddToRoleAsync(u25, "Customer");
}
AppUsers.Add(u25);
AppUser u26 = new AppUser();
u26.UserName = "******";
u26.Email = "*****@*****.**";
u26.PhoneNumber = "8929209512";
u26.FirstName = "Kelly";
u26.LastName = "Nelson";
u26.Address = "3244 Ludington Court";
u26.City = "Beaumont";
u26.State = "TX";
u26.Zip = "77720";
u26.UserStatus = "Active";
IdentityResult resultu26 = await _userManager.CreateAsync(u26, "spotmydog");
if (resultu26.Succeeded)
{
await _userManager.AddToRoleAsync(u26, "Customer");
}
AppUsers.Add(u26);
AppUser u27 = new AppUser();
u27.UserName = "******";
u27.Email = "*****@*****.**";
u27.PhoneNumber = "9226301774";
u27.FirstName = "Joe";
u27.LastName = "Nguyen";
u27.Address = "4780 Talisman Court";
u27.City = "San Marcos";
u27.State = "TX";
u27.Zip = "78667";
u27.UserStatus = "Active";
IdentityResult resultu27 = await _userManager.CreateAsync(u27, "joejoejoe");
if (resultu27.Succeeded)
{
await _userManager.AddToRoleAsync(u27, "Customer");
}
AppUsers.Add(u27);
AppUser u28 = new AppUser();
u28.UserName = "******";
u28.Email = "*****@*****.**";
u28.PhoneNumber = "2537646912";
u28.FirstName = "Bill";
u28.LastName = "O'Reilly";
u28.Address = "4154 Delladonna Plaza";
u28.City = "Bergheim";
u28.State = "TX";
u28.Zip = "78004";
u28.UserStatus = "Active";
IdentityResult resultu28 = await _userManager.CreateAsync(u28, "billyboy");
if (resultu28.Succeeded)
{
await _userManager.AddToRoleAsync(u28, "Customer");
}
AppUsers.Add(u28);
AppUser u29 = new AppUser();
u29.UserName = "******";
u29.Email = "*****@*****.**";
u29.PhoneNumber = "2182889379";
u29.FirstName = "Anka";
u29.LastName = "Radkovich";
u29.Address = "72361 Bayside Drive";
u29.City = "Austin";
u29.State = "TX";
u29.Zip = "78789";
u29.UserStatus = "Active";
IdentityResult resultu29 = await _userManager.CreateAsync(u29, "radgirl");
if (resultu29.Succeeded)
{
await _userManager.AddToRoleAsync(u29, "Customer");
}
AppUsers.Add(u29);
AppUser u30 = new AppUser();
u30.UserName = "******";
u30.Email = "*****@*****.**";
u30.PhoneNumber = "9532396075";
u30.FirstName = "Megan";
u30.LastName = "Rhodes";
u30.Address = "76875 Hoffman Point";
u30.City = "Orlando";
u30.State = "FL";
u30.Zip = "32830";
u30.UserStatus = "Active";
IdentityResult resultu30 = await _userManager.CreateAsync(u30, "meganr34");
if (resultu30.Succeeded)
{
await _userManager.AddToRoleAsync(u30, "Customer");
}
AppUsers.Add(u30);
AppUser u31 = new AppUser();
u31.UserName = "******";
u31.Email = "*****@*****.**";
u31.PhoneNumber = "7303815953";
u31.FirstName = "Eryn";
u31.LastName = "Rice";
u31.Address = "048 Elmside Park";
u31.City = "South Padre Island";
u31.State = "TX";
u31.Zip = "78597";
u31.UserStatus = "Active";
IdentityResult resultu31 = await _userManager.CreateAsync(u31, "ricearoni");
if (resultu31.Succeeded)
{
await _userManager.AddToRoleAsync(u31, "Customer");
}
AppUsers.Add(u31);
AppUser u32 = new AppUser();
u32.UserName = "******";
u32.Email = "*****@*****.**";
u32.PhoneNumber = "3677322422";
u32.FirstName = "Jorge";
u32.LastName = "Rodriguez";
u32.Address = "01 Browning Pass";
u32.City = "Austin";
u32.State = "TX";
u32.Zip = "78744";
u32.UserStatus = "Active";
IdentityResult resultu32 = await _userManager.CreateAsync(u32, "alaskaboy");
if (resultu32.Succeeded)
{
await _userManager.AddToRoleAsync(u32, "Customer");
}
AppUsers.Add(u32);
AppUser u33 = new AppUser();
u33.UserName = "******";
u33.Email = "*****@*****.**";
u33.PhoneNumber = "3911705385";
u33.FirstName = "Allen";
u33.LastName = "Rogers";
u33.Address = "844 Anderson Alley";
u33.City = "Canyon Lake";
u33.State = "TX";
u33.Zip = "78133";
u33.UserStatus = "Active";
IdentityResult resultu33 = await _userManager.CreateAsync(u33, "bunnyhop");
if (resultu33.Succeeded)
{
await _userManager.AddToRoleAsync(u33, "Customer");
}
AppUsers.Add(u33);
AppUser u34 = new AppUser();
u34.UserName = "******";
u34.Email = "*****@*****.**";
u34.PhoneNumber = "7351610920";
u34.FirstName = "Olivier";
u34.LastName = "Saint-Jean";
u34.Address = "1891 Docker Point";
u34.City = "Austin";
u34.State = "TX";
u34.Zip = "78779";
u34.UserStatus = "Active";
IdentityResult resultu34 = await _userManager.CreateAsync(u34, "dustydusty");
if (resultu34.Succeeded)
{
await _userManager.AddToRoleAsync(u34, "Customer");
}
AppUsers.Add(u34);
AppUser u35 = new AppUser();
u35.UserName = "******";
u35.Email = "*****@*****.**";
u35.PhoneNumber = "5269661692";
u35.FirstName = "Sarah";
u35.LastName = "Saunders";
u35.Address = "1469 Upham Road";
u35.City = "Austin";
u35.State = "TX";
u35.Zip = "78720";
u35.UserStatus = "Active";
IdentityResult resultu35 = await _userManager.CreateAsync(u35, "jrod2017");
if (resultu35.Succeeded)
{
await _userManager.AddToRoleAsync(u35, "Customer");
}
AppUsers.Add(u35);
AppUser u36 = new AppUser();
u36.UserName = "******";
u36.Email = "*****@*****.**";
u36.PhoneNumber = "1875727246";
u36.FirstName = "William";
u36.LastName = "Sewell";
u36.Address = "1672 Oak Valley Circle";
u36.City = "Austin";
u36.State = "TX";
u36.Zip = "78705";
u36.UserStatus = "Active";
IdentityResult resultu36 = await _userManager.CreateAsync(u36, "martin1234");
if (resultu36.Succeeded)
{
await _userManager.AddToRoleAsync(u36, "Customer");
}
AppUsers.Add(u36);
AppUser u37 = new AppUser();
u37.UserName = "******";
u37.Email = "*****@*****.**";
u37.PhoneNumber = "1394323615";
u37.FirstName = "Martin";
u37.LastName = "Sheffield";
u37.Address = "816 Kennedy Place";
u37.City = "Round Rock";
u37.State = "TX";
u37.Zip = "78680";
u37.UserStatus = "Active";
IdentityResult resultu37 = await _userManager.CreateAsync(u37, "penguin12");
if (resultu37.Succeeded)
{
await _userManager.AddToRoleAsync(u37, "Customer");
}
AppUsers.Add(u37);
AppUser u38 = new AppUser();
u38.UserName = "******";
u38.Email = "*****@*****.**";
u38.PhoneNumber = "6645937874";
u38.FirstName = "John";
u38.LastName = "Smith";
u38.Address = "0745 Golf Road";
u38.City = "Austin";
u38.State = "TX";
u38.Zip = "78760";
u38.UserStatus = "Active";
IdentityResult resultu38 = await _userManager.CreateAsync(u38, "rogerthat");
if (resultu38.Succeeded)
{
await _userManager.AddToRoleAsync(u38, "Customer");
}
AppUsers.Add(u38);
AppUser u39 = new AppUser();
u39.UserName = "******";
u39.Email = "*****@*****.**";
u39.PhoneNumber = "6470254680";
u39.FirstName = "Dustin";
u39.LastName = "Stroud";
u39.Address = "505 Dexter Plaza";
u39.City = "Sweet Home";
u39.State = "TX";
u39.Zip = "77987";
u39.UserStatus = "Active";
IdentityResult resultu39 = await _userManager.CreateAsync(u39, "smitty444");
if (resultu39.Succeeded)
{
await _userManager.AddToRoleAsync(u39, "Customer");
}
AppUsers.Add(u39);
AppUser u40 = new AppUser();
u40.UserName = "******";
u40.Email = "*****@*****.**";
u40.PhoneNumber = "7701621022";
u40.FirstName = "Eric";
u40.LastName = "Stuart";
u40.Address = "585 Claremont Drive";
u40.City = "Corpus Christi";
u40.State = "TX";
u40.Zip = "78412";
u40.UserStatus = "Active";
IdentityResult resultu40 = await _userManager.CreateAsync(u40, "stewball");
if (resultu40.Succeeded)
{
await _userManager.AddToRoleAsync(u40, "Customer");
}
AppUsers.Add(u40);
AppUser u41 = new AppUser();
u41.UserName = "******";
u41.Email = "*****@*****.**";
u41.PhoneNumber = "2181960061";
u41.FirstName = "Peter";
u41.LastName = "Stump";
u41.Address = "89035 Welch Circle";
u41.City = "Pflugerville";
u41.State = "TX";
u41.Zip = "78660";
u41.UserStatus = "Active";
IdentityResult resultu41 = await _userManager.CreateAsync(u41, "slowwind");
if (resultu41.Succeeded)
{
await _userManager.AddToRoleAsync(u41, "Customer");
}
AppUsers.Add(u41);
AppUser u42 = new AppUser();
u42.UserName = "******";
u42.Email = "*****@*****.**";
u42.PhoneNumber = "9908469499";
u42.FirstName = "Jeremy";
u42.LastName = "Tanner";
u42.Address = "4 Stang Trail";
u42.City = "Austin";
u42.State = "TX";
u42.Zip = "78702";
u42.UserStatus = "Active";
IdentityResult resultu42 = await _userManager.CreateAsync(u42, "tanner5454");
if (resultu42.Succeeded)
{
await _userManager.AddToRoleAsync(u42, "Customer");
}
AppUsers.Add(u42);
AppUser u43 = new AppUser();
u43.UserName = "******";
u43.Email = "*****@*****.**";
u43.PhoneNumber = "7011918647";
u43.FirstName = "Allison";
u43.LastName = "Taylor";
u43.Address = "726 Twin Pines Avenue";
u43.City = "Austin";
u43.State = "TX";
u43.Zip = "78713";
u43.UserStatus = "Active";
IdentityResult resultu43 = await _userManager.CreateAsync(u43, "allyrally");
if (resultu43.Succeeded)
{
await _userManager.AddToRoleAsync(u43, "Customer");
}
AppUsers.Add(u43);
AppUser u44 = new AppUser();
u44.UserName = "******";
u44.Email = "*****@*****.**";
u44.PhoneNumber = "8937910053";
u44.FirstName = "Rachel";
u44.LastName = "Taylor";
u44.Address = "06605 Sugar Drive";
u44.City = "Austin";
u44.State = "TX";
u44.Zip = "78712";
u44.UserStatus = "Active";
IdentityResult resultu44 = await _userManager.CreateAsync(u44, "taylorbaylor");
if (resultu44.Succeeded)
{
await _userManager.AddToRoleAsync(u44, "Customer");
}
AppUsers.Add(u44);
AppUser u45 = new AppUser();
u45.UserName = "******";
u45.Email = "*****@*****.**";
u45.PhoneNumber = "6394568913";
u45.FirstName = "Frank";
u45.LastName = "Tee";
u45.Address = "3567 Dawn Plaza";
u45.City = "Austin";
u45.State = "TX";
u45.Zip = "78786";
u45.UserStatus = "Active";
IdentityResult resultu45 = await _userManager.CreateAsync(u45, "teeoff22");
if (resultu45.Succeeded)
{
await _userManager.AddToRoleAsync(u45, "Customer");
}
AppUsers.Add(u45);
AppUser u46 = new AppUser();
u46.UserName = "******";
u46.Email = "*****@*****.**";
u46.PhoneNumber = "2676838676";
u46.FirstName = "Clent";
u46.LastName = "Tucker";
u46.Address = "704 Northland Alley";
u46.City = "San Antonio";
u46.State = "TX";
u46.Zip = "78279";
u46.UserStatus = "Active";
IdentityResult resultu46 = await _userManager.CreateAsync(u46, "tucksack1");
if (resultu46.Succeeded)
{
await _userManager.AddToRoleAsync(u46, "Customer");
}
AppUsers.Add(u46);
AppUser u47 = new AppUser();
u47.UserName = "******";
u47.Email = "*****@*****.**";
u47.PhoneNumber = "3452909754";
u47.FirstName = "Allen";
u47.LastName = "Velasco";
u47.Address = "72 Harbort Point";
u47.City = "Navasota";
u47.State = "TX";
u47.Zip = "77868";
u47.UserStatus = "Active";
IdentityResult resultu47 = await _userManager.CreateAsync(u47, "meow88");
if (resultu47.Succeeded)
{
await _userManager.AddToRoleAsync(u47, "Customer");
}
AppUsers.Add(u47);
AppUser u48 = new AppUser();
u48.UserName = "******";
u48.Email = "*****@*****.**";
u48.PhoneNumber = "8567089194";
u48.FirstName = "Janet";
u48.LastName = "Vino";
u48.Address = "1 Oak Valley Place";
u48.City = "Boston";
u48.State = "MA";
u48.Zip = "02114";
u48.UserStatus = "Active";
IdentityResult resultu48 = await _userManager.CreateAsync(u48, "vinovino");
if (resultu48.Succeeded)
{
await _userManager.AddToRoleAsync(u48, "Customer");
}
AppUsers.Add(u48);
AppUser u49 = new AppUser();
u49.UserName = "******";
u49.Email = "*****@*****.**";
u49.PhoneNumber = "6260784394";
u49.FirstName = "Jake";
u49.LastName = "West";
u49.Address = "48743 Banding Parkway";
u49.City = "Marble Falls";
u49.State = "TX";
u49.Zip = "78654";
u49.UserStatus = "Active";
IdentityResult resultu49 = await _userManager.CreateAsync(u49, "gowest");
if (resultu49.Succeeded)
{
await _userManager.AddToRoleAsync(u49, "Customer");
}
AppUsers.Add(u49);
AppUser u50 = new AppUser();
u50.UserName = "******";
u50.Email = "*****@*****.**";
u50.PhoneNumber = "3733971174";
u50.FirstName = "Louis";
u50.LastName = "Winthorpe";
u50.Address = "96850 Summit Crossing";
u50.City = "Austin";
u50.State = "TX";
u50.Zip = "78730";
u50.UserStatus = "Active";
IdentityResult resultu50 = await _userManager.CreateAsync(u50, "louielouie");
if (resultu50.Succeeded)
{
await _userManager.AddToRoleAsync(u50, "Customer");
}
AppUsers.Add(u50);
AppUser u51 = new AppUser();
u51.UserName = "******";
u51.Email = "*****@*****.**";
u51.PhoneNumber = "8433359800";
u51.FirstName = "Reagan";
u51.LastName = "Wood";
u51.Address = "18354 Bluejay Street";
u51.City = "Austin";
u51.State = "TX";
u51.Zip = "78712";
u51.UserStatus = "Active";
IdentityResult resultu51 = await _userManager.CreateAsync(u51, "woodyman1");
if (resultu51.Succeeded)
{
await _userManager.AddToRoleAsync(u51, "Customer");
}
AppUsers.Add(u51);
//loop through customers
foreach (AppUser ur in AppUsers)
{
//set name of User to help debug
customerEmail = ur.Email;
//see if repo exists in database
AppUser dbur = db.Users.FirstOrDefault(r => r.Email == ur.Email);
if (dbur == null) //user does not exist in database
{
db.Users.Add(ur);
db.SaveChanges();
intCustomersAdded += 1;
}
else
{
dbur.UserName = ur.UserName;
dbur.Email = ur.Email;
dbur.PhoneNumber = ur.PhoneNumber;
dbur.FirstName = ur.FirstName;
dbur.LastName = ur.LastName;
dbur.Address = ur.Address;
dbur.City = ur.City;
dbur.State = ur.State;
dbur.Zip = ur.Zip;
db.Update(dbur);
db.SaveChanges();
}
}
}
catch
{
String msg = "Users added:" + intCustomersAdded + "; Error on " + customerEmail;
throw new InvalidOperationException(msg);
}
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
Name = Input.Name,
StreetAddress = Input.StreetAddress,
City = Input.City,
State = Input.State,
PostalCode = Input.PostalCode,
PhoneNumber = Input.PhoneNumber
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, SD.CustomerUser);
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, 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>.");
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public static async Task SeedData(DataContext context, UserManager <AppUser> userManager, RoleManager <IdentityRole> roleManager)
{
if (!userManager.Users.Any())
{
var users = new List <AppUser>
{
new AppUser
{
DisplayName = "Joey",
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
DisplayName = "Jeff",
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
DisplayName = "Suzy",
UserName = "******",
Email = "*****@*****.**"
},
new AppUser
{
DisplayName = "Tech",
UserName = "******",
Email = "*****@*****.**"
}
};
foreach (var usr in users)
{
await userManager.CreateAsync(usr, "Pa$$w0rd");
}
}
IdentityResult roleResult;
//Adding Admin Role
// var roleCheck = await roleManager.RoleExistsAsync("Admin");
if (!roleManager.Roles.Any())
{
//create the roles and seed them to the database
roleResult = await roleManager.CreateAsync(new IdentityRole("Admin"));
roleResult = await roleManager.CreateAsync(new IdentityRole("Member"));
}
//Assign Admin role to the main User here we have given our newly registered
//login id for Admin management
var user = await userManager.FindByEmailAsync("*****@*****.**");
await userManager.AddToRoleAsync(user, "Admin");
user = await userManager.FindByEmailAsync("*****@*****.**");
await userManager.AddToRoleAsync(user, "Admin");
user = await userManager.FindByEmailAsync("*****@*****.**");
await userManager.AddToRoleAsync(user, "Admin");
user = await userManager.FindByEmailAsync("*****@*****.**");
await userManager.AddToRoleAsync(user, "Member");
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
//var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
CompanyId = Input.CompanyId,
Street = Input.Street,
City = Input.City,
State = Input.State,
PostalCode = Input.PostalCode,
Name = Input.Name,
PhoneNumber = Input.PhoneNumber,
Role = Input.Role
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
if (!await _roleManager.RoleExistsAsync(ProjectConstant.Role_Admin))
{
await _roleManager.CreateAsync(new IdentityRole(ProjectConstant.Role_Admin));
}
if (!await _roleManager.RoleExistsAsync(ProjectConstant.Role_Employee))
{
await _roleManager.CreateAsync(new IdentityRole(ProjectConstant.Role_Employee));
}
if (!await _roleManager.RoleExistsAsync(ProjectConstant.Role_User_Comp))
{
await _roleManager.CreateAsync(new IdentityRole(ProjectConstant.Role_User_Comp));
}
if (!await _roleManager.RoleExistsAsync(ProjectConstant.Role_User_Indi))
{
await _roleManager.CreateAsync(new IdentityRole(ProjectConstant.Role_User_Indi));
}
//await _userManager.AddToRoleAsync(user, ProjectConstant.Role_Admin);
if (user.Role == null)
{
await _userManager.AddToRoleAsync(user, ProjectConstant.Role_User_Indi);
}
else
{
if (user.CompanyId > 0)
{
await _userManager.AddToRoleAsync(user, ProjectConstant.Role_User_Comp);
}
await _userManager.AddToRoleAsync(user, user.Role);
}
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
//var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
// 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>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
if (user.Role == null)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "User", new { Area = "Admin" }));
}
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> Edit(String id, [Bind("UserName, Email")] Benutzer model, String Role)
{
if (ModelState.IsValid)
{
try
{
var user = await userManager.FindByIdAsync(id);
var newName = user.UserName;
if (model.UserName == null) // Fall: Benutzername ist leer.
{
toastNotification.AddToastMessage("Kein Benutzername eingegeben", "Es muss ein Benutzername vergeben werden.", ToastEnums.ToastType.Error, new ToastOption()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction(nameof(Edit)));
}
else if (model.Email == null) // Fall: Email ist leer.
{
toastNotification.AddToastMessage("Kein Email eingegeben", "Es muss eine Email-Adresse vergeben werden.", ToastEnums.ToastType.Error, new ToastOption()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction(nameof(Edit)));
}
else
{
// Fall: Der Benutzername wurde geändert.
if (model.UserName != newName)
{
var userExist = bibContext.Benutzer.SingleOrDefault(b => b.UserName == model.UserName);
// Fall: Der neue Benutzername existiert bereits in der Datenbank.
if (userExist != null)
{
toastNotification.AddToastMessage("Benutzername bereits vergeben", "Der Benutzername \"" + model.UserName + "\" ist bereits vergeben.", ToastEnums.ToastType.Error, new ToastOption()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction(nameof(Edit)));
}
// Alle bisherigern Referenzen auf den neuen Namen ändern
var warenkorb = bibContext.Warenkorb.Where(e => e.Benutzer.Equals(user.UserName));
foreach (var warenkorbExemplar in warenkorb)
{
warenkorbExemplar.Benutzer = model.UserName;
bibContext.Warenkorb.Update(warenkorbExemplar);
}
var leihauftraege = bibContext.Leihauftrag.Where(e => e.Benutzer.Equals(user.UserName));
foreach (var leihauftrag in leihauftraege)
{
leihauftrag.Benutzer = model.UserName;
bibContext.Leihauftrag.Update(leihauftrag);
}
await bibContext.SaveChangesAsync();
var setNameResult = await userManager.SetUserNameAsync(user, model.UserName);
}
// Fall: Die Email-Adresse wurde geändert
if (user.Email != model.Email)
{
await userManager.SetEmailAsync(user, model.Email);
}
// Rolle des Benutzers wird für die Datenbank aktualisiert
if (Role == "Admin")
{
var role = await userManager.GetRolesAsync(user);
await userManager.RemoveFromRolesAsync(user, role);
await userManager.AddToRoleAsync(user, "Admin");
user.Role = "Admin";
bibContext.Update(user);
bibContext.SaveChanges();
toastNotification.AddToastMessage("Benutzerdaten geändert", "Die Benutzerdaten von \"" + user.UserName + "\" wurden geändert.", ToastEnums.ToastType.Success, new ToastOption()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction(nameof(Index)));
}
if (Role == "Member")
{
var role = await userManager.GetRolesAsync(user);
await userManager.RemoveFromRolesAsync(user, role);
await userManager.AddToRoleAsync(user, "Member");
user.Role = "Member";
bibContext.Update(user);
bibContext.SaveChanges();
toastNotification.AddToastMessage("Benutzerdaten geändert", "Der Benutzerdaten von \"" + user.UserName + "\" wurden geändert.", ToastEnums.ToastType.Success, new ToastOption()
{
PositionClass = ToastPositions.TopCenter
});
return(RedirectToAction(nameof(Index)));
}
}
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateConcurrencyException)
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
public static async Task Initialize(ApplicationDbContext context,
UserManager <User> userManager,
RoleManager <Role> roleManager)
{
context.Database.EnsureCreated();
String adminId1 = "";
String adminId2 = "";
string role1 = "Admin";
string desc1 = "This is the administrator role";
string role2 = "Member";
string desc2 = "This is the members role";
string password = "******";
if (await roleManager.FindByNameAsync(role1) == null)
{
await roleManager.CreateAsync(new Role(role1, desc1, DateTime.Now));
}
if (await roleManager.FindByNameAsync(role2) == null)
{
await roleManager.CreateAsync(new Role(role2, desc2, DateTime.Now));
}
if (await userManager.FindByNameAsync("*****@*****.**") == null)
{
var user = new User
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Adam",
LastName = "Aldridge",
Street = "Fake St",
City = "Vancouver",
Province = "BC",
PostalCode = "V5U K8I",
Country = "Canada",
PhoneNumber = "6902341234"
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
await userManager.AddPasswordAsync(user, password);
await userManager.AddToRoleAsync(user, role1);
}
adminId1 = user.Id;
}
if (await userManager.FindByNameAsync("*****@*****.**") == null)
{
var user = new User
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Bob",
LastName = "Barker",
Street = "Vermont St",
City = "Surrey",
Province = "BC",
PostalCode = "V1P I5T",
Country = "Canada",
PhoneNumber = "7788951456"
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
await userManager.AddPasswordAsync(user, password);
await userManager.AddToRoleAsync(user, role1);
}
adminId2 = user.Id;
}
if (await userManager.FindByNameAsync("*****@*****.**") == null)
{
var user = new User
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Mike",
LastName = "Myers",
Street = "Yew St",
City = "Vancouver",
Province = "BC",
PostalCode = "V3U E2Y",
Country = "Canada",
PhoneNumber = "6572136821"
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
await userManager.AddPasswordAsync(user, password);
await userManager.AddToRoleAsync(user, role2);
}
}
if (await userManager.FindByNameAsync("*****@*****.**") == null)
{
var user = new User
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Donald",
LastName = "Duck",
Street = "Well St",
City = "Vancouver",
Province = "BC",
PostalCode = "V8U R9Y",
Country = "Canada",
PhoneNumber = "6041234567"
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
await userManager.AddPasswordAsync(user, password);
await userManager.AddToRoleAsync(user, role2);
}
}
}
public async Task <List <ValidationResult> > SetupUser(SetupUserViewModel userViewModel)
{
bool isValid = Validator.TryValidateObject(userViewModel, new ValidationContext(userViewModel, null, null), results, false);
if (!isValid)
{
return(results);
}
Enum.TryParse(typeof(UserTypes), userViewModel.UserType.ToString(), out object userType);
var user = new ImanageUser()
{
UserName = userViewModel.Email,
LastName = userViewModel.LastName,
FirstName = userViewModel.FirstName,
MiddleName = userViewModel.MiddleName,
Gender = userViewModel.Gender,
Email = userViewModel.Email,
UserType = (UserTypes)userType
};
Enum.TryParse(typeof(UserRoles), userViewModel.Role.ToString(), out object role);
var status = await CreateIdentityUser(user);
userViewModel.Role = (int)role;
if (status.Any())
{
return(results);
}
userViewModel.User_Id = user.Id.ToString();
var createResult = await CreateUserType(userViewModel, user, (UserTypes)userType);
if (!createResult.Any())
{
user.UserTypeId = Guid.Parse(userViewModel.UserType_Id);
await _userManager.UpdateAsync(user);
var roleName = role.ToString();
if (!await _roleManager.RoleExistsAsync(roleName))
{
await _roleManager.CreateAsync(new ImanageRole()
{
Name = roleName
});
}
await _userManager.AddToRoleAsync(user, roleName);
await AssignDefaultPermission(user, roleName);
userViewModel.RoleName = roleName;
}
else
{
await _userManager.DeleteAsync(user);
}
return(createResult);
}
public async Task Seed()
{
if (!_roleManager.Roles.Any())
{
await _roleManager.CreateAsync(new AppRole()
{
Name = "Admin",
NormalizedName = "Admin",
Description = "Administrator"
});
await _roleManager.CreateAsync(new AppRole()
{
Name = "Manager",
NormalizedName = "Manager",
Description = "Manager"
});
await _roleManager.CreateAsync(new AppRole()
{
Name = "Staff",
NormalizedName = "Staff",
Description = "Staff"
});
await _roleManager.CreateAsync(new AppRole()
{
Name = "Customer",
NormalizedName = "Customer",
Description = "Customer"
});
}
if (!_userManager.Users.Any())
{
await _userManager.CreateAsync(new AppUser()
{
UserName = "******",
FullName = "Administrator",
Email = "*****@*****.**",
Balance = 0,
DateCreated = DateTime.Now,
DateModified = DateTime.Now,
Active = true
}, "123");
var user = await _userManager.FindByNameAsync("admin");
await _userManager.AddToRoleAsync(user, "Admin");
}
if (!_context.Contacts.Any())
{
_context.Contacts.Add(new Contact()
{
Id = CommonConstants.DefaultContactId,
Address = "Ngõ 168, đường Vương Thừa Vũ, quận Thanh Xuân, Hà Nội",
Email = "*****@*****.**",
Name = "GymNutri",
Phone = "0974 240 911",
Website = "http://GymNutri.com",
Lat = 21.0435009,
Lng = 105.7894758,
Active = true
});
}
if (_context.Functions.Count() == 0)
{
_context.Functions.AddRange(new List <Function>()
{
new Function()
{
Id = "Business", Name = "Business", ParentId = null, OrderNo = 1, Active = true, Url = "/", IconCss = "fa fa-building"
},
new Function()
{
Id = "MemberCard", Name = "Member Card", ParentId = "Business", OrderNo = 1, Active = true, Url = "/Admin/MemberCard/Index", IconCss = "fa fa-credit-card-alt"
},
new Function()
{
Id = "DaisyOrder", Name = "Daisy Order", ParentId = "Business", OrderNo = 2, Active = true, Url = "/Admin/DaisyOrder/Index", IconCss = "fa fa-folder-o"
},
new Function()
{
Id = "Category", Name = "Category", ParentId = null, OrderNo = 1, Active = true, Url = "/", IconCss = "fa fa-th-list"
},
new Function()
{
Id = "CommonCategory", Name = "Common Category", ParentId = "Category", OrderNo = 1, Active = true, Url = "/Admin/CommonCategory/Index", IconCss = "fa fa-list-ol"
},
new Function()
{
Id = "StatusCategory", Name = "Status Category", ParentId = "Category", OrderNo = 2, Active = true, Url = "/Admin/StatusCategory/Index", IconCss = "fa fa-star-half-o"
},
new Function()
{
Id = "CustomerRelated", Name = "Related To Customer", ParentId = null, OrderNo = 2, Active = true, Url = "/", IconCss = "fa fa-user"
},
new Function()
{
Id = "Customer", Name = "Customer", ParentId = "CustomerRelated", OrderNo = 1, Active = true, Url = "/Admin/Customer/Index", IconCss = "fa fa-user-plus"
},
new Function()
{
Id = "BodyClassification", Name = "Body Classification", ParentId = "CustomerRelated", OrderNo = 2, Active = true, Url = "/Admin/BodyClassification/Index", IconCss = "fa fa-male"
},
new Function()
{
Id = "System", Name = "System", ParentId = null, OrderNo = 3, Active = true, Url = "/", IconCss = "fa fa-cog"
},
new Function()
{
Id = "Role", Name = "Role", ParentId = "System", OrderNo = 1, Active = true, Url = "/Admin/Role/Index", IconCss = "fa fa-id-card"
},
new Function()
{
Id = "User", Name = "User", ParentId = "System", OrderNo = 2, Active = true, Url = "/Admin/User/Index", IconCss = "fa fa-users"
},
new Function()
{
Id = "FoodRelated", Name = "Related To Food", ParentId = null, OrderNo = 4, Active = true, Url = "/", IconCss = "fa fa-apple"
},
new Function()
{
Id = "FoodCategory", Name = "Food Category", ParentId = "FoodRelated", OrderNo = 1, Active = true, Url = "/Admin/FoodCategory/Index", IconCss = "fa fa-external-link"
},
new Function()
{
Id = "Food", Name = "Food", ParentId = "FoodRelated", OrderNo = 2, Active = true, Url = "/Admin/Food/Index", IconCss = "fa fa-pie-chart"
},
new Function()
{
Id = "SetOfFood", Name = "Set Of Food", ParentId = "FoodRelated", OrderNo = 3, Active = true, Url = "/Admin/SetOfFood/Index", IconCss = "fa fa-bars"
},
new Function()
{
Id = "FoodPrice", Name = "Food Price", ParentId = "FoodRelated", OrderNo = 4, Active = true, Url = "/Admin/FoodPrice/Index", IconCss = "fa fa-money"
},
new Function()
{
Id = "Meal", Name = "Meal", ParentId = "FoodRelated", OrderNo = 5, Active = true, Url = "/Admin/Meal/Index", IconCss = "fa fa-circle-o"
},
new Function()
{
Id = "Template", Name = "Template", ParentId = null, OrderNo = 5, Active = true, Url = "/", IconCss = "fa fa-folder-open"
},
new Function()
{
Id = "TemplateMenu", Name = "Template Menu", ParentId = "Template", OrderNo = 1, Active = true, Url = "/Admin/TemplateMenu/Index", IconCss = "fa fa-road"
},
new Function()
{
Id = "Utility", Name = "Utility", ParentId = null, OrderNo = 6, Active = true, Url = "/", IconCss = "fa fa-clone"
},
new Function()
{
Id = "Footer", Name = "Footer", ParentId = "Utility", OrderNo = 1, Active = true, Url = "/Admin/Footer/Index", IconCss = "fa fa-fort-awesome"
},
new Function()
{
Id = "Feedback", Name = "Feedback", ParentId = "Utility", OrderNo = 2, Active = true, Url = "/Admin/Feedback/Index", IconCss = "fa fa-comments"
},
new Function()
{
Id = "Announcement", Name = "Announcement", ParentId = "Utility", OrderNo = 3, Active = true, Url = "/Admin/Announcement/Index", IconCss = "fa fa-comment"
},
new Function()
{
Id = "Contact", Name = "Contact", ParentId = "Utility", OrderNo = 4, Active = true, Url = "/Admin/Contact/Index", IconCss = "fa fa-address-book"
},
new Function()
{
Id = "Slide", Name = "Slide", ParentId = "Utility", OrderNo = 5, Active = true, Url = "/Admin/Slide/Index", IconCss = "fa fa-picture-o"
},
new Function()
{
Id = "Advertisment", Name = "Advertisment", ParentId = "Utility", OrderNo = 6, Active = true, Url = "/Admin/Advertisement/Index", IconCss = "fa fa-eye"
},
});
}
if (_context.Footers.Count(x => x.Id == CommonConstants.DefaultFooterId) == 0)
{
string content = "Footer";
_context.Footers.Add(new Footer()
{
Id = CommonConstants.DefaultFooterId,
Content = content
});
}
if (_context.Slides.Count() == 0)
{
List <Slide> slides = new List <Slide>()
{
new Slide()
{
Name = "Slide 01", Image = "/client-side/images/slider/slide-1.jpg", Url = "#", DisplayOrder = 0, GroupAlias = "top", Active = true
},
new Slide()
{
Name = "Slide 02", Image = "/client-side/images/slider/slide-2.jpg", Url = "#", DisplayOrder = 1, GroupAlias = "top", Active = true
},
new Slide()
{
Name = "Slide 03", Image = "/client-side/images/slider/slide-3.jpg", Url = "#", DisplayOrder = 2, GroupAlias = "top", Active = true
},
new Slide()
{
Name = "Slide 01", Image = "/client-side/images/brand1.png", Url = "#", DisplayOrder = 1, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 02", Image = "/client-side/images/brand2.png", Url = "#", DisplayOrder = 2, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 03", Image = "/client-side/images/brand3.png", Url = "#", DisplayOrder = 3, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 04", Image = "/client-side/images/brand4.png", Url = "#", DisplayOrder = 4, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 05", Image = "/client-side/images/brand5.png", Url = "#", DisplayOrder = 5, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 06", Image = "/client-side/images/brand6.png", Url = "#", DisplayOrder = 6, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 07", Image = "/client-side/images/brand7.png", Url = "#", DisplayOrder = 7, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 08", Image = "/client-side/images/brand8.png", Url = "#", DisplayOrder = 8, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 09", Image = "/client-side/images/brand9.png", Url = "#", DisplayOrder = 9, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 10", Image = "/client-side/images/brand10.png", Url = "#", DisplayOrder = 10, GroupAlias = "brand", Active = true
},
new Slide()
{
Name = "Slide 11", Image = "/client-side/images/brand11.png", Url = "#", DisplayOrder = 11, GroupAlias = "brand", Active = true
},
};
_context.Slides.AddRange(slides);
}
if (!_context.SystemConfigs.Any(x => x.Id == "HomeTitle"))
{
_context.SystemConfigs.Add(new SystemConfig()
{
Id = "HomeTitle",
Name = "Home's title",
Value1 = "Gym Nutri",
Active = true
});
}
if (!_context.SystemConfigs.Any(x => x.Id == "HomeMetaKeyword"))
{
_context.SystemConfigs.Add(new SystemConfig()
{
Id = "HomeMetaKeyword",
Name = "Home Keyword",
Value1 = "Gym, Nutrition",
Active = true
});
}
if (!_context.SystemConfigs.Any(x => x.Id == "HomeMetaDescription"))
{
_context.SystemConfigs.Add(new SystemConfig()
{
Id = "HomeMetaDescription",
Name = "Home Description",
Value1 = "Home Gym nutrition",
Active = true
});
}
if (_context.AdvertisementPages.Count() == 0)
{
List <AdvertisementPage> pages = new List <AdvertisementPage>()
{
new AdvertisementPage()
{
Id = "home", Name = "Home", AdvertisementPositions = new List <AdvertisementPosition>()
{
new AdvertisementPosition()
{
Id = "home-left", Name = "Bên trái"
}
}
},
new AdvertisementPage()
{
Id = "product-cate", Name = "Product category",
AdvertisementPositions = new List <AdvertisementPosition>()
{
new AdvertisementPosition()
{
Id = "product-cate-left", Name = "Bên trái"
}
}
},
new AdvertisementPage()
{
Id = "product-detail", Name = "Product detail",
AdvertisementPositions = new List <AdvertisementPosition>()
{
new AdvertisementPosition()
{
Id = "product-detail-left", Name = "Bên trái"
}
}
},
};
_context.AdvertisementPages.AddRange(pages);
}
if (_context.BodyClassifications.Count() == 0)
{
List <BodyClassification> bodyClassifications = new List <BodyClassification>()
{
new BodyClassification()
{
GroupCode = "BodyType",
Code = "Ectomorph",
Name = "Ectomorph",
Description = "Tạng người gầy",
Active = true
},
new BodyClassification()
{
GroupCode = "BodyType",
Code = "Mesomorph",
Name = "Mesomorph",
Description = "Tạng người cơ bắp",
Active = true
},
new BodyClassification()
{
GroupCode = "BodyType",
Code = "Endomorph",
Name = "Endomorph",
Description = "Tạng người béo",
Active = true
}
};
_context.BodyClassifications.AddRange(bodyClassifications);
}
if (_context.CommonCategories.Count() == 0)
{
List <CommonCategory> commonCategories = new List <CommonCategory>()
{
new CommonCategory()
{
GroupCode = "FoodType",
Code = "Eating",
Name = "Đồ ăn",
Active = true,
UserCreated = "*****@*****.**"
},
new CommonCategory()
{
GroupCode = "FoodType",
Code = "Beverage",
Name = "Đồ uống",
Active = true,
UserCreated = "*****@*****.**"
}
};
_context.CommonCategories.AddRange(commonCategories);
}
if (_context.FoodCategories.Count() == 0)
{
List <FoodCategory> foodCategories = new List <FoodCategory>()
{
new FoodCategory()
{
Code = "main",
Name = "Món chính",
FoodTypeCode = "Eating",
OrderNo = 1,
Active = true,
UserCreated = "*****@*****.**"
}
};
_context.FoodCategories.AddRange(foodCategories);
}
if (_context.Foods.Count() == 0)
{
List <Food> foods = new List <Food>()
{
new Food()
{
Code = "beef",
Name = "Thịt bò xào tổng hợp",
FoodCategoryId = 1,
Description = "Món ăn quen thuộc nhưng để làm ngon cũng không phải là dễ dàng",
UserCreated = "*****@*****.**",
Active = true
},
new Food()
{
Code = "chicken",
Name = "Gà xào xả ớt",
FoodCategoryId = 1,
Description = "Ngon ngon, lạ miệng, dễ làm",
UserCreated = "*****@*****.**",
Active = true
}
};
_context.Foods.AddRange(foods);
}
if (_context.StatusCategories.Count() == 0)
{
List <StatusCategory> statusCategories = new List <StatusCategory>()
{
new StatusCategory()
{
Code = "vip",
Name = "Vip",
OrderNo = 1,
Table = "User",
Active = true
},
new StatusCategory()
{
Code = "done",
Name = "Done",
OrderNo = 1,
Table = "Order",
Active = true
}
};
_context.StatusCategories.AddRange(statusCategories);
}
await _context.SaveChangesAsync();
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "rro ao tentar recuperar informações do provedor externo.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
using var transaction = _context.Database.BeginTransaction();
var result = await _userManager.CreateAsync(user);
await _userManager.AddToRoleAsync(user, "ADMIN");
transaction.Commit();
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("Usuario criado com o provedor {Name}.", info.LoginProvider);
/*var userId = await _userManager.GetUserIdAsync(user);
* var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
* code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
* var callbackUrl = Url.Page(
* "/Account/ConfirmEmail",
* pageHandler: null,
* values: new { area = "Identity", userId = userId, 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>.");
*
* // If account confirmation is required, we need to show the link if we don't have a real email sender
* if (_userManager.Options.SignIn.RequireConfirmedAccount)
* {
* return RedirectToPage("./RegisterConfirmation", new { Email = Input.Email });
* }*/
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
public static void SeedUsers(UserManager <MyUser> userManager)
{
// admin
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser admin = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
DepartmentId = 1
};
IdentityResult result = userManager.CreateAsync(admin, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(admin, "Admin").Wait();
userManager.AddToRoleAsync(admin, "Manager").Wait();
userManager.AddToRoleAsync(admin, "Employee").Wait();
}
}
// manager (IT department - 1), employee
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser manager = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Aris",
LastName = "Kallergis",
CostPerHour = 20,
DepartmentId = 1
};
IdentityResult result = userManager.CreateAsync(manager, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(manager, "Manager").Wait();
userManager.AddToRoleAsync(manager, "Employee").Wait();
}
}
// manager (R&D department - 2), employee
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser manager = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Mary",
LastName = "Ksenou",
CostPerHour = 20,
DepartmentId = 2
};
IdentityResult result = userManager.CreateAsync(manager, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(manager, "Manager").Wait();
userManager.AddToRoleAsync(manager, "Employee").Wait();
}
}
// manager (R&D department - 2), employee
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser manager = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Nikos",
LastName = "Dimitriou",
CostPerHour = 20,
DepartmentId = 2
};
IdentityResult result = userManager.CreateAsync(manager, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(manager, "Manager").Wait();
userManager.AddToRoleAsync(manager, "Employee").Wait();
}
}
// manager (HR department - 3), employee
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser manager = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Xrysa",
LastName = "Xrystopoulou",
CostPerHour = 20,
DepartmentId = 3
};
IdentityResult result = userManager.CreateAsync(manager, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(manager, "Manager").Wait();
userManager.AddToRoleAsync(manager, "Employee").Wait();
}
}
// manager (Accounting department - 4), employee
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser manager = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Mike",
LastName = "Scott",
CostPerHour = 20,
DepartmentId = 4
};
IdentityResult result = userManager.CreateAsync(manager, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(manager, "Manager").Wait();
userManager.AddToRoleAsync(manager, "Employee").Wait();
}
}
// employee (with manager Admin)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Charalampos",
LastName = "Makrylakis",
CostPerHour = 10,
DepartmentId = 1,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Aris
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Mary)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Kostas",
LastName = "Tsak",
CostPerHour = 10,
DepartmentId = 2,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Mary
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Mary)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Dimitris",
LastName = "Pitsios",
CostPerHour = 10,
DepartmentId = 2,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Mary
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Nikos)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Iosif",
LastName = "Gemenitzoglou",
CostPerHour = 10,
DepartmentId = 2,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Nikos (manager)
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Nikos)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Iosif",
LastName = "Gemenitzoglou",
CostPerHour = 10,
DepartmentId = 2,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Nikos (manager)
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Aris)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Eleni",
LastName = "Vasileiou",
CostPerHour = 10,
DepartmentId = 1,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Aris
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Xrysa)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Kostis",
LastName = "Konstantinou",
CostPerHour = 10,
DepartmentId = 3,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Xrysa
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
// employee (with manager Mike)
if (userManager.FindByEmailAsync("*****@*****.**").Result == null)
{
MyUser employee = new MyUser
{
UserName = "******",
Email = "*****@*****.**",
EmailConfirmed = true,
FirstName = "Ntinos",
LastName = "Sadikis",
CostPerHour = 10,
DepartmentId = 4,
ManagerId = userManager.FindByEmailAsync("*****@*****.**").Result.Id // Id of Mike
};
IdentityResult result = userManager.CreateAsync(employee, "111111").Result;
if (result.Succeeded)
{
userManager.AddToRoleAsync(employee, "Employee").Wait();
}
}
}
public async Task <IActionResult> SeedRoles()
{
ApplicationUser user1 = new ApplicationUser {
Email = "*****@*****.**", UserName = "******", FirstName = "Jack", LastName = "Ryan", BirthDate = DateTime.Now, Company = "CIA", Position = "Analyst"
};
ApplicationUser user2 = new ApplicationUser {
Email = "*****@*****.**", UserName = "******", FirstName = "Manoj", LastName = "Bajpai", BirthDate = DateTime.Now, Company = "NSA", Position = "Senior Analyst"
};
IdentityResult result = await _userManager.CreateAsync(user1, "Password1!");
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new user"
}));
}
result = await _userManager.CreateAsync(user2, "Password1!");
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new user"
}));
}
result = await _roleManager.CreateAsync(new IdentityRole("Supervisor"));
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new Roles"
}));
}
result = await _roleManager.CreateAsync(new IdentityRole("Employee"));
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new Roles"
}));
}
result = await _userManager.AddToRoleAsync(user1, "Supervisor");
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new role"
}));
}
result = await _userManager.AddToRoleAsync(user2, "Employee");
if (!result.Succeeded)
{
return(View("Error", new ErrorViewModel {
RequestId = "Failed to add new role"
}));
}
return(RedirectToAction("Index", "Home"));
}
public async Task AddUserToRoleAsync(User user, string roleName)
{
await _userManager.AddToRoleAsync(user, roleName);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
Nombre = Input.Nombre,
Ciudad = Input.Ciudad,
Pais = Input.Pais,
Direccion = Input.Direccion,
PhoneNumber = Input.PhoneNumber,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(CNT.Admin))
{
await _roleManager.CreateAsync(new IdentityRole(CNT.Admin));
await _roleManager.CreateAsync(new IdentityRole(CNT.Usuario));
}
string rol = Request.Form["radUsuarioRole"].ToString();
if (rol == CNT.Admin)
{
await _userManager.AddToRoleAsync(user, CNT.Admin);
}
else
{
if (rol == CNT.Usuario)
{
await _userManager.AddToRoleAsync(user, CNT.Usuario);
}
}
_logger.LogInformation("User created a new account with password.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
//var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { area = "Identity", 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>.");
//if (_userManager.Options.SignIn.RequireConfirmedAccount)
//{
// return RedirectToPage("RegisterConfirmation", new { email = Input.Email });
//}
//else
//{
// 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 async Task Initialize(BackendContext context)
{
IdentityRole admin;
// var tmp = context.Users.ToList();
// var tmp2 = context.Roles.ToList();
// var tmp3 = context.Roles.Any(r => r.Name == "Admin");
if (!context.Roles.Any(r => r.Name == "Admin"))
{
admin = new IdentityRole
{
Name = "Admin",
NormalizedName = "ADMIN"
};
await context.Roles.AddAsync(admin);
await context.SaveChangesAsync();
}
else
{
admin = await context.Roles.FirstOrDefaultAsync(r => r.Name == "Admin");
}
IdentityRole member;
if (!context.Roles.Any(r => r.Name == "Member"))
{
member = new IdentityRole
{
Name = "Member",
NormalizedName = "MEMBER"
};
await context.Roles.AddAsync(member);
await context.SaveChangesAsync();
}
else
{
member = await context.Roles.FirstOrDefaultAsync(r => r.Name == "Member");
}
IdentityResult result;
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var user = new IdentityUser
{
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
UserName = "******",
EmailConfirmed = true,
};
result = await _userManager.CreateAsync(user, "herpDerp1!");
await context.SaveChangesAsync();
result = await _userManager.AddToRoleAsync(user, admin.Name);
context.SaveChangesAsync().Wait();
}
if (!context.Users.Any(u => u.Email == "*****@*****.**"))
{
var memberUser = new IdentityUser
{
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
UserName = "******",
EmailConfirmed = true,
LockoutEnabled = false,
NormalizedUserName = "******",
};
result = await _userManager.CreateAsync(memberUser, "herpDerp1!");
await context.SaveChangesAsync();
result = await _userManager.AddToRoleAsync(memberUser, member.Name);
await context.SaveChangesAsync();
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
var role = Request.Form["userRole"].ToString();
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
PhoneNumber = Input.PhoneNumber
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
if (role == Sd.KitchenRole)
{
await _userManager.AddToRoleAsync(user, Sd.KitchenRole);
}
if (role == Sd.ManagerRole)
{
await _userManager.AddToRoleAsync(user, Sd.ManagerRole);
}
if (role == Sd.FrontDeskRole)
{
await _userManager.AddToRoleAsync(user, Sd.FrontDeskRole);
}
else
{
await _userManager.AddToRoleAsync(user, Sd.CusomerRole);
}
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
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>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
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 async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
int roleId = Convert.ToInt32(model.RoleId);
//int roleId = 22;
//Entities db = new Entities();
if (roleId == 0)
{
//var doctor = new Doctor();
var user = new ApplicationUser()
{
UserName = model.UserName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, "Doctor");
//doctor.LoginId = user.Id;
//doctor.HospitalId = 1;
//db.Doctors.Add(doctor);
//db.SaveChanges();
//Session["DoctorId"] = doctor.DoctorId;
await SignInAsync(user, isPersistent : false);
//return RedirectToAction("Edit", "Doctor", new { id = doctor.DoctorId });
}
else
{
AddErrors(result);
}
}
else if (roleId == 1)
{
//var collegian = new Collegian();
var user = new ApplicationUser()
{
UserName = model.UserName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, "Collegian");
//collegian = new Collegian();
//collegian.LoginId = user.Id;
//collegian.UniversityId = 1;
//db.Collegians.Add(collegian);
//db.SaveChanges();
//Session["CollegianId"] = collegian.CollegianId;
//await SignInAsync(user, isPersistent: false);
//return RedirectToAction("Edit", "Collegian", new { id = collegian.CollegianId });
}
else
{
AddErrors(result);
}
}
else if (roleId == 22)//set user as admin role
{
var user = new ApplicationUser()
{
UserName = model.UserName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, "Admin");
await SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private async Task BuildForInternalAsync(Tenant tenant)
{
//Create Organization Units
var organizationUnits = new List <OrganizationUnit>();
var producing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Producing");
var researchAndDevelopment = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Research & Development", producing);
var ivrProducts = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "IVR Related Products", researchAndDevelopment);
var voiceTech = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Voice Technologies", researchAndDevelopment);
var inhouseProjects = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Inhouse Projects", researchAndDevelopment);
var qualityManagement = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Quality Management", producing);
var testing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Testing", producing);
var selling = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Selling");
var marketing = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Marketing", selling);
var sales = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Sales", selling);
var custRelations = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Customer Relations", selling);
var supporting = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Supporting");
var buying = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Buying", supporting);
var humanResources = await CreateAndSaveOrganizationUnit(organizationUnits, tenant, "Human Resources", supporting);
//Create users
var users = _randomUserGenerator.GetRandomUsers(RandomHelper.GetRandom(12, 26), tenant.Id);
foreach (var user in users)
{
//Create the user
await _userManager.CreateAsync(user);
await CurrentUnitOfWork.SaveChangesAsync();
//Add to roles
await _userManager.AddToRoleAsync(user, StaticRoleNames.Tenants.User);
//Add to OUs
var randomOus = RandomHelper.GenerateRandomizedList(organizationUnits).Take(RandomHelper.GetRandom(0, 3));
foreach (var ou in randomOus)
{
await _userManager.AddToOrganizationUnitAsync(user, ou);
}
//Set profile picture
if (RandomHelper.GetRandom(100) < 70) //A user will have a profile picture in 70% probability.
{
await SetRandomProfilePictureAsync(user);
}
}
//Set a picture to admin!
var admin = await _userManager.FindByNameAsync(AbpUserBase.AdminUserName);
await SetRandomProfilePictureAsync(admin);
//Create Friendships
var friends = RandomHelper.GenerateRandomizedList(users).Take(3).ToList();
foreach (var friend in friends)
{
await _friendshipManager.CreateFriendshipAsync(
new Friendship(
admin.ToUserIdentifier(),
friend.ToUserIdentifier(),
tenant.TenancyName,
friend.UserName,
friend.ProfilePictureId,
FriendshipState.Accepted)
);
await _friendshipManager.CreateFriendshipAsync(
new Friendship(
friend.ToUserIdentifier(),
admin.ToUserIdentifier(),
tenant.TenancyName,
admin.UserName,
admin.ProfilePictureId,
FriendshipState.Accepted)
);
}
//Create chat message
var friendWithMessage = RandomHelper.GenerateRandomizedList(friends).First();
var sharedMessageId = Guid.NewGuid();
_chatMessageRepository.InsertAndGetId(
new ChatMessage(
friendWithMessage.ToUserIdentifier(),
admin.ToUserIdentifier(),
ChatSide.Sender,
L("Demo_SampleChatMessage"),
ChatMessageReadState.Read,
sharedMessageId,
ChatMessageReadState.Unread
)
);
_chatMessageRepository.InsertAndGetId(
new ChatMessage(
admin.ToUserIdentifier(),
friendWithMessage.ToUserIdentifier(),
ChatSide.Receiver,
L("Demo_SampleChatMessage"),
ChatMessageReadState.Unread,
sharedMessageId,
ChatMessageReadState.Read
)
);
}
//.net core 2.1
/* private readonly DataContext _context;
* public Seed(DataContext context)
* {
* _context = context;
* } */
public static async Task SeedUsers(UserManager <AppUser> userManager, RoleManager <AppRole> roleManager)
{
if (!await userManager.Users.AnyAsync())
{
var userData = System.IO.File.ReadAllText("Data/UserSeedData.json");
var users = JsonConvert.DeserializeObject <List <AppUser> >(userData);
var roles = new List <AppRole>
{
new AppRole {
Name = "Member"
},
new AppRole {
Name = "Admin"
},
new AppRole {
Name = "Moderator"
},
};
foreach (var role in roles)
{
await roleManager.CreateAsync(role);
}
foreach (var user in users)
{
/*byte[] passwordHash, passwordSalt;*/
/*CreatePasswordHash("password", out passwordHash, out passwordSalt);
*
* user.PasswordHash = passwordHash;
* user.PasswordSalt = passwordSalt;*/
user.UserName = user.UserName.ToLower();
foreach (var ca in user.ClassifiedAds)
{
ca.DateAdded = DateTime.Now;
ca.Status = "Approved";
foreach (var photo in ca.Photos)
{
photo.Status = "Approved";
}
}
await userManager.CreateAsync(user, "Password123");
await userManager.AddToRoleAsync(user, "Member");
}
var admin = new AppUser
{
UserName = "******",
City = "Veles"
};
await userManager.CreateAsync(admin, "P@ssw0rd");
await userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" });
}
}
public async Task <ActionResult> Register(RegisterViewModel rvm)
{
if (rvm.Birthday.AddYears(13) >= DateTime.Now && rvm.EmployeeAccountType != true)
{
ModelState.AddModelError("", "You are too young to have an account. You must be at least 13 to register for this site.");
}
else if (rvm.Birthday.AddYears(18) >= DateTime.Now && rvm.EmployeeAccountType == true)
{
ModelState.AddModelError("", "The user is too young to be an employee. They must be at least 18 or older.");
}
var emailPassword = rvm.Password;
//if registration data is valid, create a new user on the database
if (ModelState.IsValid)
{
//this code maps the RegisterViewModel to the AppUser domain model
AppUser newUser = new AppUser
{
UserName = rvm.Email,
Email = rvm.Email,
PhoneNumber = rvm.PhoneNumber,
//TODO: Add the rest of the custom user fields here
//FirstName is included as an example
FirstName = rvm.FirstName,
MiddleInitial = rvm.MiddleInitial,
LastName = rvm.LastName,
Address = rvm.FirstName,
City = rvm.City,
State = rvm.State,
Zip = rvm.Zip,
Birthday = rvm.Birthday,
PCPBalance = rvm.PCPBalance,
AccountStatus = true,
};
//This code uses the UserManager object to create a new user with the specified password
IdentityResult result = await _userManager.CreateAsync(newUser, rvm.Password);
//If the add user operation was successful, we need to do a few more things
if (result.Succeeded && User.IsInRole("Manager"))
{
if (rvm.CustomerAccountType == false && rvm.EmployeeAccountType == true)
{
//adds to employee role
await _userManager.AddToRoleAsync(newUser, "Employee");
}
else
{
//adds to customer role
await _userManager.AddToRoleAsync(newUser, "Customer");
}
//NOTE: This code logs the user into the account that they just created
//You may or may not want to log a user in directly after they register - check
//the business rules!
//Microsoft.AspNetCore.Identity.SignInResult result2 = await _signInManager.PasswordSignInAsync(rvm.Email, rvm.Password, false, lockoutOnFailure: false);
//Send the user to the home page
return(RedirectToAction("AccountCreation", "Email", new { newUser.Id, emailPassword }));
}
if (result.Succeeded != User.IsInRole("Manager"))
{
//TODO: Add user to desired role. This example adds the user to the customer role
await _userManager.AddToRoleAsync(newUser, "Customer");
//NOTE: This code logs the user into the account that they just created
//You may or may not want to log a user in directly after they register - check
//the business rules!
Microsoft.AspNetCore.Identity.SignInResult result2 = await _signInManager.PasswordSignInAsync(rvm.Email, rvm.Password, false, lockoutOnFailure : false);
//Send the user to the home page
return(RedirectToAction("AccountCreation", "Email", new { newUser.Id, emailPassword }));
}
else //the add user operation didn't work, and we need to show an error message
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
//this is the sad path - something went wrong,
//return the user to the register page to try again
return(View(rvm));
}
/// <summary>
/// Generate default admin user / role
/// </summary>
private static async Task EnsureSeedIdentityData <TUser, TRole>(UserManager <TUser> userManager,
RoleManager <TRole> roleManager, IdentityData identityDataConfiguration)
where TUser : IdentityUser, new()
where TRole : IdentityRole, new()
{
// adding roles from seed
foreach (var r in identityDataConfiguration.Roles)
{
if (!await roleManager.RoleExistsAsync(r.Name))
{
var role = new TRole
{
Name = r.Name
};
var result = await roleManager.CreateAsync(role);
if (result.Succeeded)
{
foreach (var claim in r.Claims)
{
await roleManager.AddClaimAsync(role, new System.Security.Claims.Claim(claim.Type, claim.Value));
}
}
}
}
// adding users from seed
foreach (var user in identityDataConfiguration.Users)
{
var identityUser = new TUser
{
UserName = user.Username,
Email = user.Email,
EmailConfirmed = true
};
var userByUserName = await userManager.FindByNameAsync(user.Username);
var userByEmail = await userManager.FindByEmailAsync(user.Email);
// User is already exists in database
if (userByUserName != default || userByEmail != default)
{
continue;
}
// if there is no password we create user without password
// user can reset password later, because accounts have EmailConfirmed set to true
var result = !string.IsNullOrEmpty(user.Password)
? await userManager.CreateAsync(identityUser, user.Password)
: await userManager.CreateAsync(identityUser);
if (result.Succeeded)
{
foreach (var claim in user.Claims)
{
await userManager.AddClaimAsync(identityUser, new System.Security.Claims.Claim(claim.Type, claim.Value));
}
foreach (var role in user.Roles)
{
await userManager.AddToRoleAsync(identityUser, role);
}
}
}
}
private async Task Seed(IUnitOfWork uow , UserManager<ApplicationUser> usrMan, RoleManager<IdentityRole> _RoleManager)
{
var email = "*****@*****.**";
var RoleName = "CustomerAdmin";
var role = await _RoleManager.FindByNameAsync(RoleName);
if (role == null)
{
role = new IdentityRole { Name = RoleName };
await _RoleManager.CreateAsync(role);
}
RoleName = "superadmin";
role = await _RoleManager.FindByNameAsync( RoleName );
if ( role == null)
{
role = new IdentityRole { Name = "SuperAdmin" };
await _RoleManager.CreateAsync(role);
}
var appUser = await usrMan.FindByEmailAsync(email);
if (appUser != null)
{
var result = await usrMan.DeleteAsync(appUser);
}
else
{
appUser = new ApplicationUser() { UserName = email, Email = email };
var result2 = await usrMan.CreateAsync(appUser, "Shafiro2,");
if (result2.Succeeded)
{
await usrMan.AddToRoleAsync(appUser, RoleName );
var hrmUser = new User()
{
UserID = "7310209296",
FirstName = "Gabriel",
LastName = "Tekin",
UserName = "******",
UserCode = "tekgab",
PhoneNumber = "0702385537"
};
if (uow.UserRepository.GetEagerLoad( w => w.UserID.Equals( hrmUser.UserID, StringComparison.OrdinalIgnoreCase )).FirstOrDefault() == null )
{
uow.UserRepository.Insert(hrmUser);
uow.Save();
}
}
else
{
var code = result2.Errors.FirstOrDefault().Code;
}
}
} // method seed
private static void AddUsersToRoles(UserManager<ApplicationUser> users, RoleManager<ApplicationRole> roleManager)
{
var admin = users.FindByEmailAsync("*****@*****.**").Result;
var esthetician = users.FindByEmailAsync("*****@*****.**").Result;
Task.FromResult(users.AddToRolesAsync(admin, new[] { "Admin", "Esthetician" }).Result);
Task.FromResult(users.AddToRoleAsync(esthetician, "Esthetician").Result);
}
public async Task <ApiResponse> Create(RegisterDto parameters)
{
try
{
if (!ModelState.IsValid)
{
return(new ApiResponse(400, "User Model is Invalid"));
}
var user = new ApplicationUser
{
UserName = parameters.UserName,
Email = parameters.Email
};
user.UserName = parameters.UserName;
var result = await _userManager.CreateAsync(user, parameters.Password);
if (!result.Succeeded)
{
return(new ApiResponse(400, "Register User Failed: " + result.Errors.FirstOrDefault()?.Description));
}
else
{
var claimsResult = _userManager.AddClaimsAsync(user, new Claim[] {
new Claim(Policies.IsUser, ""),
new Claim(JwtClaimTypes.Name, parameters.UserName),
new Claim(JwtClaimTypes.Email, parameters.Email),
new Claim(JwtClaimTypes.EmailVerified, "false", ClaimValueTypes.Boolean)
}).Result;
}
//Role - Here we tie the new user to the "User" role
await _userManager.AddToRoleAsync(user, "User");
if (Convert.ToBoolean(_configuration["BlazorBoilerplate:RequireConfirmedEmail"] ?? "false"))
{
#region New User Confirmation Email
try
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = string.Format("{0}/Account/ConfirmEmail/{1}?token={2}", _configuration["BlazorBoilerplate:ApplicationUrl"], user.Id, token);
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email = EmailTemplates.BuildNewUserConfirmationEmail(email, user.UserName, user.Email, callbackUrl, user.Id.ToString(), token); //Replace First UserName with Name if you want to add name to Registration Form
_logger.LogInformation("New user created: {0}", user);
await _emailService.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
#endregion
return(new ApiResponse(200, "Create User Success"));
}
#region New User Email
try
{
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email.BuildNewUserEmail(user.FullName, user.UserName, user.Email, parameters.Password);
_logger.LogInformation("New user created: {0}", user);
await _emailService.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
#endregion
UserInfoDto userInfo = new UserInfoDto
{
IsAuthenticated = false,
UserName = user.UserName,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
//ExposedClaims = user.Claims.ToDictionary(c => c.Type, c => c.Value),
Roles = new List <string> {
"User"
}
};
return(new ApiResponse(200, "Created New User", userInfo));
}
catch (Exception ex)
{
_logger.LogError("Create User Failed: {0}", ex.Message);
return(new ApiResponse(400, "Create User Failed"));
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new SammysAutoApplicationUser
{
UserName = Input.Email,
Email = Input.Email,
FirstName = Input.FirstName,
LastName = Input.LastName,
Address = Input.Address,
City = Input.City,
PostalCode = Input.PostalCode,
PhoneNumber = Input.PhoneNumber
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(SD.CustomerEndUser))
{
await _roleManager.CreateAsync(new SammysAutoApplicationRole(SD.CustomerEndUser));
}
if (!await _roleManager.RoleExistsAsync(SD.AdminEndUser))
{
await _roleManager.CreateAsync(new SammysAutoApplicationRole(SD.AdminEndUser));
}
await _userManager.AddToRoleAsync(user, SD.AdminEndUser);
//if (Input.IsAdmin)
//{
//}
//else
//{
// await _userManager.AddToRoleAsync(user, SD.CustomerEndUser);
//}
_logger.LogInformation("User created a new account with password.");
if (User.IsInRole(SD.AdminEndUser))
{
return(RedirectToAction("Index", "Users"));
}
else
{
var userDetails = await _userManager.FindByEmailAsync(Input.Email);
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Cars", new { userId = userDetails.Id }));
}
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
//var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
// 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>.");
//if (_userManager.Options.SignIn.RequireConfirmedAccount)
//{
// return RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl });
//}
//else
//{
// 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 async Task<ActionResult> AddUserToRole(string roleName)
{
var userStore = new UserStore<IdentityUser>();
var userManager = new UserManager<IdentityUser>(userStore);
var roleStore = new RoleStore<IdentityRole>();
var roleManager = new RoleManager<IdentityRole>(roleStore);
var role = await roleManager.FindByNameAsync(roleName);
if (role == null)
{
return View();
}
await userManager.AddToRoleAsync(User.Identity.GetUserId(), roleName);
return RedirectToAction("index", "home");
}
public async Task <IActionResult> Put([FromBody] UserViewModel model)
{
// return a generic HTTP Status 500 (Server Error)
// if the client payload is invalid.
if (model == null)
{
return(new StatusCodeResult(500));
}
// check if the Username/Email already exists
ApplicationUser user = await UserManager.FindByNameAsync(model.UserName);
if (user != null)
{
return(BadRequest("Username already exists"));
}
user = await UserManager.FindByEmailAsync(model.Email);
if (user != null)
{
return(BadRequest("Email already exists."));
}
// added in 2018.01.06 to fix GitHub issue #11
// ref.: https://github.com/PacktPublishing/ASP.NET-Core-2-and-Angular-5/issues/11
if (!PasswordCheck.IsValidPassword(model.Password, UserManager.Options.Password))
{
return(BadRequest("Password is too weak."));
}
var now = DateTime.Now;
// create a new Item with the client-sent json data
user = new ApplicationUser()
{
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.UserName,
Email = model.Email,
DisplayName = model.DisplayName,
CreatedDate = now,
LastModifiedDate = now
};
// Add the user to the Db with the choosen password
await UserManager.CreateAsync(user, model.Password);
// Assign the user to the 'RegisteredUser' role.
await UserManager.AddToRoleAsync(user, "RegisteredUser");
// Remove Lockout and E-Mail confirmation
user.EmailConfirmed = true;
user.LockoutEnabled = false;
// persist the changes into the Database.
DbContext.SaveChanges();
// return the newly-created User to the client.
return(Json(user.Adapt <UserViewModel>(),
JsonSettings));
}
/// <summary>
/// remove all current permission for the given user and insert new given permissions.
/// </summary>
/// <param name="newRoles">Accepts a list of RolesName type string</param>
/// <param name="UserID">Accepts a 128 chr userID type string</param>
/// <returns></returns>
public async Task<string> EditbuildingUserPermission(List<string> newRoles, string UserID)
{
var result = "";
var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
//get all roles for the current user
List<string> AllRoles = UserManager.GetRoles(UserID).ToList();
//delete all the roles
foreach (var item in AllRoles)
{
await UserManager.RemoveFromRoleAsync(UserID, item);
}
//add new roles
foreach (var item in newRoles)
{
if (RoleManager.RoleExists(item))
{
await UserManager.AddToRoleAsync(UserID, item);
}
}
return result;
}
public async Task <IActionResult> CreateAdminIfDoesntExist(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new Korisnik
{
UserName = "******",
Email = "*****@*****.**",
Name = "Admin",
Surname = "Admin",
JMBAG = "111111111",
};
//var result = await _userManager.CreateAsync(user, "Admin1234");
var result = await _signInManager.PasswordSignInAsync(user.Email, "Admin1234", false, false);
if (!result.Succeeded)
{
var creationResult = await _userManager.CreateAsync(user, "Admin1234");
if (creationResult.Succeeded)
{
if (!await _roleManager.RoleExistsAsync(StaticDetails.AdminRole))
{
await _roleManager.CreateAsync(new IdentityRole(StaticDetails.AdminRole));
}
if (!await _roleManager.RoleExistsAsync(StaticDetails.ProfessorRole))
{
await _roleManager.CreateAsync(new IdentityRole(StaticDetails.ProfessorRole));
}
if (!await _roleManager.RoleExistsAsync(StaticDetails.StudentRole))
{
await _roleManager.CreateAsync(new IdentityRole(StaticDetails.StudentRole));
}
await _userManager.AddToRoleAsync(user, StaticDetails.AdminRole);
_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 _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
}
// If we got this far, something failed, redisplay form
//return null;
return(new OkResult());
}
public async Task ValidateAsync(ExtensionGrantValidationContext context)
{
var createUser = false;
var raw = context.Request.Raw;
var credential = raw.Get(OidcConstants.TokenRequest.GrantType);
if (credential != null && credential == AuthConstants.GrantType.PhoneNumberToken)
{
var phoneNumber = raw.Get(AuthConstants.TokenRequest.PhoneNumber);
var verificationToken = raw.Get(AuthConstants.TokenRequest.Token);
var user = await _userManager.Users.SingleOrDefaultAsync(x => x.PhoneNumber == _userManager.NormalizeKey(phoneNumber));
if (user == null)
{
user = new User
{
UserName = phoneNumber,
PhoneNumber = phoneNumber,
SecurityStamp = phoneNumber.Sha256()
};
createUser = true;
}
var result = await _phoneNumberTokenProvider.ValidateAsync("verify_number", verificationToken, _userManager, user);
if (result)
{
if (createUser)
{
user.PhoneNumberConfirmed = true;
var resultCreation = await _userManager.CreateAsync(user);
if (resultCreation != IdentityResult.Success)
{
_logger.LogInformation("User creation failed: {username}, reason: invalid user", phoneNumber);
await _events.RaiseAsync(new UserLoginFailureEvent(phoneNumber, resultCreation.Errors.Select(x => x.Description).Aggregate((a, b) => a + ", " + b), false));
return;
}
var resultAssignedRole = await _userManager.AddToRoleAsync(user, UserRole.UserRoleName);
if (resultAssignedRole != IdentityResult.Success)
{
_logger.LogInformation(" Assign User to role failed: {username}, reason: invalid user", phoneNumber);
await _events.RaiseAsync(new UserLoginFailureEvent(phoneNumber, resultCreation.Errors.Select(x => x.Description).Aggregate((a, b) => a + ", " + b), false));
return;
}
}
_logger.LogInformation("Credentials validated for username: {phoneNumber}", phoneNumber);
await _events.RaiseAsync(new UserLoginSuccessEvent(phoneNumber, user.Id.ToString(), phoneNumber, false));
await _signInManager.SignInAsync(user, true);
context.Result = new GrantValidationResult(user.Id.ToString(), OidcConstants.AuthenticationMethods.ConfirmationBySms);
}
else
{
_logger.LogInformation("Authentication failed for token: {token}, reason: invalid token", verificationToken);
await _events.RaiseAsync(new UserLoginFailureEvent(verificationToken, "invalid token or verification id", false));
}
}
else
{
context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid verify_phone_number_token credential");
}
}
public async Task <int> CreateWithAdminUserAsync(
string tenancyName,
string name,
string adminPassword,
string adminEmailAddress,
string connectionString,
bool isActive,
int?editionId,
bool shouldChangePasswordOnNextLogin,
bool sendActivationEmail,
DateTime?subscriptionEndDate,
bool isInTrialPeriod,
string emailActivationLink)
{
int newTenantId;
long newAdminId;
await CheckEditionAsync(editionId, isInTrialPeriod);
using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
{
//Create tenant
var tenant = new Tenant(tenancyName, name)
{
IsActive = isActive,
EditionId = editionId,
SubscriptionEndDateUtc = subscriptionEndDate?.ToUniversalTime(),
IsInTrialPeriod = isInTrialPeriod,
ConnectionString = connectionString.IsNullOrWhiteSpace() ? null : SimpleStringCipher.Instance.Encrypt(connectionString)
};
await CreateAsync(tenant);
await _unitOfWorkManager.Current.SaveChangesAsync(); //To get new tenant's id.
//Create tenant database
_abpZeroDbMigrator.CreateOrMigrateForTenant(tenant);
//We are working entities of new tenant, so changing tenant filter
using (_unitOfWorkManager.Current.SetTenantId(tenant.Id))
{
//Create static roles for new tenant
CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
await _unitOfWorkManager.Current.SaveChangesAsync(); //To get static role ids
//grant all permissions to admin role
var adminRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.Admin);
await _roleManager.GrantAllPermissionsAsync(adminRole);
//User role should be default
var userRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.User);
userRole.IsDefault = true;
CheckErrors(await _roleManager.UpdateAsync(userRole));
//Create admin user for the tenant
if (adminPassword.IsNullOrEmpty())
{
adminPassword = User.CreateRandomPassword();
}
var adminUser = User.CreateTenantAdminUser(tenant.Id, adminEmailAddress);
adminUser.Password = _passwordHasher.HashPassword(adminUser, adminPassword);
adminUser.ShouldChangePasswordOnNextLogin = shouldChangePasswordOnNextLogin;
adminUser.IsActive = true;
CheckErrors(await _userManager.CreateAsync(adminUser));
await _unitOfWorkManager.Current.SaveChangesAsync(); //To get admin user's id
//Assign admin user to admin role!
CheckErrors(await _userManager.AddToRoleAsync(adminUser, adminRole.Name));
//Notifications
await _appNotifier.WelcomeToTheApplicationAsync(adminUser);
//Send activation email
if (sendActivationEmail)
{
adminUser.SetNewEmailConfirmationCode();
await _userEmailer.SendEmailActivationLinkAsync(adminUser, emailActivationLink, adminPassword);
}
await _unitOfWorkManager.Current.SaveChangesAsync();
await _demoDataBuilder.BuildForAsync(tenant);
newTenantId = tenant.Id;
newAdminId = adminUser.Id;
}
await uow.CompleteAsync();
}
//Used a second UOW since UOW above sets some permissions and _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync needs these permissions to be saved.
using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
{
using (_unitOfWorkManager.Current.SetTenantId(newTenantId))
{
await _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync(new UserIdentifier(newTenantId, newAdminId));
await _unitOfWorkManager.Current.SaveChangesAsync();
await uow.CompleteAsync();
}
}
return(newTenantId);
}
public async Task <IdentityResult> AddToRoleAsync(ApplicationUser user, string role)
{
return(await _userManager.AddToRoleAsync(user, role));
}
public static async Task SeedUsers(UserManager <AppUser> userMgr)
{
// add Admin
if (await userMgr.FindByEmailAsync("*****@*****.**") == null)
{
var user = new AppUser()
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Firstname = "admin",
Email = "*****@*****.**"
};
var userResult = await userMgr.CreateAsync(user, "Docent@1");
var roleResult = await userMgr.AddToRoleAsync(user, "Admin");
if (!userResult.Succeeded || !roleResult.Succeeded)
{
throw new InvalidOperationException("Failed to build admin and add roles");
}
}
// add User
if (await userMgr.FindByEmailAsync("*****@*****.**") == null)
{
var user = new AppUser()
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Firstname = "Victor",
Email = "*****@*****.**"
};
var userResult = await userMgr.CreateAsync(user, "Victor@1");
var roleResult = await userMgr.AddToRoleAsync(user, "User");
if (!userResult.Succeeded || !roleResult.Succeeded)
{
throw new InvalidOperationException("Failed to build admin and add roles");
}
}
if (await userMgr.FindByEmailAsync("*****@*****.**") == null)
{
var user = new AppUser()
{
Id = Guid.NewGuid().ToString(),
UserName = "******",
Firstname = "Victor",
Email = "*****@*****.**"
};
var userResult = await userMgr.CreateAsync(user, "Victor@1");
var roleResult = await userMgr.AddToRoleAsync(user, "Creator");
if (!userResult.Succeeded || !roleResult.Succeeded)
{
throw new InvalidOperationException("Failed to build admin and add roles");
}
}
}
public async Task EnsureDatabaseAsync()
{
await MigrateDatabaseAsync(ServiceProvider);
_userManager = ServiceProvider.GetService<UserManager<ApplicationUser>>();
var roleManager = ServiceProvider.GetService<RoleManager<IdentityRole>>();
await EnsureUsersAsync(false);
Context = ServiceProvider.GetRequiredService<ApplicationDbContext>();
//var userStore = new UserStore<ApplicationUser>(context);
////var roleManager = new RoleManager<IdentityRole>();
//var userManager = new UserManager<ApplicationUser>(
// , );
EnsureDatabaseExists();
Context.Database.EnsureCreated();
// Add Mvc.Client to the known applications.
_productsCrud = new CrudBase<Product, int>(
Context, Context.Products, p => p.ProductId);
_ordersCrud = new CrudBase<Order, int>(
Context, Context.Orders, p => p.Id);
var customersCrud = new CrudBase<Customer, int>(
Context, Context.Customers, p => p.CustomerId);
//Action<string, double, int?, DateTime?, string> prod = (name, price, customerId, dateCreated, cratedByUserId) =>
//{
// productId = Prod(productsCrud, productId, name, price, customerId, dateCreated, cratedByUserId);
//};
Action<string, string, string> cust = (guid, firstName, lastName) =>
{
customersCrud.EnsureEntity(
guid, customer =>
{
customer.FirstName = firstName;
customer.LastName = lastName;
});
};
cust("6c13ec25-b9cf-4c99-87e7-13a45a034342", "Harry", "Whitburn");
cust("0e941f32-8ae1-4eae-875a-f748bae3ce2a", "Nick", "Lawden");
cust("134bd420-f64a-40db-bbe4-0b9a9ff3eb01", "Emil", "Roijer");
Context.SaveChanges();
Prod("00d5c0b0-738d-41ff-86d4-dca84da1d4d5", "Apple number1", 10, null, null);
Prod("cd4c554d-3ca2-49aa-9286-08abacba3fa0", "Apple number1", 10, 1, null, "1");
Prod("d100c753-3335-439c-88db-b8d9b6c09cc8", "Orange number1", 20, null, null);
Prod("da93b8a4-4378-4ce0-918e-653f1bd4acaf", "Peanut butter number1", 25, 2, null);
Prod("fe208521-4a77-4b09-94c2-2f08a4dd8872", "xApple number2", 10, 1, null);
Prod("844fbc16-3d77-4421-9498-aa65300bc789", "xOrange number2", 20, 2, null);
Prod("78509968-0073-4c57-8774-ec0d58ea7ff3", "xPeanut butter number2", 25, 2, null);
Prod("18b8c4e7-48a2-40c7-bea8-1d1879bf852e", "xApple number2", 10, 1, null);
Prod("e5ab744c-441c-447b-ae92-055b1bce5541", "xOrange number2", 20, 2, null);
Prod("3a5476b1-7dd8-40b0-a6ce-b6bd3127da6f", "xPeanut butter number2", 25, 2, null);
Prod("633a125c-1fe2-4f06-859d-a8d8fd52eb11", "xApple number2", 10, 1, null);
Prod("27eea6ff-c4aa-44a0-84fe-32b0e13beec4", "xOrange number2", 20, 2, null);
Prod("dcdc6836-3b44-41c5-8ade-792e39ce2112", "xPeanut butter number2", 25, 2, null);
Prod("fdc3139d-8585-4b34-b815-13598bf55791", "xApple number2", 10, 1, null);
Prod("46b058b2-dd55-4741-9ee0-99c63c4bd94a", "xOrange number2", 20, 2, null);
Prod("11c0e3e5-c5d7-4ff5-ba6c-a54b77f91d1b", "xPeanut butter number2", 25, 2, null);
Prod("796b6b1d-2d6d-413c-bcab-2659c0fdf02f", "Apple number3", 10, 1, null);
Prod("5f928f2f-bc1b-4e73-a0d8-20c36f817342", "Orange number3", 20, 2, null);
Prod("f4fa623d-f412-4b68-8a26-17cfa16cb0a0", "Peanut butter number3", 25, 2, null);
Prod("8f81d6ab-4c8f-4800-aea0-3cb1ca116fc6", "Apple number4", 10, 1, null);
Prod("f2b8032f-c8ac-406f-8038-939201771901", "Orange number4", 20, 2, null);
Prod("dc872dbf-956c-43aa-aba4-e75395af7d83", "Peanut butter number4", 25, 2, null);
Prod("4ca16ce0-1466-4ba6-a69b-5465ed0a4b1d", "Apple number5", 10, 1, null);
Prod("66cc487b-2eb1-470b-98c8-03ee913d860e", "Orange number5", 20, 2, null);
Prod("e77e6589-1dba-4c8b-97b1-1564056ddf10", "Peanut butter number5", 25, 2, null);
Prod("183946f3-41a9-4140-a1cb-b328e3a778d1", "Apple number6", 10, 1, null);
Prod("2995edec-ec1b-42ed-aa97-1e68a9ef765c", "Orange number6", 20, 2, null);
Prod("a78204ae-169a-4d30-936b-034cda5abd0f", "Peanut butter number6", 25, 2, null);
Context.SaveChanges();
Order("31d57282-4824-4441-9bd0-49588b952728", "First order", 1);
Order("fc41cc01-6dc3-4ca5-88a4-c4a463cd6316", "Second order", 1);
Order("f1379562-c779-43bc-a507-71a8506ca8c9", "Third order", 1);
Context.SaveChanges();
await EnsureUsersAsync(true);
await roleManager.CreateAsync(new IdentityRole("Admin"));
await roleManager.CreateAsync(new IdentityRole("User"));
await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync("1"), "Admin");
await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync("1"), "User");
await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync("2"), "User");
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
this.ExternalLogins = (await this._signInManager
.GetExternalAuthenticationSchemesAsync()).ToList();
if (this.ModelState.IsValid)
{
EventuresUser user = new EventuresUser
{
UserName = this.Input.Username,
Email = this.Input.Email,
FirstName = this.Input.FirstName,
LastName = this.Input.LastName,
UCN = this.Input.UCN
};
IdentityResult result = await this._userManager.CreateAsync(user, this.Input.Password);
if (result.Succeeded)
{
this._logger.LogInformation("User created a new account with password.");
if ((await _userManager.GetUsersInRoleAsync("Admin")).Count() == 0)
{
await _userManager.AddToRoleAsync(user, "Admin");
}
else
{
await _userManager.AddToRoleAsync(user, "User");
}
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
//var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { area = "Identity", 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>.");
if (this._userManager.Options.SignIn.RequireConfirmedAccount)
{
return(this.RedirectToPage("RegisterConfirmation", new { email = this.Input.Email }));
}
else
{
await this._signInManager.SignInAsync(user, isPersistent : false);
return(this.LocalRedirect(returnUrl));
}
}
foreach (IdentityError error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(this.Page());
}
public async Task<ActionResult> Create(RegisterViewModel userViewModel, string RoleId, [Bind(Include="Name")] ApplicationUser kUser, string[] selectedKPIs)
{
if(selectedKPIs != null)
{
kUser.KPIs = new List<KPI>();
foreach(var kpi in selectedKPIs){
var kpiToAdd = context.KPIs.Find(int.Parse(kpi));
kUser.KPIs.Add(kpiToAdd);
}
}
if (ModelState.IsValid)
{
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var userinfo = new MyUserInfo()
{
FirstName = userViewModel.FirstName,
LastName = userViewModel.LastName
};
var user = new ApplicationUser();
user.UserName = userViewModel.UserName;
user.Email = userViewModel.Email;
user.MyUserInfo = userinfo;
var adminresult = UserManager.Create(user, userViewModel.Password);
context.Users.Add(user);
context.SaveChanges();
//Add User Admin to Role Admin
if (adminresult.Succeeded)
{
if (!String.IsNullOrEmpty(RoleId))
{
//Find Role Admin
var role = await RoleManager.FindByIdAsync(RoleId);
var result = await UserManager.AddToRoleAsync(user.Id, role.Name);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First().ToString());
ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Id", "Name");
return View();
}
}
}
else
{
ModelState.AddModelError("", adminresult.Errors.First().ToString());
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Id", "Name");
return View();
}
return RedirectToAction("Index");
}
else
{
ViewBag.RoleId = new SelectList(RoleManager.Roles, "Id", "Name");
return View();
}
}
private async Task CreateAcount(ApplicationDbContext context, UserManager<ApplicationUser> userManager, string name, string surname, string email, string password, Configurations.Role role, Configurations.UserType userType)
{
if (context.Consumers.Any(x => x.Email == email) || context.Producers.Any(x => x.Email == email))
return;
User user;
switch(userType)
{
case Configurations.UserType.Producer:
user = new Producer();
break;
case Configurations.UserType.Consumer:
user = new Consumer();
break;
default:
user = new Consumer();
break;
}
user.Name = name;
user.Surname = surname;
user.Email = email;
user.Avatar = Path.Combine(Configurations.UserAvatarStockagePath, Configurations.DefaultFileName);
user.RegistrationDate = DateTime.Now;
user.Enable = true;
switch (userType)
{
case Configurations.UserType.Producer:
Producer producer = user as Producer;
producer.CompanyName = "La ferme de " + producer.Name;
producer.Latitude = 44.7354673;
producer.Longitude = 4.601407399999971;
context.Producers.Add(producer);
break;
case Configurations.UserType.Consumer:
context.Consumers.Add(user as Consumer);
break;
default:
context.Consumers.Add(user as Consumer);
break;
}
#region Creating linked application data
var appUser = new ApplicationUser { UserName = user.Email, Email = user.Email };
appUser.User = user;
var result = await userManager.CreateAsync(appUser, password);
if (result.Succeeded)
{
//Add user role
result = await userManager.AddToRoleAsync(appUser, role.ToString());
//Add user type
result = await userManager.AddToRoleAsync(appUser, userType.ToString());
}
#endregion Creating linked application data
context.SaveChanges();
}
public static void DatabaseInitData(ApplicationDbContext dbContext, UserManager<ApplicationUser> userManager, RoleManager<IdentityRole> roleManager)
{
if (!dbContext.Users.Any())
{
var user = new ApplicationUser { UserName = "******", Email = "*****@*****.**" };
var result = userManager.CreateAsync(user, "Admin@1");
userManager.AddToRoleAsync(user, RoleNames.Admin);
}
if (!dbContext.Cities.Any())
{
dbContext.Cities.Add(new City {Name = "Рязань"});
dbContext.Cities.Add(new City {Name = "Тула"});
dbContext.SaveChanges();
}
if (!dbContext.TypesHousing.Any())
{
var houseTypes = new List<TypesHousing>
{
new TypesHousing {Name = "1-к квартира"},
new TypesHousing {Name = "2-к квартира"},
new TypesHousing {Name = "3-к квартира"},
new TypesHousing {Name = "4-к квартира"},
new TypesHousing {Name = "5-к квартира"},
new TypesHousing {Name = "комната"},
new TypesHousing {Name = "коммуналка"}
};
var additionList = new string[]
{
"Дом",
"Флигель",
"Гостинка",
"Малосемейка",
"Комната в общежитии",
"Койко-место",
"Коттедж",
"Особняк",
"Часть дома",
"Комната в секции"
};
foreach (var item in additionList)
{
houseTypes.Add(new TypesHousing {Name = item });
}
foreach (var type in houseTypes)
{
dbContext.TypesHousing.Add(type);
}
dbContext.SaveChanges();
}
if (!dbContext.Districts.Any())
{
var ryazan = dbContext.Cities.First(x => x.Id == 1);
var tula = dbContext.Cities.First(x => x.Id == 2);
var districs = new District[]
{
new District { Name = "Дашково Песочня", City = ryazan },
new District { Name = "Дягилево", City = ryazan},
new District { Name = "Кальное", City = ryazan},
new District { Name = "Канищево", City = ryazan},
new District { Name = "Михайловское шоссе", City = ryazan},
new District { Name = "Московский", City = ryazan},
new District { Name = "Недостоево", City = ryazan},
new District { Name = "Приокский", City = ryazan},
new District { Name = "Роща", City = ryazan},
new District { Name = "Рыбное", City = ryazan},
new District { Name = "Рязанский р-н", City = ryazan},
new District { Name = "Соколовка", City = ryazan},
new District { Name = "Солотча", City = tula},
new District { Name = "Центр", City = tula},
new District { Name = "Шлаковый", City = tula},
new District { Name = "Южный", City = tula},
new District { Name = "Центральный р-н", City = tula},
new District { Name = "Советский р-н", City = tula},
new District { Name = "Привокзальный р-н", City = tula},
new District { Name = "Зареченский р-н", City = tula},
new District { Name = "Пролетарский р-н", City = tula},
new District { Name = "Тульская обл", City = tula}
};
foreach (var district in districs)
{
dbContext.Districts.Add(district);
}
dbContext.SaveChanges();
}
if (!dbContext.Streets.Any())
{
#region
var streets = new Street[]
{
new Street {Name = "1 Мая ул"},
new Street {Name = "1 Район ул"},
new Street {Name = "1-й Авиационный проезд"},
new Street {Name = "1-й Аллейный проезд"},
new Street {Name = "1-й Базарный проезд"},
new Street {Name = "1-й Дачный пер"},
new Street {Name = "1-й Крайний проезд"},
new Street {Name = "1-й Озерный пер"},
new Street {Name = "1-й Тракторный проезд"},
new Street {Name = "10 Линия ул"},
new Street {Name = "10 Район ул"},
new Street {Name = "11 Линия ул"},
new Street {Name = "11 Район ул"},
new Street {Name = "12 Линия ул"},
new Street {Name = "12 Район ул"},
new Street {Name = "14 Линия ул"},
new Street {Name = "1905 года пер"},
new Street {Name = "2 Бутырки ул"},
new Street {Name = "2 Линия ул"},
new Street {Name = "2 Район ул"},
new Street {Name = "2-й Авиационный проезд"},
new Street {Name = "2-й Аллейный проезд"},
new Street {Name = "2-й Базарный проезд"},
new Street {Name = "2-й Дачный пер"},
new Street {Name = "2-й Дягилевский проезд"},
new Street {Name = "2-й Крайний проезд"},
new Street {Name = "2-й Озерный пер"},
new Street {Name = "2-й Тракторный проезд"},
new Street {Name = "26 Бакинских Комиссаров пл"},
new Street {Name = "3 Бутырки ул"},
new Street {Name = "3 Линия ул"},
new Street {Name = "3 Район ул"},
new Street {Name = "3-й Авиационный проезд"},
new Street {Name = "3-й Аллейный проезд"},
new Street {Name = "3-й Базарный проезд"},
new Street {Name = "3-й Дачный пер"},
new Street {Name = "3-й Дягилевский проезд"},
new Street {Name = "3-й Озерный пер"},
new Street {Name = "3-й Тракторный проезд"},
new Street {Name = "3-й Усадебный проезд"},
new Street {Name = "4 Линия ул"},
new Street {Name = "4 Район ул"},
new Street {Name = "4-й Авиационный проезд"},
new Street {Name = "4-й Аллейный проезд"},
new Street {Name = "4-й Дачный пер"},
new Street {Name = "4-й Дягилевский проезд"},
new Street {Name = "4-й Озерный пер"},
new Street {Name = "4-й Озёрный пер"},
new Street {Name = "4-й Тракторный проезд"},
new Street {Name = "4-й Усадебный проезд"},
new Street {Name = "5 Линия ул"},
new Street {Name = "5 Район ул"},
new Street {Name = "5-й Авиационный проезд"},
new Street {Name = "5-й Аллейный проезд"},
new Street {Name = "5-й Дягилевский проезд"},
new Street {Name = "5-й Озерный пер"},
new Street {Name = "50-летия Октября пл"},
new Street {Name = "6 Линия ул"},
new Street {Name = "6-й Авиационный проезд"},
new Street {Name = "6-й Аллейный проезд"},
new Street {Name = "7 Линия ул"},
new Street {Name = "7 Район ул"},
new Street {Name = "7-й Авиационный проезд"},
new Street {Name = "7-й Аллейный проезд"},
new Street {Name = "8 Линия ул"},
new Street {Name = "8 Марта ул"},
new Street {Name = "8 Район ул"},
new Street {Name = "8-й Авиационный проезд"},
new Street {Name = "9 Линия пер"},
new Street {Name = "9 Линия ул"},
new Street {Name = "9 Район ул"},
new Street {Name = "Авиационная ул"},
new Street {Name = "Аллейная 8-й проезд"},
new Street {Name = "Аллейная ул"},
new Street {Name = "Бабушкина 1-й проезд"},
new Street {Name = "Бабушкина ул"},
new Street {Name = "Баженова пер"},
new Street {Name = "Баженова ул"},
new Street {Name = "Базарная ул"},
new Street {Name = "Бахмачеевская ул"},
new Street {Name = "Безбожная 1-я ул"},
new Street {Name = "Безбожная 2-я ул"},
new Street {Name = "Белинского проезд"},
new Street {Name = "Белинского ул"},
new Street {Name = "Белякова ул"},
new Street {Name = "Березняковская ул"},
new Street {Name = "Березовая ул"},
new Street {Name = "Библиотечная ул"},
new Street {Name = "Бирюзова ул"},
new Street {Name = "Боголюбова ул"},
new Street {Name = "Божатково мкр"},
new Street {Name = "Божатково п"},
new Street {Name = "Больничная (Солотча) ул"},
new Street {Name = "Большая (Шереметьево-Песочня) ул"},
new Street {Name = "Борки мкр"},
new Street {Name = "Братиславская ул"},
new Street {Name = "Бронная ул"},
new Street {Name = "Бульварный пер"},
new Street {Name = "Быстрецкая ул"},
new Street {Name = "Вагоны (Соколовка) тер"},
new Street {Name = "Введенская ул"},
new Street {Name = "Великанова ул"},
new Street {Name = "Верхняя ул"},
new Street {Name = "Весенняя (Канищево) ул"},
new Street {Name = "Весенняя ул"},
new Street {Name = "Ветеринарная ул"},
new Street {Name = "Вишневая ул"},
new Street {Name = "Вишневый (Канищево) пер"},
new Street {Name = "Владимирская (Солотча) ул"},
new Street {Name = "Вознесенская ул"},
new Street {Name = "Войкова пер"},
new Street {Name = "Вокзальная ул"},
new Street {Name = "Вольная (Солотча) ул"},
new Street {Name = "Восточная ул"},
new Street {Name = "Восточный промузел мкр"},
new Street {Name = "Высоковольтная ул"},
new Street {Name = "Гагарина (Соколовка) ул"},
new Street {Name = "Гагарина 1-й проезд"},
new Street {Name = "Гагарина 2-й проезд"},
new Street {Name = "Гагарина 3-й проезд"},
new Street {Name = "Гагарина 4-й проезд"},
new Street {Name = "Гагарина ул"},
new Street {Name = "Газетный пер"},
new Street {Name = "Гайдара (Солотча) ул"},
new Street {Name = "Гайдара ул"},
new Street {Name = "Гаражная ул"},
new Street {Name = "Гвардейская ул"},
new Street {Name = "Гоголя проезд"},
new Street {Name = "Гоголя ул"},
new Street {Name = "Голенчинская ул"},
new Street {Name = "Голенчинское ш"},
new Street {Name = "Горького ул"},
new Street {Name = "Гражданская 2-й пер"},
new Street {Name = "Гражданская ул"},
new Street {Name = "Гражданский 1-й проезд"},
new Street {Name = "Грибоедова проезд"},
new Street {Name = "Грибоедова ул"},
new Street {Name = "Дачная (Канищево) ул"},
new Street {Name = "Дачная (Соколовка) ул"},
new Street {Name = "Дачная (Солотча) ул"},
new Street {Name = "Дачная ул"},
new Street {Name = "Дашковская ул"},
new Street {Name = "Декабристов проезд"},
new Street {Name = "Декабристов ул"},
new Street {Name = "Дзержинского ул"},
new Street {Name = "Димитрова пл"},
new Street {Name = "Димитрова ул"},
new Street {Name = "Добролюбова 1-й проезд"},
new Street {Name = "Добролюбова 2-й проезд"},
new Street {Name = "Добролюбова 3-й проезд"},
new Street {Name = "Добролюбова 4-й проезд"},
new Street {Name = "Добролюбова 5-й проезд"},
new Street {Name = "Добролюбова 6-й проезд"},
new Street {Name = "Добролюбова ул"},
new Street {Name = "Дорожная (Канищево) ул"},
new Street {Name = "Дорожная (Соколовка) ул"},
new Street {Name = "Дорожный пер"},
new Street {Name = "Достоевского ул"},
new Street {Name = "Дружная ул"},
new Street {Name = "Дунай (Солотча) ул"},
new Street {Name = "Дягилево п"},
new Street {Name = "Дягилево ст"},
new Street {Name = "Дягилевская ул"},
new Street {Name = "Есенина ул"},
new Street {Name = "Железнодорожная (Соколовка) ул"},
new Street {Name = "Железнодорожная (Солотча) ул"},
new Street {Name = "Железнодорожная 1-я ул"},
new Street {Name = "Железнодорожная 2-я ул"},
new Street {Name = "Животноводческая ул"},
new Street {Name = "Животноводческий проезд"},
new Street {Name = "Забайкальская ул"},
new Street {Name = "Заводская проезд"},
new Street {Name = "Завражнова проезд"},
new Street {Name = "Загородная ул"},
new Street {Name = "Западная ул"},
new Street {Name = "Запрудная ул"},
new Street {Name = "Заречная ул"},
new Street {Name = "Затинная ул"},
new Street {Name = "Зафабричная ул"},
new Street {Name = "Земляничная ул"},
new Street {Name = "Земляничный 1-й проезд"},
new Street {Name = "Земляничный 2-й проезд"},
new Street {Name = "Земляничный пер"},
new Street {Name = "Зубковой ул"},
new Street {Name = "Индустриальный 1-й пер"},
new Street {Name = "Интернатская ул"},
new Street {Name = "Интернациональная ул"},
new Street {Name = "К.Маркса ул"},
new Street {Name = "Кальная ул"},
new Street {Name = "Кальновский туп"},
new Street {Name = "Кальное мкр"},
new Street {Name = "Кальной проезд"},
new Street {Name = "Канищево п"},
new Street {Name = "Карцево п"},
new Street {Name = "Карцево тер"},
new Street {Name = "Карьерная ул"},
new Street {Name = "Касимовский пер"},
new Street {Name = "Касимовское ш"},
new Street {Name = "Качевская ул"},
new Street {Name = "Каширина ул"},
new Street {Name = "Керамзавода ул"},
new Street {Name = "Керамические Выселки ул"},
new Street {Name = "Кирпичного завода ул"},
new Street {Name = "Коломенская ул"},
new Street {Name = "Коломенский 1-й проезд"},
new Street {Name = "Коломенский 2-й проезд"},
new Street {Name = "Коломенский 3-й проезд"},
new Street {Name = "Коломенский 4-й проезд"},
new Street {Name = "Коломенский 5-й проезд"},
new Street {Name = "Коломенский 6-й проезд"},
new Street {Name = "Колхозная (Канищево) ул"},
new Street {Name = "Колхозная (Семчино) ул"},
new Street {Name = "Колхозная ул"},
new Street {Name = "Колхозный проезд"},
new Street {Name = "Кольцова ул"},
new Street {Name = "Комбайновая ул"},
new Street {Name = "Коммунистический пер"},
new Street {Name = "Комсомольский пер"},
new Street {Name = "Коняева 1-й проезд"},
new Street {Name = "Коняева 2-й проезд"},
new Street {Name = "Коняева 3-й проезд"},
new Street {Name = "Коняева 4-й проезд"},
new Street {Name = "Коняева 5-й проезд"},
new Street {Name = "Коняева ул"},
new Street {Name = "Корнилова ул"},
new Street {Name = "Космодемьянской 1-й проезд"},
new Street {Name = "Космодемьянской ул"},
new Street {Name = "Космонавтов ул"},
new Street {Name = "Костычева ул"},
new Street {Name = "Котовского проезд"},
new Street {Name = "Котовского ул"},
new Street {Name = "Крайняя ул"},
new Street {Name = "Красная 1-я ул"},
new Street {Name = "Красная 2-я ул"},
new Street {Name = "Краснорядская ул"},
new Street {Name = "Кремлевский вал"},
new Street {Name = "Кремль ул"},
new Street {Name = "Крупской ул"},
new Street {Name = "Кудрявцева ул"},
new Street {Name = "Куйбышевское ш"},
new Street {Name = "Культуры ул"},
new Street {Name = "Кутузова ул"},
new Street {Name = "Л.Шевцовой ул"},
new Street {Name = "Лагерная ул"},
new Street {Name = "Лево-Лыбедска ул"},
new Street {Name = "Ленина пл"}
};
#endregion
var cityList = dbContext.Cities.Select(x => x.Id).ToList();
foreach (var street in streets)
{
street.CityId = cityList[Random.Next(cityList.Count)];
dbContext.Streets.Add(street);
}
dbContext.SaveChanges();
}
if (!dbContext.Housing.Any())
{
for (int i = 0; i < 100; i++)
{
dbContext.Housing.Add(CreateHousingRadnom(dbContext));
dbContext.SaveChanges();
}
}
}
private async static void InitializeUserAdmin(ApplicationDbContext context, UserManager<ApplicationUser> userManager)
{
ApplicationUser admin = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
DateOfBirth = new DateTime(1990, 1, 1),
EmailConfirmed = true
};
Thread.Sleep(2000);
await userManager.CreateAsync(admin, "Beast@2"); //password must match constraints of 6 char min, case-change, min 1 number and non-letter character
Thread.Sleep(2000);
await userManager.AddToRoleAsync(admin, "admin");
context.SaveChanges();
}
