public async Task <ApiResponse <RegisterUserVM> > RegisterAsync(RegisterUserVM userToRegister)
{
try
{
var registerResp = await _httpClient.PostJTokenAsync <ApiResponse <RegisterUserVM> >("api/account/register", userToRegister);
if (registerResp.IsError)
{
return(registerResp);
}
if (registerResp.Result.Ticket != null)
{
await _jsRuntime.InvokeVoidAsync("Cookies.set", "Ticket", registerResp.Result.Ticket);
await _localStorage.RemoveItemAsync("Ticket");
}
return(registerResp);
}
catch (Exception ex)
{
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status500InternalServerError, "Api threw an Exception", null, null, ex));
}
}
public IActionResult Register(RegisterUserVM registerUserVM)
{
User user = new User {
Id = Guid.NewGuid(),
FirstName = registerUserVM.FirstName,
LastName = registerUserVM.LastName,
MiddleName = registerUserVM.MiddleName,
Email = registerUserVM.Email,
Password = registerUserVM.Password,
Type = registerUserVM.UserType
};
User registeredUser = _userService.Add(user);
switch (registerUserVM.UserType)
{
case "Teacher":
Teacher teacher = new Teacher {
UserId = registeredUser.Id
};
_teacherService.AddNewTeacher(teacher);
break;
case "Student":
Student student = new Student {
UserId = registeredUser.Id
};
_studentService.AddNewStudent(student);
break;
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Register(RegisterUserVM model)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Please fill in the requirements below");
return(View(model));
}
//check email
if (db.usersAccounts.Any(x => x.Email == model.Email))
{
ModelState.AddModelError("", "Sorry, this Email already exists");
return(View(model));
}
UserAccount user = new UserAccount()
{
UserID = Guid.NewGuid(),
Password = Crypto.Hash(model.Password, "sha256"),
Email = model.Email,
Country = model.Country,
City = model.City,
Province = model.Province,
Street = model.Street,
Residence = model.Residence,
Phone = model.Phone
};
db.usersAccounts.Add(user);
db.SaveChanges();
TempData["success"] = "You have successfully registered, you can now log in with your username / email and password";
return(RedirectToAction("Login", "UserAccount"));
}
public async Task <IActionResult> Registrar(RegisterUserVM registroVM)
{
if (ModelState.IsValid)
{
var user = new Usuario(new Name(registroVM.Nome, registroVM.Sobrenome), registroVM.Username,
registroVM.Email, registroVM.NumeroTelefone, registroVM.CPF,
new Endereco(registroVM.Logradouro, registroVM.Numero, registroVM.CEP, registroVM.Bairro, registroVM.Cidade, registroVM.Estado));
var result = await _userManager.CreateAsync(user, registroVM.Password);
if (result.Succeeded)
{
if (registroVM.PasswordMestra == _senhaMestra)
{
await _userManager.AddToRoleAsync(user, "Admin");
await _signInManager.SignInAsync(user, isPersistent : false);
}
else
{
await _userManager.AddToRoleAsync(user, "Member");
await _signInManager.SignInAsync(user, isPersistent : false);
}
return(RedirectToAction("LoggedIn", "Account"));
}
}
return(View(registroVM));
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserVM registerUserVM)
{
try
{
var user = await _userStore.GetUserByPhoneAsync(registerUserVM.Phone);
if (user != null)
{
return(Conflict(1));
}
var result = await _userStore.CreateUserAsync(new UserEntity
{
Name = registerUserVM.Name,
Surname = registerUserVM.Surname,
Phone = registerUserVM.Phone,
Password = registerUserVM.PasswordHash
});
return(Ok(result));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Creates the user.
/// </summary>
public async Task<RegisterUserResultVM> RegisterAsync(RegisterUserVM vm, ExternalLoginData extLogin)
{
await ValidateRegisterRequestAsync(vm);
var isFirstUser = await IsFirstUserAsync();
var user = _mapper.Map<AppUser>(vm);
user.Id = Guid.NewGuid().ToString();
user.IsValidated = isFirstUser;
var createResult = await _userMgr.CreateAsync(user);
if (!createResult.Succeeded)
{
var msgs = createResult.Errors.Select(x => new KeyValuePair<string, string>("", x.Description)).ToList();
throw new ValidationException(msgs);
}
var login = new UserLoginInfo(extLogin.LoginProvider, extLogin.ProviderKey, extLogin.LoginProvider);
await _userMgr.AddLoginAsync(user, login);
await _userMgr.AddToRoleAsync(user, isFirstUser ? nameof(UserRole.Admin) : nameof(UserRole.User));
await _signMgr.SignInAsync(user, true);
return new RegisterUserResultVM
{
IsValidated = user.IsValidated,
User = user,
Principal = await _signMgr.CreateUserPrincipalAsync(user)
};
}
public HttpResponse Register(RegisterUserVM vM)
{
if (this.IsUserSignedIn())
{
return(this.Redirect("/"));
}
if (string.IsNullOrWhiteSpace(vM.Username) || vM.Username.Length < 5 || vM.Username.Length > 20)
{
return(Error("Username must be between 5 and 20 symbols!"));
}
if (!new EmailAddressAttribute().IsValid(vM.Email))
{
return(Error("Email is not valid!"));
}
if (string.IsNullOrWhiteSpace(vM.Password) || vM.Password.Length < 6 || vM.Password.Length > 20)
{
return(Error("Password must be between 5 and 20 symbols!"));
}
if (vM.Password != vM.ConfirmPassword)
{
return(Error("Passwords don't mach!"));
}
userService.CreateUser(vM);
return(Redirect("/Users/Login"));
}
/// <summary>
/// Performs additional checks on the registration request.
/// </summary>
private async Task ValidateRegisterRequestAsync(RegisterUserVM vm, bool usePasswordAuth)
{
var val = new Validator();
if (FuzzyDate.TryParse(vm.Birthday) == null)
{
val.Add(nameof(vm.Birthday), "Дата рождения указана неверно.");
}
var emailExists = await _db.Users.AnyAsync(x => x.Email == vm.Email);
if (emailExists)
{
val.Add(nameof(vm.Email), "Адрес электронной почты уже зарегистрирован.");
}
if (usePasswordAuth)
{
if (vm.Password == null || vm.Password.Length < 6)
{
val.Add(nameof(vm.Password), "Пароль должен содержать как минимум 6 символов.");
}
if (vm.Password != vm.PasswordCopy)
{
val.Add(nameof(vm.PasswordCopy), "Пароли не совпадают.");
}
}
val.ThrowIfInvalid();
}
public async Task <IActionResult> AddUser()
{
var vm = new RegisterUserVM();
vm.AdminTypes = new List <SelectListItem>()
{
new SelectListItem {
Value = AdminTypeEnum.None.ToString(), Text = "None"
},
new SelectListItem {
Value = AdminTypeEnum.Regular.ToString(), Text = "Regular"
},
};
var user = await _userManager.FindByIdAsync(User.FindFirst("sub").Value);
if (await _userManager.IsInRoleAsync(user, "Global"))
{
vm.AdminTypes.Add(new SelectListItem {
Value = AdminTypeEnum.Global.ToString(), Text = "Super"
});
vm.AdminTypes.Add(new SelectListItem {
Value = AdminTypeEnum.Global.ToString(), Text = "Global"
});
}
return(View(vm));
}
// GET: Launch/Register
public ActionResult Register()
{
RegisterUserVM user = new RegisterUserVM();
LanguageService langService = new LanguageService();
CountryService countryService = new CountryService();
user.CountryId = 73;
user.LanguageId = 2;
user.CountryList = (from item in countryService.GetAll().OrderBy(x => x.Name)
select new SelectListItem()
{
Text = item.Name,
Value = item.Id.ToString()
}).ToList();
user.LangList = (from item in langService.GetAll().OrderBy(x => x.Name)
select new SelectListItem()
{
Text = item.Name,
Value = item.Id.ToString()
}).ToList();
ViewBag.Error = TempData["ErrorMessage"];
//leads to register view
return(View(user));
}
public void RegisterUser(RegisterUserVM user)
{
var user1 = Mapper.Map <User>(user);
Contex.Users.Add(user1);
Contex.SaveChanges();
}
/// <summary>
/// Creates a default page for the user.
/// </summary>
public async Task <Page> CreateDefaultUserPageAsync(RegisterUserVM vm, ClaimsPrincipal principal)
{
var name = new[] { vm.LastName, vm.FirstName, vm.MiddleName }
.Where(x => !string.IsNullOrWhiteSpace(x))
.Select(x => x.Trim())
.JoinString(" ");
var createVm = new PageEditorVM
{
Title = name,
Description = name,
Type = PageType.Person,
Facts = new JObject
{
["Birth.Date"] = new JObject {
["Value"] = vm.Birthday
},
["Main.Name"] = new JObject
{
["Values"] = new JArray
{
new JObject
{
["FirstName"] = vm.FirstName,
["MiddleName"] = vm.MiddleName,
["LastName"] = vm.LastName
}
}
}
}.ToString()
};
return(await CreateAsync(createVm, principal));
}
public async Task <IActionResult> Register(RegisterUserVM vm)
{
if (ModelState.IsValid)
{
//map
MyUser tempUser = new MyUser
{
UserName = vm.Username,
Email = vm.Email
};
//add user to database
var result = await _userManagerService.CreateAsync(tempUser, vm.Password);
if (result.Succeeded)
{
//add user to role CUSTOMER
await _userManagerService.AddToRoleAsync(tempUser, "Customer");
//go home
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var err in result.Errors)
{
ModelState.AddModelError("", err.Description);
}
}
}
//error input validation
return(View(vm));
}
public RegisterUser(int typeDB)
{
InitializeComponent();
_vm = new RegisterUserVM(Navigation);
BindingContext = _vm;
_vm.TypeDB = typeDB;
}
/// <summary>
/// Displays the registration form.
/// </summary>
private async Task <ActionResult> ViewRegisterFormAsync(RegisterUserVM vm)
{
ViewBag.Data = new RegisterUserDataVM
{
IsFirstUser = await _auth.IsFirstUserAsync()
};
return(View("RegisterForm", vm));
}
public void CreateUser(RegisterUserVM registerUserVM)
{
db.Add(new User
{
Password = ComputeHash(registerUserVM.Password),
Email = registerUserVM.Email,
Username = registerUserVM.Username
});
db.SaveChanges();
}
public ActionResult Register([Bind(Include = "Username,Email,Password,Phone")] RegisterUserVM user)
{
if (ModelState.IsValid)
{
this.service.RegisterUser(user);
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public async Task <IActionResult> Register(RegisterUserVM user)
{
var result = await _accountService.Register(user);
if (result.Response != null)
{
return(BadRequest(result));
}
return(Ok("User was added"));
}
/// <summary>
/// Displays the registration form.
/// </summary>
private async Task <ActionResult> ViewRegisterFormAsync(RegisterUserVM vm, bool usesPasswordAuth)
{
ViewBag.Data = new RegisterUserDataVM
{
IsFirstUser = await _auth.IsFirstUserAsync(),
UsePasswordAuth = usesPasswordAuth
};
return(View("RegisterForm", vm));
}
public IActionResult Post([FromBody] RegisterUserVM registerUserVM, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations)
{
var user = _mapper.Map <User>(registerUserVM);
var result = _userService.Insert(user);
if (result.Success)
{
return(Ok(_signManager.GenerateTokenAndSetIdentity(result.Value, signingConfigurations, tokenConfigurations)));
}
return(Conflict(result));
}
/// <summary>
/// Performs additional checks on the registration request.
/// </summary>
private async Task ValidateRegisterRequestAsync(RegisterUserVM vm)
{
var val = new Validator();
if (FuzzyDate.TryParse(vm.Birthday) == null)
val.Add(nameof(vm.Birthday), "Дата рождения указана неверно.");
var emailExists = await _db.Users.AnyAsync(x => x.Email == vm.Email);
if (emailExists)
val.Add(nameof(vm.Email), "Адрес электронной почты уже зарегистрирован.");
val.ThrowIfInvalid();
}
public JsonResult Post([FromBody] RegisterUserVM newuser)
{
var response = new ApiResponse();
if (newuser.Password != newuser.ConfirmPassword)
{
response.IsSucced = false;
response.Errors.Add("Password don't match");
return(new JsonResult(response));
}
var newUser = new ApplicationUser
{
UserName = newuser.Email,
Email = newuser.Email,
};
try
{
var userCreationResult = _userManager.CreateAsync(newUser, newuser.Password);
response.IsSucced = userCreationResult.Result.Succeeded;
if (userCreationResult.Result.Succeeded)
{
response.Redirect.Redirected = true;
response.Redirect.RedirectLink = "/Home/Index";
return(new JsonResult(response));
}
else
{
foreach (var error in userCreationResult.Result.Errors)
{
response.Errors.Add(error.Description);
}
return(new JsonResult(response));
}
}
catch (Exception e)
{
response.IsSucced = false;
response.Errors.Add("Database connection problem.");
return(new JsonResult(response));
Console.WriteLine(e);
}
// var emailConfirmationToken = _userManager.GenerateEmailConfirmationTokenAsync(newUser);
// var tokenVerificationUrl = Url.Action("VerifyEmail", "Account", new {id = newUser.Id, token = emailConfirmationToken}, Request.Scheme);
// _messageService.Send(model.Email, "Verify your email", $"Click <a href=\"{tokenVerificationUrl}\">here</a> to verify your email");
}
public async Task <IActionResult> Register([FromBody] RegisterUserVM model)
{
try
{
//check if user already exists
var existingUser = await userManager.FindByEmailAsync(model.Email);
if (existingUser != null)
{
return(BadRequest("User already exists"));
}
//check if model is null
if (model == null)
{
return(BadRequest("User object cannot be null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid user object"));
}
//create user object
var user = new AppUser
{
Email = model.Email,
UserName = model.Email,//email serves as username as well
FirstName = model.FirstName,
LastName = model.LastName,
};
//save user
var result = await userManager.CreateAsync(user, model.Password);
//check if successful
if (result.Succeeded)
{
return(Ok("User has been created successfully"));
}
else
{
return(BadRequest("User was not successfully created"));
}
}
catch (Exception)
{
return(this.StatusCode(500));
}
}
public async Task <IActionResult> Reg(RegisterUserVM registerUserVM)
{
if (!ModelState.IsValid)
{
return(View(registerUserVM));
}
if (!await accountRepository.RegisterUser(registerUserVM))
{
ModelState.AddModelError(nameof(RegisterUserVM.UserName), "Registration failed...");
return(View(registerUserVM));
}
return(RedirectToAction(nameof(UserController.Index), "User"));
}
public async Task <HttpResponseMessage> RegisterAsync(RegisterUserVM viewModel)
{
try
{
string entity = JsonConvert.SerializeObject(viewModel);
var response = await Client.PostAsync("/api/account/register", new StringContent(entity, Encoding.UTF8, "application/json"));
return(response.EnsureSuccessStatusCode());
}
catch (Exception e)
{
throw e;
}
}
public async Task <ActionResult> Register(RegisterUserVM vm)
{
if (!await CanRegisterAsync())
{
return(View("RegisterDisabled"));
}
var info = Session.Get <RegistrationInfo>();
if (info == null && !(await _auth.IsFirstUserAsync()))
{
return(RedirectToAction("Login"));
}
if (!ModelState.IsValid)
{
return(await ViewRegisterFormAsync(vm, usesPasswordAuth : info == null));
}
try
{
var result = await _auth.RegisterAsync(vm, info?.Login);
if (!result.IsValidated)
{
return(RedirectToAction("RegisterSuccess", "Auth"));
}
if (vm.CreatePersonalPage)
{
_db.Entry(result.User).State = EntityState.Unchanged;
result.User.Page = await _pages.CreateDefaultUserPageAsync(vm, result.Principal);
await _db.SaveChangesAsync();
await _search.AddPageAsync(result.User.Page);
}
return(RedirectToAction("Index", "Home"));
}
catch (ValidationException ex)
{
SetModelState(ex);
return(await ViewRegisterFormAsync(vm, usesPasswordAuth : info == null));
}
}
private void Given_new_user_want_to_join_with_this_datas()
{
viewModel = new RegisterUserVM()
{
Name = "Joaquim",
Password = "******",
Email = "*****@*****.**",
City = "São Paulo",
PostalCode = "04473-150",
Linkedin = "linkedin.com/joaquim",
Neighborhood = "Vila Olimpia",
Street = "Rua teste",
Country = "Brasil",
State = "SP",
Number = "100"
};
}
public async Task <ApiResponse <RegisterUserVM> > RegisterAsync(RegisterUserVM userToRegister)
{
try
{
var user = new User {
UserName = userToRegister.UserName, Email = userToRegister.Email
};
var result = userToRegister.Password != null ? await _userManager.CreateAsync(user, userToRegister.Password) : await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
var errors = result.Errors.ToLookup(user.GetPropertyNames());
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status401Unauthorized, "Invalid Model", errors, null));
}
await _userManager.AddClaimAsync(user, new Claim("Email", user.Email));
await _userManager.AddToRoleAsync(user, "User");
if (_userManager.Options.SignIn.RequireConfirmedEmail)
{
var code = (await _userManager.GenerateEmailConfirmationTokenAsync(user)).UTF8ToBase64SafeUrl();
var deployingEmailResponse = await _emailSender.SendConfirmationEmailAsync(userToRegister.Email, code, userToRegister.ReturnUrl);
if (deployingEmailResponse.IsError)
{
userToRegister.ReturnUrl = $"/Account/ResendEmailConfirmation/?email={userToRegister.Email}&returnUrl={userToRegister.ReturnUrl.HtmlEncode()}";
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status500InternalServerError, "Registration had been Successful, but the email wasn't sent. Try again later.", null, userToRegister, deployingEmailResponse.ResponseException));
}
userToRegister.ReturnUrl = $"/Account/ConfirmEmail?email={userToRegister.Email}&returnUrl={userToRegister.ReturnUrl.HtmlEncode()}";
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status201Created, $"Registration for User \"{userToRegister.UserName}\" has been successful, activation email has been deployed to: \"{userToRegister.Email}\"", null, _mapper.Map(userToRegister, new RegisterUserVM())));
}
userToRegister.ReturnUrl = $"/Account/Login?returnUrl={userToRegister.ReturnUrl.HtmlEncode()}";
userToRegister.Ticket = await GenerateLoginTicketAsync(user.Id, user.PasswordHash, false);
await _signInManager.SignInAsync(user, false);
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status201Created, $"Registration for User \"{userToRegister.UserName}\" has been successful, you are now logged in", null, userToRegister));
}
catch (Exception ex)
{
return(new ApiResponse <RegisterUserVM>(StatusCodeType.Status500InternalServerError, "Registration Failed", null, null, ex));
}
}
public IHttpActionResult Register([FromBody] RegisterUserVM model)
{
using (_userRepo)
{
var salt = HashingPasswords.GenerateSalt();
var pw = HashingPasswords.GenerateHash(model.Password, salt);
_userRepo.Add(new User()
{
UserName = model.UserName,
PasswordHash = pw,
PasswordSalt = salt
});
_userRepo.SaveChanges();
return(Ok("User registered successfully."));
}
}
public ActionResult Put(string username, [FromBody] RegisterUserVM model)
{
if (ModelState.IsValid)
{
if (_userRepository.GetByUsername(username) == null)
{
return(NotFound(new OperationResponse()
{
IsValid = false,
Errors = new Dictionary <string, string>()
{
{ "username", "User does not exists." }
}
}));
}
var updatedUser = new UserDto()
{
Username = username, Email = model.Email, ClearTextPassword = model.Password, Timezone = model.Timezone
};
_userRepository.Update(updatedUser);
return(Ok(updatedUser));
}
else
{
var listErrors = ModelState.ToDictionary(
m => m.Key,
m => m.Value.Errors
.Select(s => s.ErrorMessage)
.FirstOrDefault(s => s != null)
);
return(BadRequest(new OperationResponse()
{
IsValid = false, Errors = listErrors
}));
}
}
