public async Task <IdentityResult> RegisterUserAsync(RegisterViewModel model)
{
if (await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false) != null)
{
return(IdentityResults.UserExists);
}
var user = _mapper.Map <User>(model);
user.UserName = user.Email.Split('@')[0];
var result = await _userManager.CreateAsync(user, model.Password)
.Then(() => _userManager.AddToRoleAsync(user, Roles.StudentRole))
.Then(() =>
{
user.EmailConfirmed = true;
return(_userManager.UpdateAsync(user));
}).ConfigureAwait(false);
if (result.Succeeded)
{
var newUser = await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false);
var registerEvent = new StudentRegisterEvent(newUser.Id, newUser.Email, newUser.Name,
newUser.Surname, newUser.MiddleName);
_eventBus.Publish(registerEvent);
}
return(result);
}
public async Task <ActionResult> Register(RegisterClientViewModel model)
{
if (ModelState.IsValid)
{
UserDTO user = _mapper.Map <RegisterClientViewModel, UserDTO>(model);
IdentityResult result;
try
{
result = await _userManager.CreateAsync(user, user.Password);
}
catch (ArgumentNullException exception)
{
return(Content(exception.Message));
}
if (result.Succeeded)
{
var currentUser = await _userManager.FindByNameAsync(model.UserName);
var addToRoleResult = await _userManager.AddToRoleAsync(currentUser.Id, "User");
if (addToRoleResult.Succeeded)
{
return(View("SuccessRegistration"));
}
ModelState.AddModelError("", @"Неудачная попытка регистрации.");
return(View(model));
}
}
return(View(model));
}
public async Task <AuthResult <Token> > SignUp(SignUpDTO signUpDto)
{
if (signUpDto == null ||
string.IsNullOrEmpty(signUpDto.Username) ||
string.IsNullOrEmpty(signUpDto.Password) ||
string.IsNullOrEmpty(signUpDto.ConfirmPassword) ||
string.IsNullOrEmpty(signUpDto.FullName) ||
string.IsNullOrEmpty(signUpDto.Email) ||
signUpDto.Password != signUpDto.ConfirmPassword
)
{
return(AuthResult <Token> .UnvalidatedResult);
}
var newUser = new TUser {
Username = signUpDto.Username, Email = signUpDto.Email, FullName = signUpDto.FullName
};
var succeeded = await userManager.CreateAsync(newUser, signUpDto.Password);
if (succeeded)
{
if (newUser.Id > 0)
{
await userManager.AddToRoleAsync(newUser.Id, Roles.User);
var token = jwtManager.GenerateToken(newUser);
return(AuthResult <Token> .TokenResult(token));
}
}
return(AuthResult <Token> .UnauthorizedResult);
}
public async Task InitializeAsync()
{
if (_roleManager.Roles.Count() == 0)
{
List <ApplicationRole> roles = new List <ApplicationRole>
{
new ApplicationRole("Admin"),
new ApplicationRole("User")
};
foreach (var role in roles)
{
await _roleManager.CreateAsync(role);
}
}
if (await _userManager.FindByNameAsync("admin") == null)
{
await _userManager.CreateAsync(new ApplicationUser
{
Email = "*****@*****.**",
FirstName = "Admin",
LastName = "Admin",
JoinDate = DateTime.UtcNow,
UserName = "******",
EmailConfirmed = true
},
"Stl21598z!");
var user = await _userManager.FindByNameAsync("admin");
await _userManager.AddToRoleAsync(user.Id, "Admin");
}
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (this.ModelState.IsValid)
{
var user = new User {
UserName = model.Username, Email = model.Email, DateOfBirth = model.DateOfBirth, CreatedOn = DateTime.Now
};
var result = await this.userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await userServices.CreateUserInitialBalances(user.Id, model.CurrencyName);
await userManager.AddToRoleAsync(user, UserRoles.User.ToString());
await this.signinManager.SignInAsync(user, isPersistent : false);
return(this.RedirectToAction("", "", new { @area = "" }));
}
this.AddErrors(result);
}
// If we got this far, something failed, redisplay form
model.Currencies = await GetCurrenciesSelectListItemsCached();
return(this.View(model));
}
public async Task <IHttpActionResult> Save([FromBody] CreateUserDto model)
{
var repeated = _userRepository.GetUserByName(model.UserName);
if (repeated != null)
{
return(BadRequest("User already exists!"));
}
var user = new User {
UserName = model.UserName, Email = model.Email, IsEmailConfirmed = model.IsEmailConfirmed
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
result = await _userManager.AddToRoleAsync(user.Id, Role.Client);
if (result.Succeeded)
{
return(Ok());
}
var createdUser = _userRepository.GetUserByName(model.UserName);
if (createdUser != null)
{
await _userManager.DeleteAsync(createdUser);
}
}
return(BadRequest(result.Errors.FirstOrDefault()));
}
public async Task AddNewUniversity(AddUniRequest request)
{
User user = new User
{
Email = request.Email,
UserName = request.Email
};
var success = await userManager.CreateAsync(user, request.Password);
if (success.Succeeded == true)
{
await userManager.AddToRoleAsync(user, "Administrator");
//await signInManager.PasswordSignInAsync(request.Email, request.Password, false, false);
}
University university = new University()
{
Name = request.UniversityName,
//User = user,
UserId = user.Id
};
await unitOfWork.UniversityRepository.CreateAsync(university);
await unitOfWork.Commit();
}
public async Task AddToRoleShouldSuccess()
{
_userManagerFacade.Setup(x => x.AddToRoleAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Success));
var result = await _userManager.AddToRoleAsync(null, null);
Assert.That(result.Succeeded, Is.EqualTo(true));
}
private async Task <User> CheckUserAsync(string email, string firstName, string lastName, string password, string role)
{
var user = await userManager.FindByEmailAsync(email);
if (user == null)
{
user = await AddUser(email, firstName, lastName, password, role);
}
var isInRole = await userManager.IsInRoleAsync(user, role);
if (!isInRole)
{
await userManager.AddToRoleAsync(user, role);
}
return(user);
}
public async Task SeedDevelopmentEnvironmentAsync()
{
await _roleManager.AddRoleAsync(ApplicationRole.Admin);
await _roleManager.AddRoleAsync(ApplicationRole.User);
var(_, benUserId) = await _userManager.CreateAsync("*****@*****.**", "hunter2", 1);
await _userManager.AddToRoleAsync(benUserId, ApplicationRole.Admin);
}
public async Task <IActionResult> Register(RegisterNewUserViewModel model)
{
if (ModelState.IsValid)
{
var user = await userHelper.FindByEmailAsync(model.Username);
if (user == null)
{
user = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Username,
UserName = model.Username,
};
var result = await userHelper.CreateAsync(user, model.Password);
if (result != IdentityResult.Success)
{
ModelState.AddModelError(string.Empty, "La cuenta no pudo crearse correctamente");
return(View(model));
}
await userHelper.AddToRoleAsync(user, model.UserRoles);
ViewBag.Message = "La cuenta ha sido creada correctamente. Debe habilitarla para iniciar sesión.";
return(RedirectToAction("Index", "Users"));
}
ModelState.AddModelError(string.Empty, "El correo electrónico ya ha sido asociado");
ViewBag.Name = roleManager.GetRolesSelectList();
}
return(View(model));
}
public async Task <IActionResult> PromoteUser(string userId)
{
var user = userManager.Users.Where(u => u.Id == userId).FirstOrDefault();
if (user is null)
{
return(PartialView("_StatusMessage", "Error: User not found!"));
}
var result = await userManager.AddToRoleAsync(user, "Administrator");
if (!result.Succeeded)
{
return(PartialView("_StatusMessage", "Error: Could not promote user!"));
}
return(PartialView("_StatusMessage", "The user has been successfully promoted!"));
}
public async Task <IdentityResult> RegisterUser(UserRegisterDTO registerUserModel)
{
User usr = null;
if (registerUserModel.RoleName == "User")
{
usr = new Person()
{
UserName = registerUserModel.Email,
Email = registerUserModel.Email,
FullName = registerUserModel.Name,
PhoneNumber = registerUserModel.PhoneNumber
};
}
else
{
usr = new Administrator()
{
UserName = registerUserModel.Email,
Email = registerUserModel.Email,
FullName = registerUserModel.Name,
PhoneNumber = registerUserModel.PhoneNumber
};
}
using (var context = provider.Context)
{
IUserManager manager = provider.GetUserManager(context);
IdentityResult result = null;
try
{
result = await manager.CreateAsync(usr, registerUserModel.Password);
}
catch (Exception ex)
{
throw ex;
}
if (result.Succeeded)
{
result = await manager.AddToRoleAsync(usr.Id, registerUserModel.RoleName);
}
return(result);
}
}
public async Task <ServiceResponse> AddToRoleAsync(string email, Roles role)
{
var user = await _userManager.FindByEmailAsync(_cryptoProvider.EncryptPrivate(email)).ConfigureAwait(false);
if (user == null)
{
return(new ServiceResponse("User not found."));
}
var result = await _userManager.AddToRoleAsync(user, role.ToString()).ConfigureAwait(false);
if (!result.Succeeded)
{
return(new ServiceResponse(string.Join(", ", result.Errors.Select(e => e.Description))));
}
return(new ServiceResponse());
}
public async Task Register(string email, string password)
{
var user = new User()
{
Email = email,
UserName = email,
};
IdentityResult res = await _userManager.CreateAsync(user, password);
if (res.Succeeded)
{
await _userManager.AddToRoleAsync(user.Id, Roles.Byuer);
return;
}
else
{
throw new RegisterFailedException(res.Errors.First());
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new User()
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PatrName = model.PatrName,
RegistrationDate = DateTimeOffset.Now
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id.ToString(), code, Request.Scheme);
await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _userManager.AddToRoleAsync(user, "user");
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <NewStudentResultDTO> AddStudentAsync(CreateStudentDTO studentDTO)
{
var createResult = new NewStudentResultDTO
{
Created = false,
Student = null
};
var user = new ApplicationUser()
{
UserName = studentDTO.Email, Email = studentDTO.Email, CreatedDate = DateTime.Now, FirstName = studentDTO.FirstName, LastName = studentDTO.LastName, EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, studentDTO.Pesel.ToString() + studentDTO.LastName.ToLower().Substring(0, Math.Min(studentDTO.LastName.Length, 3)));
//var saveUserResult = _store.Context.SaveChanges();
var roleResult = await _userManager.AddToRoleAsync(user.Id, "student");
if (!result.Succeeded || !roleResult.Succeeded)
{
return(createResult);
}
var student = Mapper.Map <Student>(studentDTO);
student.UserId = user.Id;
var createdStudent = _repository.InsertStudent(student);
if (_repository.Save())
{
createResult.Created = true;
createResult.Student = Mapper.Map <GetStudentDTO>(createdStudent);
return(createResult);
}
return(createResult);
}
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();
_chatMessageRepository.InsertAndGetId(
new ChatMessage(
friendWithMessage.ToUserIdentifier(),
admin.ToUserIdentifier(),
ChatSide.Sender,
L("Demo_SampleChatMessage"),
ChatMessageReadState.Read
)
);
_chatMessageRepository.InsertAndGetId(
new ChatMessage(
admin.ToUserIdentifier(),
friendWithMessage.ToUserIdentifier(),
ChatSide.Receiver,
L("Demo_SampleChatMessage"),
ChatMessageReadState.Unread
)
);
}
public async Task <IdentityResult> AddToRoleAsync(User user, string role)
{
return(await _userManager.AddToRoleAsync(user, role));
}
public async Task ApproveAsync(int userId)
{
await _userManager.AddToRoleAsync(userId, DefaultRole.ApprovedUser.ToString());
}
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,
string tenantUrl)
{
int newTenantId;
long newAdminId;
await CheckEditionAsync(editionId, isInTrialPeriod);
using (var uow = _unitOfWorkManager.Begin(TransactionScopeOption.RequiresNew))
{
if (tenantUrl.IsNullOrEmpty())
{
throw new UserFriendlyException("You forgot to enter Tenant URL");
}
//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),
TenantUrl = tenantUrl
};
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);
}
