public async Task <ActionResult> Register(UserRegisterForm registerViewModels)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
else
{
IdentityResultTHP infor = await this._identityService.Register(registerViewModels);
if (infor.IsErrors)
{
foreach (var error in infor.Errors)
{
ModelState.AddModelError(string.Empty, error);
}
return(View());
}
else
{
return(RedirectToAction(nameof(Login)));
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Create()
{
UserRegisterForm user = new UserRegisterForm();
user.BirthDate = new DateTime(1977, 7, 7);
return(View(user));
}
public async Task <IActionResult> CreateUser(UserRegisterForm userRegisterForm)
{
if (ModelState.IsValid)
{
var userToCreate = _mapper.Map <User>(userRegisterForm);
var result = await _userManager.CreateAsync(userToCreate, userRegisterForm.Password);
var userProfile = _mapper.Map <UserProfileDto>(userToCreate);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(userToCreate, "Client");
_logger.LogInformation($"New user with id {userToCreate.Id} successfully created.");
return(Ok(new { userProfile }));
}
return(BadRequest(result.Errors));
}
_logger.LogError("Invalid request model, some fields are missed or have invalid format.");
return(BadRequest(ModelState.Values));
}
public async Task <ActionResult <User> > PostUser(UserRegisterForm userForm)
{
User user = new User(userForm);
_context.User.Add(user);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUser", new { id = user.Id }, user));
}
public async Task <IdentityResultTHP> Register(UserRegisterForm user, params string[] roles)
{
IdentityResultTHP result = new IdentityResultTHP();
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required,
TransactionScopeAsyncFlowOption.Enabled))
{
try
{
IdentityResult createUser = await _userService.CreateAsync(new User {
UserName = user.Username,
PhoneNumber = user.Phone,
Address = user.Address,
FullName = user.FullName,
DateOfBirth = user.DateOfBirth
}, user.Password);
if (!createUser.Succeeded)
{
result.Errors.AddRange(createUser.Errors);
}
else
{
foreach (var roleName in roles)
{
if (!_roleService.RoleExists(roleName))
{
IdentityResult createRole = await this._roleService.CreateAsync(new Role { Name = roleName });
if (!createRole.Succeeded)
{
result.Errors.AddRange(createRole.Errors);
}
}
User currentUser = await _userService.FindByNameAsync(user.Username);
if (!_userService.IsInRole(currentUser.Id, roleName))
{
await _userService.AddToRoleAsync(currentUser.Id, roleName);
}
}
scope.Complete();
}
}
catch (Exception ex)
{
throw ex;
}
}
return(result);
}
public ActionResult Register(UserRegisterForm form)
{
if (ModelState.IsValid)
{
UserModel savedUser = form.SaveToDB();
UserSession.User = new SessionUser(savedUser.UserId, savedUser.Username);
return(RedirectToAction("Details", "User", new { username = savedUser.Username }));
}
else
{
return(View(form));
}
}
public ActionResult Create(UserRegisterForm u)
{
try
{
if (ModelState.IsValid)
{
RegisterUser ru = new RegisterUser();
ru.Login = u.Login;
ru.Mail = u.Mail;
ru.BirthDate = u.BirthDate;
int country;
Int32.TryParse(u.SelectedCountry, out country);
ru.Country = country;
byte[] pwEncrypt;
_encrypt = new RSAEncryption(ConsumeInstance.Get <byte[]>("Auth"));
pwEncrypt = _encrypt.Encrypt(u.Password);
ru.Password = Convert.ToBase64String(pwEncrypt);
UserResponse ur = ConsumeInstance.PostWithReturn <RegisterUser, UserResponse>("User", ru);
if (ur.ErrorCode == 1)
{
FlashMessage.Warning("Email already in use");
return(RedirectToAction("Create"));
}
else if (ur.ErrorCode == 2)
{
FlashMessage.Warning("Login already in use");
return(RedirectToAction("Create"));
}
else
{
FlashMessage.Confirmation("Account created");
}
return(RedirectToAction("Login"));
}
else
{
return(View(u));
}
}
catch
{
return(View());
}
}
public async Task <IActionResult> Register(UserRegisterForm userModel)
{
if (!ModelState.IsValid)
{
return(View("Register", userModel));
}
var result = await _userService.RegisterUser(userModel);
if (result == null)
{
ViewBag.Message = "Rejestracja powiodła się";
return(View("Success"));
}
else
{
ModelState.AddModelError(result?.Key, result?.Value);
return(View("Register", userModel));
}
}
public async Task <KeyValuePair <string, string>?> RegisterUser(UserRegisterForm userRegisterForm)
{
Log.Information("Rejestracja!");
var viewModel = new UserLoginForm()
{
UserName = userRegisterForm.UserName
};
try
{
var user = _userManager.FindByNameAsync(userRegisterForm.UserName).Result;
if (user != null)
{
Log.Error("Username taken");
return(new KeyValuePair <string, string>("UserRegisterForm.Username", "Username taken"));
}
user = _userManager.FindByEmailAsync(userRegisterForm.Email).Result;
if (user != null)
{
Log.Error("Email taken");
return(new KeyValuePair <string, string>("UserRegisterForm.Email", "Email taken"));
}
var registerUser = new DaoUser()
{
FirstName = userRegisterForm.FirstName,
LastName = userRegisterForm.LastName,
Email = userRegisterForm.Email,
UserName = userRegisterForm.UserName,
EmailConfirmed = false
};
var result = await _userManager.CreateAsync(registerUser, userRegisterForm.Password);
if (result.Succeeded)
{
var companyId = 0;
try
{
user = await _userManager.FindByNameAsync(userRegisterForm.UserName);
if (user != null)
{
await _userManager.AddToRoleAsync(registerUser, RoleNames.User);
viewModel = new UserLoginForm()
{
UserName = user.UserName
};
string confirmationToken = _userManager.GenerateEmailConfirmationTokenAsync(user).Result;
byte[] tokenGeneratedBytes = Encoding.UTF8.GetBytes(confirmationToken);
var tokenEncoded = WebEncoders.Base64UrlEncode(tokenGeneratedBytes);
await _emailService.SendConfirmAccountEmail(new CancellationToken(), tokenEncoded,
new BaseUserInfo()
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
});
Log.Information("Registration successfully completed.");
return(null);
}
}
catch (Exception e)
{
await _userManager.DeleteAsync(user);
Log.Error("Registration failed.", e.Message);
throw;
}
}
}
catch (Exception e)
{
Log.Error("Registration failed.", e.Message);
throw;
}
return(Error <KeyValuePair <string, string> >("Registration failed."));
}
public async Task <UserViewModel> RegisterUser(UserRegisterForm userRegisterForm)
{
var viewModel = new UserViewModel()
{
UserloginForm = new UserLoginForm()
{
Username = userRegisterForm.UserName
}
};
try
{
var user = _userManager.FindByNameAsync(userRegisterForm.UserName).Result;
if (user != null)
{
viewModel.Error = new GackoError("Username is in use");
return(viewModel);
}
user = _userManager.FindByEmailAsync(userRegisterForm.Email).Result;
if (user != null)
{
viewModel.Error = new GackoError("Email is in use");
return(viewModel);
}
var registerUser = _mapper.Map <DaoUser>(userRegisterForm);
var userId = await _userManager.Users.Select(_ => _.Id).OrderByDescending(_ => _).FirstOrDefaultAsync();
registerUser.Id = userId + 1;
registerUser.EmailConfirmed = true;
var result = await _userManager.CreateAsync(registerUser, userRegisterForm.Password);
if (result.Succeeded)
{
var checkuser = await _userManager.FindByNameAsync(userRegisterForm.UserName);
if (checkuser != null)
{
await _userManager.AddToRoleAsync(registerUser, "Administrator");
viewModel.UserloginForm = new UserLoginForm()
{
Username = checkuser.UserName
};
viewModel.IsSuccess = true;
viewModel.Success = new GackoSuccess("Registration succeeded.");
}
}
else
{
viewModel.Error = new GackoError("Rgistration failed.");
}
}
catch (Exception e)
{
viewModel.Error = new Shared.Models.GackoError(e);
}
return(viewModel);
}
public async Task <IActionResult> Register(UserRegisterForm userModel)
{
return(View("Login", await _userService.RegisterUser(userModel)));
}
public ActionResult Register()
{
UserRegisterForm form = new UserRegisterForm();
return(View(form));
}
