public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _accountDSL.Register(model); if (!result.Succeeded) { return(BadRequest(result.Errors)); } return(Ok(await _accountDSL.AddToken(model))); }
public async Task <IActionResult> register([FromBody] RegisterRequestViewModel request) { var result = await _userService.RegisterRequest(request); if (result.UserName == null) { return(BadRequest("Register is failed")); } else { return(new OkObjectResult(new { statusCode = HttpStatusCode.OK, data = result })); } }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(GetModelStateErrorResponse(ModelState))); } var resp = await RegisterUser(model); if (resp.Type != ResponseType.Success) { return(BadRequest(resp)); } return(Ok(resp)); }
public async Task <UserViewModel> CreateUser(RegisterRequestViewModel viewModel, string token) { var json = JsonConvert.SerializeObject(viewModel);// convert object to json // create request var client = _httClientFactory.CreateClient(); var httpcontent = new StringContent(json, Encoding.UTF8, "application/json"); client.BaseAddress = new Uri("http://apieshop.somee.com"); client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token); var response = await client.PostAsync("/api/User/register", httpcontent); var data = await response.Content.ReadAsStringAsync(); var user = JsonConvert.DeserializeObject <ResultApiCreateUser>(data); return(user.data); }
public IActionResult Register(RegisterRequestViewModel model) { if (ModelState.IsValid) { try { _accountManager.Register(model); return(RedirectToAction("Login", "Account")); } catch (AppException app) { ModelState.AddModelError(string.Empty, app.Message); } } return(View()); }
public async Task <IActionResult> DoctorRegister([FromBody] UsersModel model) { try { ResultModel res = new ResultModel(); if (model == null) { return(BadRequest(new Exception("Unable to fetch record"))); } else { var req = new RegisterRequestViewModel { Email = model.Email, Name = model.FirstName + " " + model.LastName, Password = "******",//model.Password, Role = model.Role }; res = await RegisterAsync(req); if (res.Code == 4) { //return BadRequest(result.Response); return(Json(res)); } else { model.loginId = res.Response; if (!string.IsNullOrEmpty(model.Role) && model.Role.ToLower().Equals("doctor")) { this._repo.AddDoctor(model); } else { this._repo.AddNurse(model); } return(Json(res)); //return Ok(); } } } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task <ResultModel> RegisterAsync([FromBody] RegisterRequestViewModel model) { //var aVal = 0; var blowUp = 1 / aVal; ResultModel res = new ResultModel(); if (!ModelState.IsValid) { //return BadRequest(ModelState); var errors = ModelState.Values.SelectMany(v => v.Errors).Select(a => a.Exception).ToList(); res.Code = 4; res.Response = String.Join(',', errors); return(res); } var user = new AppUser { UserName = model.Email, Name = model.Name, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { //return BadRequest(result.Errors); res.Code = 4; res.Response = string.Join(',', result.Errors.Select(a => a.Description).ToList()); return(res); } await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); if (string.IsNullOrEmpty(model.Role)) { await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Patient)); } else { await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", model.Role.ToLower())); } res.Code = 1; res.Response = user.Id; return(res);//Ok(new RegisterResponseViewModel(user)); }
public void Register_RegisterSuccess() { //Arrange var mockRegisterRequest = new RegisterRequestViewModel() { Password = "******", Balance = 1, ConfirmPassword = "******", LoginName = "MockLoginName" }; // Act var result = _accountController.Register(mockRegisterRequest); var redirectResult = (RedirectToActionResult)result; //Assert Assert.True(redirectResult.ControllerName == "Account"); Assert.True(redirectResult.ActionName == "Login"); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new AppUser { FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } return(Ok()); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { await ValidateEmailAsync(model.Email); await ValidateNameAsync(model.Name); var user = new ApplicationUser { Email = model.Email, UserName = model.Name, }; var createUserResult = await _userManager.CreateAsync(user, model.Password); if (!createUserResult.Succeeded) { return(BadRequest(ModelState)); } return(Ok(user)); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new AppUser { UserName = model.Name, Name = model.Name, Email = model.Email, PhoneNumber = model.PhoneNumber }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Action( action: "ConfirmEmail", controller: "Account", values: new { userId = user.Id, code, model.RedirectUrl }, protocol: Request.Scheme); await _emailSender.SendEmailAsync(user.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("phoneNumber", user.PhoneNumber)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer)); return(Ok()); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new ApplicationUser { Email = model.Email, Nome = model.Name, SobreNome = model.SobreNome, UserName = model.Email, Cep = model.Cep, Cidade = model.Cidade, Estado = model.Estado, Endereco = model.Endereco, Pais = model.Pais, PhoneNumber = model.Telefone }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Nome)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Operador)); await _userManager.AddToRoleAsync(user, "operador"); return(Ok(new RegisterResponseViewModel(user))); }
public IActionResult RegisterUser([FromBody] RegisterRequestViewModel request) { if (string.IsNullOrWhiteSpace(request.Name)) { return(BadRequest(new ErrorViewModel($"{nameof(request.Name)} cannot be empty", nameof(request.Name)))); } if (!EmailHelper.IsEmailValid(request.Email)) { return(BadRequest(new ErrorViewModel($"{nameof(request.Email)} is not valid", nameof(request.Email)))); } if (string.IsNullOrWhiteSpace(request.Password)) { return(BadRequest(new ErrorViewModel { Message = $"{nameof(request.Password)} cannot be empty" })); } if (!PasswordValidator.IsPassWordValid(request.Password)) { return(BadRequest(new ErrorViewModel { Message = "Password must be between 8 and 64 characters and must contain both uppercase and lowercase letters" })); } // Trim spaces from name + email request.Name = request.Name.Trim(); request.Email = request.Email.Trim(); if (_userService.GetUser(request.Email) != null) { return(BadRequest(new ErrorViewModel($"A user with email {request.Email} already exists", nameof(request.Email)))); } var user = _userService.Register(request.Name, request.Email, request.ShowEmail, request.Password, string.Empty, RemoteIpAddress); return(Ok(user)); }
public IActionResult Register([FromBody] RegisterRequestViewModel request) { User newUser = new User { FirstName = request.FirstName, LastName = request.LastName, Password = request.Password, Role = request.Role, Username = request.Username, PrimaryAddress = new Address { State = request.State, StreetAddress = request.StreetAddress, City = request.City, ZipCode = request.ZipCode } }; _userRepository.InsertRecord(newUser); return(Ok(newUser)); }
public void Register(RegisterRequestViewModel request) { Log.Information("Start - Registration request for user: {0}", request.LoginName); var account = _accountRepository.GetByLoginName(request.LoginName); if (account != null && account.Id != 0) { CommonHelper.ThrowAppException(string.Format("Login name {0} already exist!", request.LoginName)); } _accountRepository.Insert(new AccountEntity() { //TODO Auto Generate AccountNumber = CommonHelper.GenerateAccountNumber(_accountRepository.GetNextAccountId(request.LoginName)), Balance = request.Balance, CreateDate = DateTime.Now, LoginName = request.LoginName, Password = CommonHelper.EncodePasswordToBase64(request.Password, _config.GetValue <string>("HashKey")), }); Log.Information("End - Registration request for user: {0}", request.LoginName); }
public async Task<IActionResult> Register([FromBody]RegisterRequestViewModel model) { //var aVal = 0; var blowUp = 1 / aVal; if (!ModelState.IsValid) { return BadRequest(ModelState); } var user = new AppUser { UserName = model.Email, Name = model.Name, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) return BadRequest(result.Errors); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer)); return Ok(new RegisterResponseViewModel(user)); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { var errorsList = ModelState.Keys.SelectMany(key => ModelState[key].Errors.Select(error => new IdentityError { Code = "Validation", Description = error.ErrorMessage })); return(BadRequest(errorsList)); } var user = new ApplicationUser { UserName = model.Email, Name = model.Name, CompanyName = model.CompanyName, Email = model.Email, Id = Guid.NewGuid().ToString() }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _userManager.AddClaimAsync(user, new Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new Claim("role", Roles.Consumer)); await _userManager.AddClaimAsync(user, new Claim("companyName", user.CompanyName)); return(Ok(new RegisterResponseViewModel(user))); }
public async Task <IActionResult> PatientRegister([FromBody] UsersModel model) { try { ResultModel res = new ResultModel(); if (model == null) { return(BadRequest(new Exception("Unable to fetch record"))); } else { var req = new RegisterRequestViewModel { Email = model.Email, Name = model.FirstName + " " + model.LastName, Password = model.Password, //Role = null }; res = await RegisterAsync(req); if (res.Code == 4) { //return BadRequest(result.Response); return(Json(res)); } else { model.loginId = res.Response; this._repo.AddPatient(model); return(Json(res)); //return Ok(); } } } catch (Exception e) { return(BadRequest(e)); } }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { //var aVal = 0; var blowUp = 1 / aVal; if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new AppUser { UserName = model.Email, Name = model.Name, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } var token = await _userManager.GenerateEmailConfirmationTokenAsync(user); var confirmationLink = Url.Action(nameof(ConfirmEmail), "Account", new { token, email = user.Email }, Request.Scheme); var message = "Confirmation email link " + confirmationLink; await _emailSender.SendEmailAsync(user.Email, "Email verification", message); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer)); return(Ok(new RegisterResponseViewModel(user))); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { //var aVal = 0; var blowUp = 1 / aVal; if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new TIRIRIT_USER { UserName = model.UserName, FIRST_NAME = model.FirstName, LAST_NAME = model.LastName, Email = model.EmailAddress }; var result = await this.userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.PreferredUserName, user.UserName)); await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.GivenName, user.FIRST_NAME)); await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.FamilyName, user.FIRST_NAME)); await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Email, user.Email)); await this.userManager.AddToRoleAsync(user, Roles.StandardUser); return(Ok(new RegisterResponseViewModel(user))); }
public async Task <IActionResult> CreateUser(RegisterRequestViewModel viewModel) { if (ModelState.IsValid) { var token = HttpContext.Session.GetString("Token"); var reponse = await _userApiClient.CreateUser(viewModel, token); if (reponse != null) { TempData["Result"] = "Create Success"; return(Redirect("Index")); } else { ViewBag.Erorr = "Create user failed"; return(View()); } } else { ViewBag.Erorr = "Create user failed"; return(View()); } }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new ApplicationUser { UserName = model.Name, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _userManager.AddClaimAsync(user, new Claim("account_id", user.Id)); return(Ok()); }
public IActionResult CreateUser() { var user = new RegisterRequestViewModel(); return(View(user)); }
public Task <RegisterResponseViewModel> AddToken(RegisterRequestViewModel model) { var user = AccountHelper.MapAppUser(model); return(_accountDAL.AddToken(user)); }
public Task <IdentityResult> Register(RegisterRequestViewModel model) { var user = AccountHelper.MapAppUser(model); return(_accountDAL.Register(user, model.Password)); }
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model) { //var aVal = 0; var blowUp = 1 / aVal; if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (Domains.IsValid(model.Domain)) { return(BadRequest("Domain not supported")); } var user = new AppUser { DomainUsername = model.DomainUsername, UserName = model.Email, Name = model.Name, Email = model.Email, Domain = model.Domain }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } var appUser = new User() { Email = model.Email, AdUser = new ADUser() { Username = model.DomainUsername, Groups = new List <string>(model.Groups) }, Interests = new List <string>(model.Interests), Name = model.Name, Surname = model.Surname, IdentityId = (await _userManager.FindByEmailAsync(model.Email)).Id }; var appRegister = new CreateUserRequest() { Key = _config["KEY"], User = appUser }; Api.MakeRequest(_config["API_ADDRESS"] + "/Identity/createUser", JsonConvert.SerializeObject(appRegister)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("username", user.UserName)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Student)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("domain", user.Domain)); await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("domainUsername", user.DomainUsername)); foreach (var interest in model.Interests) { await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("interest", interest)); } foreach (var group in model.Groups) { await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("group", group)); } return(Ok(new RegisterResponseViewModel(user))); }
public IActionResult Register(RegisterRequestViewModel model) { _accountService.Register(model, Request.Headers["origin"]); return(Ok(new { message = "Registration successful, please check your email for verification instructions" })); }
public async Task <ActionResult <ResponseStatusViewModel> > Put(RegisterRequestViewModel model) { ResponseStatusViewModel responseModel = new ResponseStatusViewModel(); responseModel.Result = true; if (string.IsNullOrWhiteSpace(model.FirstName)) { responseModel.Result = false; responseModel.Messages.Add("First name cannot be blank."); } if (string.IsNullOrWhiteSpace(model.LastName)) { responseModel.Result = false; responseModel.Messages.Add("Last name cannot be blank."); } if (string.IsNullOrWhiteSpace(model.Username)) { responseModel.Result = false; responseModel.Messages.Add("Username cannot be blank."); } if (string.IsNullOrWhiteSpace(model.Password)) { responseModel.Result = false; responseModel.Messages.Add("Password cannot be blank."); } if (!responseModel.Result) { return(new BadRequestObjectResult(responseModel)); } MemberModel member = new MemberModel() { Email = model.Email, UserName = model.Username, FirstName = model.FirstName, LastName = model.LastName, TwoFactorEnabled = true }; IdentityResult result = await _userManager.CreateAsync(member, model.Password); if (result.Succeeded) { IdentityRole memberRole = _roleManager.Roles.FirstOrDefault(r => r.Name == "Member"); IdentityRole adminRole = _roleManager.Roles.FirstOrDefault(r => r.Name == "Admin"); if (memberRole == null) { await _userManager.AddToRoleAsync(member, "Member"); } await _userManager.AddToRoleAsync(member, memberRole.Name); if (model.Username == "Admin") { if (adminRole == null) { await _userManager.AddToRoleAsync(member, "Admin"); } await _userManager.AddToRoleAsync(member, adminRole.Name); } responseModel.Result = true; responseModel.Messages.Add("Thank you for registering your account."); return(new OkObjectResult(responseModel)); } else { responseModel.Result = false; responseModel.Messages.Add("Unable to create your user account."); return(new BadRequestObjectResult(responseModel)); } }