public async Task SeedAsync(DataSeedContext context)
{
if (await roleRepository.GetCountAsync() == 1)
{
var existingRole = roleRepository.FirstOrDefault();
await roleRepository.DeleteAsync(existingRole);
var roles = new[] { "admin", "employee" };
foreach (var role in roles)
{
var newRole = new IdentityRole(guidGenerator.Create(), role);
await roleRepository.InsertAsync(newRole);
}
}
if (await userRepository.GetCountAsync() == 1)
{
var existingAdmin = userRepository.FirstOrDefault();
if (existingAdmin.Email == "*****@*****.**")
{
await userManager.DeleteAsync(existingAdmin);
await userRepository.HardDeleteAsync(existingAdmin);
var admin = new IdentityUser(guidGenerator.Create(), "admin", "*****@*****.**");
await userManager.CreateAsync(admin, "Admin123!");
await userManager.AddToRoleAsync(admin, "admin");
var employee = new IdentityUser(guidGenerator.Create(), "employee", "*****@*****.**");
await userManager.CreateAsync(employee, "Employee123!");
await userManager.AddToRoleAsync(employee, "employee");
}
}
}
public async void CreateRolesAsync(IContainer container)
{
IdentityRoleManager roleManager = container.Resolve <IdentityRoleManager>();
IdentityUserManager userManager = container.Resolve <IdentityUserManager>();
if (userManager.FindById(6) != null)
{
await userManager.AddToRoleAsync(6, Role.Admin.ToString());
}
if (userManager.FindById(7) != null)
{
await userManager.AddToRoleAsync(7, Role.Seller.ToString());
}
if (roleManager.FindByNameAsync(Role.Admin.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Admin.ToString()));
await userManager.AddToRoleAsync(1, Role.Admin.ToString());
}
if (roleManager.FindByNameAsync(Role.Seller.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Seller.ToString()));
}
if (roleManager.FindByNameAsync(Role.Customer.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Customer.ToString()));
}
}
public async Task <IdentityUser> CreateUser(IdentityUser user, string password)
{
var sameInfoUsers = userRepository
.Where(u => u.UserName.ToLower() == user.UserName.ToLower() || u.Email.ToLower() == user.Email.ToLower())
.ToList();
foreach (var sameInfoUser in sameInfoUsers)
{
if (sameInfoUser.UserName.ToLower() == user.UserName.ToLower())
{
throw new HttpStatusCodeException(HttpStatusCode.BadRequest, SaleManagementDomainErrorCodes.USERNAME_IS_TAKEN);
}
if (sameInfoUser.Email.ToLower() == user.Email.ToLower())
{
throw new HttpStatusCodeException(HttpStatusCode.BadRequest, SaleManagementDomainErrorCodes.EMAIL_IS_TAKEN);
}
}
var result = await userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new HttpStatusCodeException(HttpStatusCode.InternalServerError, SaleManagementDomainErrorCodes.CREATE_USER_FAILED);
}
result = await userManager.AddToRoleAsync(user, "employee");
if (!result.Succeeded)
{
throw new HttpStatusCodeException(HttpStatusCode.InternalServerError, SaleManagementDomainErrorCodes.CREATE_USER_FAILED);
}
return(user);
}
private async Task CreateUserAsync(string userName, string name, string surname, DataSeedContext context)
{
await _identityOptions.SetAsync();
if ((await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName(userName))) != null)
{
return;
}
var user = new IdentityUser(
_guidGenerator.Create(),
userName,
userName + "@abp.io",
context.TenantId
);
user.Name = name;
user.Surname = surname;
await _identityUserManager.CreateAsync(user,
"1q2w3E*"
);
await _identityUserManager.AddToRoleAsync(user, "admin");
}
public ActionResult CreateUser(UserFormViewModel model)
{
if (ModelState.IsValid)
{
var newUser = new User();
newUser.UserName = model.Email;
newUser.CompanyId = model.CompanyId;
newUser.FullName = model.FullName;
newUser.Email = model.Email;
newUser.Disabled = model.Disabled;
newUser.CreateDate = DateTime.Now;
var result = userManager.CreateAsync(newUser, model.Password).Result;
if (result.Succeeded)
{
result = userManager.AddToRoleAsync(newUser.Id, RoleNames.User).Result;
if (result.Succeeded)
{
return(Json(new { success = true }));
}
}
CollectIdentityErrors(result);
}
var m = new UserFormViewModel();
m.Companies = companyService.GetAll().ToList().ToSelectListItems(r => r.Name, r => r.Id, true);
return(PartialView(m));
}
public async Task SeedAsync(DataSeedContext context)
{
var userName = "******";
var email = userName + "@speedy.com";
var phoneNo = "0750000000";
if ((await IdentityUserManager.FindByNameAsync(userName)) != null)
{
return;
}
var userE = new IdentityUser(GuidGenerator.Create(), userName, email)
{
Name = userName,
Surname = userName
};
await IdentityUserManager.CreateAsync(userE, "!QAZ2wsx");
await IdentityUserManager.SetEmailAsync(userE, email);
await IdentityUserManager.SetPhoneNumberAsync(userE, phoneNo);
await IdentityUserManager.AddClaimAsync(userE, new System.Security.Claims.Claim("sub", userE.Id.ToString()));
await IdentityUserManager.AddToRoleAsync(userE, RolesConsts.SuperAdmin);
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
IdentityUserManager userManager = HttpContext.GetOwinContext().GetUserManager <IdentityUserManager>();
SignInManager signInManager = HttpContext.GetOwinContext().Get <SignInManager>();
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "User"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await authenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new User
{
UserName = model.Email,
Email = model.Email,
FirstName = model.Firstname,
LastName = model.Lastname,
Gender = model.Gender,
DateOfBirth = model.DateOfBirth,
ProfilePicture = model.ImageData
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await userManager.AddLoginAsync(user.Id, info.Login);
//Assign Role to user Here
await userManager.AddToRoleAsync(user.Id, "SuperAdmin");
//log activity
new SubplatformManager().LogActivity(ActivityType.RegisterActivity);
if (result.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <ApplicationUser> ProvisionNewAccount(string emailAddress, string domain)
{
var user = new ApplicationUser()
{
Email = emailAddress,
UserName = emailAddress,
};
using (var transaction = _dbContext.Database.BeginTransaction())
{
var createUserResult = await _userManager.CreateAsync(user);
if (!createUserResult.Succeeded)
{
_logger.Error(
$"Unable to create new User for {user.Email}/{user.UserName} - " +
$"{createUserResult.Errors.ToCommaDelimited()}");
return(null);
}
_logger.Info($"Created new User {user.Email}");
var addToRoleResult = await _userManager.AddToRoleAsync(user.Id, SecurityConfig.UserRole);
if (!addToRoleResult.Succeeded)
{
_logger.Error(
$"Unable to add User {user.Email}/{user.UserName} to {SecurityConfig.UserRole} - " +
$"{createUserResult.Errors.ToCommaDelimited()}");
return(null);
}
_logger.Info($"Added User {user.Email} to Role {SecurityConfig.UserRole}");
var login = new UserLoginInfo("Shopify", domain);
var addLoginResult = await _userManager.AddLoginAsync(user.Id, login);
if (!addLoginResult.Succeeded)
{
_logger.Error(
$"Unable to add Login for User {user.Email}/{user.UserName} - " +
$"{addLoginResult.Errors.StringJoin(";")}");
return(null);
}
_logger.Info($"Added User {user.Email} Login {login.LoginProvider} / {login.ProviderKey}");
transaction.Commit();
}
return(user);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
IdentityUserManager userManager = HttpContext.GetOwinContext().GetUserManager <IdentityUserManager>();
SignInManager signInManager = HttpContext.GetOwinContext().Get <SignInManager>();
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "User"));
}
if (ModelState.IsValid)
{
var user = new User
{
UserName = model.Email,
Email = model.Email,
FirstName = model.Firstname,
LastName = model.Lastname,
Gender = model.Gender,
DateOfBirth = model.DateOfBirth,
IsActive = true,
AlertsViaWebsite = true
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//Send an email with this link
string code = await userManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "User", new { userId = user.Id, code = code },
protocol: Request.Url.Scheme);
await userManager.SendEmailAsync(user.Id, Resources.ConfirmAccount,
"<a href=\"" + callbackUrl + "\">" + Resources.ConfirmAccountClickingHere + "</a>");
//Assign Role to user
await userManager.AddToRoleAsync(user.Id, "User");
//Log activity
new SubplatformManager().LogActivity(ActivityType.RegisterActivity);
//Login
await signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "User"));
}
AddErrors(result);
}
return(View(model));
}
private async Task CreateHostUserAsync(DataSeedContext context)
{
var user = await _userRepository.FindByNormalizedUserNameAsync("HostUser");
if (user == null)
{
user = new IdentityUser(
_guidGenerator.Create(),
"HostUser",
"*****@*****.**",
context.TenantId
);
user.SetProperty("IsHostUser", true);
await _userManager.CreateAsync(user, "1q2w3E*");
await _userManager.AddToRoleAsync(user, "admin");
}
}
public async Task <ActionResult> CreateNewUser(CreateUserViewModel model)
{
try
{
var user = new IdentityUser
{
Audit = new Audit(default(Guid)),
UserFullName = model.UserFullName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
UserName = model.Email,
EmailConfirmed = false,
};
var userresult = await UserManager.CreateAsync(user, "@123456");
if (userresult.Succeeded)
{
var RoleResult = await UserManager.AddToRoleAsync(user.Id, model.RoleName);
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("UserIndex", "Account"));
}
else
{
return(Json(userresult.Errors));
}
}
catch (Exception ex)
{
throw ex;
}
}
