public ActionResult <string> Register([FromBody] RegisterRequestModel registerRequestModel) { if (_databaseService.Users.FirstOrDefault(t => t.Username == registerRequestModel.Username) != null) { throw new UsernameDuplicatedException("Username duplicated."); } // 创建用户 User user = new User(); user.Username = registerRequestModel.Username; user.Password = BCrypt.Net.BCrypt.HashPassword(registerRequestModel.Password); user.Nickname = registerRequestModel.Nickname; user.Status = 0; _databaseService.Users.Add(user); _databaseService.SaveChanges(); // 创建用户组信息 GroupToUser groupToUser = new GroupToUser() { GroupId = Group.GroupID.DEFAULT, UserId = user.Id }; _databaseService.GroupsToUsersRelation.Add(groupToUser); // 创建用户目录 var groupDirectory = EntityFile.CreateDirectoryRecord(user.Username, "/users", $"/users/{user.Username}", user); _databaseService.Files.Add(groupDirectory); _databaseService.SaveChanges(); return(Ok(new RegisterResultModel(user))); }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel requestModel) { //check allowed var existing = _userManager.Users.SingleOrDefault(x => x.Email == requestModel.Email); if (existing != null) { throw new UserMessageException("Username is already taken"); } var user = new User(requestModel.Email, requestModel.Email) { Created = DateTime.UtcNow }; IdentityResult createUserResult = await _userManager.CreateAsync(user, requestModel.Password); await _userManager.AddToRoleAsync(user, requestModel.Role.ToString()); if (!createUserResult.Succeeded) { throw new UserMessageException(createUserResult.Errors.First().Description); } return(Ok()); }
public async Task <ActionResult <RegisterResponseModel> > IndexPost([FromBody] RegisterRequestModel request) { var trimmedUsername = request.Username.Trim(); if (request.Password != request.PasswordConfirm) { return(BadRequest(new RegisterResponseModel("Passwords do not match"))); } if (request.Password.Length < 8) { return(BadRequest(new RegisterResponseModel("Password must be at least 8 characters"))); } if (await database.Users.AnyAsync(u => u.Name == trimmedUsername)) { return(BadRequest(new RegisterResponseModel("Username already taken"))); } var salt = crypto.RandomSalt(); var user = new User { Name = trimmedUsername, PasswordHash = crypto.Hash(request.Password, salt), PasswordSalt = salt, JoinDate = DateTime.Now }; database.Users.Add(user); await database.SaveChangesAsync(); return(new RegisterResponseModel("ok")); }
/// <summary> /// Admins the register asynchronous. /// </summary> /// <param name="model">The model.</param> /// <returns></returns> public async Task <bool> AdminRegisterAsync(RegisterRequestModel model) { try { SqlConnection connection = DBConnection(); string encrypted = EncryptPassword(model.Password); SqlCommand command = StoreProcedureConnection("spRegisterAdmin", connection); command.Parameters.AddWithValue("FirstName", model.FirstName); command.Parameters.AddWithValue("LastName", model.LastName); command.Parameters.AddWithValue("PhoneNumber", model.PhoneNumber); command.Parameters.AddWithValue("Email", model.Email); command.Parameters.AddWithValue("Password", encrypted); command.Parameters.AddWithValue("UserAddress", model.UserAddress); command.Parameters.AddWithValue("ServiceType", model.ServiceType); connection.Open(); int result = await command.ExecuteNonQueryAsync(); connection.Close(); if (result != 0) { return(true); } else { return(false); } } catch (Exception e) { throw e; } }
public async Task <ActionResult> Register(RegisterRequestModel model) { var roles = new SelectList(new List <string>() { Roles.StudentRole, Roles.AdminRole, Roles.TeacherRole }); model.Roles = roles; if (ModelState.IsValid) { var user = new User { UserName = model.Username, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, StudentNumber = model.StudentNumber }; await this.userManager.CreateAsync(user, "12345678"); await this.userManager.AddToRoleAsync(user, model.Role); return(RedirectToAction("Index", "Users")); } return(View(model)); }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model) { if (await _authService.UserAlreadyExistsAsync(model.Email)) { return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponseModel { Status = "Error", Message = "Email already exists in the database. Please use an unique email for registration, or contact one of our administrator to recover your password/account." })); } ApplicationUser user = new ApplicationUser() { Email = model.Email, SecurityStamp = Guid.NewGuid().ToString(), UserName = model.Email, }; var result = await _authService.CreateUserAsync(user, model.Password); if (!result.Succeeded) { var errorList = result.Errors.Select(e => e.Description); return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponseModel { Status = "Error", Message = "User creation failed. Please check user details and try again.", Errors = errorList })); } return(Ok(new BaseResponseModel { Status = "Success", Message = "User created successfully." })); }
public IHttpActionResult Register(RegisterRequestModel requestModel) { if (ModelState.IsValid) { UsernameCommand uniqueUsernameCommand = new UsernameCommand(requestModel.Username); IEnumerable <ValidationResult> validations = commandDispatcher.Validate(uniqueUsernameCommand); ModelState.AddModelErrors(validations); if (ModelState.IsValid) { AccountCommand accountCommand = new AccountCommand(requestModel.Username, requestModel.Password); Account account = commandDispatcher.Dispatch <AccountCommand, Account>(accountCommand); AuthCommand authCommand = new AuthCommand(account.Id, false); Authentication authentication = commandDispatcher.Dispatch <AuthCommand, Authentication>(authCommand); AccountResponseModel responseModel = Mapper .Map <AccountResponseModel>(authentication) .Map(account); return(Ok(responseModel)); } } return(BadRequest(ModelState)); }
public RegisterViewModel() { RegistrationCommand = new RelayCommand <object>(Register); ImportImageCommand = new RelayCommand <object>(ImportImage); RegisterRequestModel = new RegisterRequestModel(); IsLoading = false; }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model) { try { var user = await _accountService.CreateAsync(new () { UserName = model.Email, Email = model.Email, PhoneNumber = model.PhoneNumber, Password = model.Password }); // TODO: Send confirm email mail return(Ok()); } catch (UserAlreadyExistsException) { return(BadRequest(new ErrorViewModel() { ErrorKey = "user_already_exists" })); } catch (UserCreateException) { return(BadRequest(new ErrorViewModel() { ErrorKey = "user_could_not_be_created" })); } catch (Exception) { return(StatusCode(500, ErrorViewModel.UNHANDLED_EXCEPTION)); } }
public IHttpActionResult Register(RegisterRequestModel data) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ItemResponse <string> response = new ItemResponse <string>(); string guid = _userService.Register(data); if (guid == "1") { response.Item = "Sorry, that UserName is already taken!"; } else if (guid == "0") { response.Item = "An account with that email already exists!"; } else { response.Item = "0"; } return(Ok(response)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <ApiBaseResponse> RegisterAsync(RegisterRequestModel requestModel) { ApiBaseResponse apiBaseResponse = new ApiBaseResponse(); var isExistedEmail = await _userService.ExistedByEmailAsync(requestModel.Email); if (isExistedEmail) { throw new BlogSolutionException("The email address has already exist.", ApplicationStatusCode.AnErrorHasOccured); } var isExistedUsername = await _userService.ExistedByUsernameAsync(requestModel.Username); if (isExistedUsername) { throw new BlogSolutionException("The username has already exist.", ApplicationStatusCode.AnErrorHasOccured); } var password = new PasswordHasher(requestModel.Password); await _userService.AddUserAsync(new User { Username = requestModel.Username, Name = requestModel.Name, Email = requestModel.Email, PhoneNumber = requestModel.PhoneNumber, PasswordHash = password.Hash, PasswordSalt = password.Salt }); return(apiBaseResponse); }
public async Task <IActionResult> RegisterAsync(RegisterRequestModel model) { try { if (model != null) { if (await account.RegisterAsync(model)) { return(Ok(new { Success = true, Message = "User is Registered SuccessFully", model })); } else { return(BadRequest(new { Success = false, Message = "User is not Registered", model })); } } else { return(BadRequest(new { Success = false, Message = "Insufficients details....", model })); } } catch (Exception e) { return(BadRequest(new { Success = false, Message = e.Message })); } }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model) { var userExists = await userManager.FindByNameAsync(model.Username); if (userExists != null) { return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponse { Status = "Error", Message = "User already exists!" })); } User user = new User() { Email = model.Email, SecurityStamp = Guid.NewGuid().ToString(), UserName = model.Username }; var result = await userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(StatusCode(StatusCodes.Status500InternalServerError, new BaseResponse { Status = "Error", Message = "User creation failed! Please check user details and try again." })); } return(Ok(new BaseResponse { Status = "Success", Message = "User created successfully!" })); }
public async Task <AuthenticationResponseModel> RegisterAsync(RegisterRequestModel registerRequest) { if (registerRequest == null) { throw new TracketBadRequestException(_localizer[Constants.LocalizedValueKeys.Messages.PleaseProvideRequiredInformationMessage]); } //IdentityRole findRole = await _roleManager.FindByNameAsync(registerRequest.RoleName); //if (findRole == null) //{ // throw new TracketNotFoundException(_localizer[Constants.LocalizeKeys.RoleNotFound]); //} using (var transaction = _unitOfWork.DBContext.Database.BeginTransaction()) { TracketUser identityUser = new TracketUser { Email = registerRequest.Email, UserName = "******" }; } return(null); }
public async Task <(AccountResponseModel, bool)> Update(RegisterRequestModel registerRequest) { // attempt to sign in var result = await _signInManager.PasswordSignInAsync(registerRequest.Email, registerRequest.Password, false, false); // return false if sign in fails if (!result.Succeeded) { return(null, false); } // if login succeeded, return updated user var logged = await _userManager.FindByEmailAsync(registerRequest.Email); logged.Email = registerRequest.Email; logged.UserName = registerRequest.Email; logged.Name = registerRequest.Name; var updated = await _userManager.UpdateAsync(logged); // return false if update fails if (!updated.Succeeded) { return(null, false); } var claims = await _userManager.GetClaimsAsync(logged); return(ToResponseModel(logged, claims), true); }
/// <summary> /// Edit action method to redirect from index page to update page /// </summary> /// <param name="model"></param> /// <returns></returns> public ActionResult Edit(RegisterRequestModel model) { RegisterRequestModel emp = employeeRepository.GetEmployee(model.EmpId); ModelState.Clear(); return(View("RegisterEmployee", emp)); }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model) { var userExist = await _userManager.FindByNameAsync(model.UserName); if (userExist != null) { return(StatusCode(StatusCodes.Status500InternalServerError, new Response { Status = "Erro", Message = "Usuário já existe" })); } User user = new User() { Email = model.Email, SecurityStamp = Guid.NewGuid().ToString(), UserName = model.UserName }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(StatusCode(StatusCodes.Status500InternalServerError, new Response { Status = "Erro", Message = "Ops, ocorreu um erro no sistema" })); } return(Ok(new Response { Status = "Sucesso", Message = "Usuário criado com sucesso" })); }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel credentials) { if (ModelState.IsValid) { var user = new User { UserName = credentials.Name, Email = credentials.Email }; var result = await _userManager.CreateAsync(user, credentials.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); return(new JsonResult(new Dictionary <string, object> { { "access_token", GetAccessToken(credentials.Name) }, { "id_token", GetIdToken(user) }, { "name", user.UserName }, { "id", user.Id } })); } return(Errors(result)); } return(Error("Unexpected error")); }
public bool RegisterEmployee(RegisterRequestModel employee) { try { Employee validEmployee = dbContext.Employees.Where(x => x.name == employee.name && x.gender == employee.gender).FirstOrDefault(); if (validEmployee == null) { int departmentId = dbContext.Departments.Where(x => x.deptname == employee.department).Select(x => x.deptid).FirstOrDefault(); Employee newEmployee = new Employee() { name = employee.name, gender = employee.gender, deptid = departmentId, salaryid = Convert.ToInt32(employee.salaryid), startdate = employee.startdate, description = employee.description }; Employee returnData = dbContext.Employees.Add(newEmployee); } int result = dbContext.SaveChanges(); if (result > 0) { return(true); } else { return(false); } } catch (Exception e) { throw e; } }
public async Task <ResponseViewModel> Create([FromBody] RegisterRequestModel model) { var oldOperator = await _accountService.GetByUsername(model.Username); if (oldOperator != null) { var response = new ResponseViewModel { Result = false, }; response.Messages.Add("Email đã tồn tại"); return(response); } else { var account = new Account { Username = model.Email, FullName = model.Fullname, Email = model.Email, Phone = model.Phone, Address = model.Address, DateOfBirth = model.DateOfBirth, AccountTypeId = 3, AccountStatusId = 1, Password = Encryptor.MD5Hash(model.Password), }; ApplyUserCreateEntity(account); return(await Save(account)); } }
public IActionResult PostUser([FromBody] RegisterRequestModel user) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.Users.Add(new WPAssign.Models.User() { EmailId = user.EmailId, Name = user.Name, Id = Guid.NewGuid().ToString(), Password = user.Password, PhoneNumber = user.PhoneNumber, Username = user.Username, Tickets = new List <Ticket>() }); _context.SaveChanges(); return(Ok(new { Message = "Ok" })); } catch (Exception) { throw; } }
public HttpResponseMessage Registration(RegisterRequestModel user) { try { this.userManager.Registration(new UserDto { Login = user.Login, Name = user.Name, SurName = user.SurName, MiddleName = user.MiddleName, Email = user.Email, Password = user.Password, ConfirmPassword = user.ConfirmPassword, Group = user.Group, FacultyID = user.FacultyID, KeyWord = user.KeyWord }, "Admin"); this.userManager.SignIn(new UserDto { Login = user.Login, Password = user.Password, RememberMe = false }, true); return(Request.CreateResponse(HttpStatusCode.OK)); } catch (ArgumentException ex) { return(Request.CreateErrorResponse(HttpStatusCode.PreconditionFailed, ex.Message)); } }
public async Task <ActionResult <RegisterResponseModel> > RegisterAsync(RegisterRequestModel request) { var response = new RegisterResponseModel(); var user = await this.userService .GetUserByRegistrationCodeAsync(request.RegistrationCode); if (Object.Equals(user, null)) { response.Status = -1; response.Message = "Invalid Registration Code."; return(Ok(response)); } if (user.IsActivatedCode) { response.Status = -2; response.Message = "The Registration Code Is Taken."; return(Ok(response)); } var hashedPassword = PasswordHasher .HashPassword(request.Password); await this.userService .UpdateUserToRegistered(user.Id, request.Username, hashedPassword, request.Email); response.Status = 1; response.Message = "Success."; return(Ok(response)); }
public virtual async Task <AuthResponse> Register(RegisterRequestModel model, CancellationToken cancellationToken = default(CancellationToken)) { HttpResponseMessage httpResponse = await this.Client.PostAsJsonAsync($"api/auth/register", model, cancellationToken).ConfigureAwait(false); this.HandleResponseCode(httpResponse); return(JsonConvert.DeserializeObject <AuthResponse>(httpResponse.Content.ContentToString())); }
public async Task <IActionResult> AdminRegistration(RegisterRequestModel register) { try { if (register != null) { if (await account.AdminRegisterAsync(register)) { return(Ok(new { Success = true, Message = "Admin is Registered SuccessFully", register })); } else { return(BadRequest(new { Success = false, Message = "Admin is not Registered", register })); } } else { return(BadRequest(new { Success = false, Message = "Insufficients details....", register })); } } catch (Exception e) { return(BadRequest(new { Success = false, Message = e.Message })); } }
public async Task <ActionResult <LoginResponseModel> > Register([FromBody] RegisterRequestModel model) { var user = new User { Email = model.Email, UserName = model.UserName, }; var result = await this.userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(this.BadRequest(result.Errors)); } var token = this.identityService.GenerateJwtToken( user.Id, user.UserName, this.appSettings.Secret); return(new LoginResponseModel { Token = token, UserName = user.UserName, Id = user.Id }); }
public async Task <ActionResult> Register(RegisterRequestModel model) { IdentityResult result = new IdentityResult(); if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName }; result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { ProfileDetailsModel profile = new ProfileDetailsModel { UserID = user.Id, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email }; return(Json(new { Success = true, User = profile })); } } return(Json(new { Success = false, Message = result.Errors })); }
public bool RegisterEmployee(RegisterRequestModel employee) { try { Employee validEmployee = dbContext.Employees.Where(x => x.Name == employee.Name && x.Gender == employee.Gender).FirstOrDefault(); if (validEmployee == null) { int departmentId = dbContext.Departments.Where(x => x.DeptName == employee.Department).Select(x => x.DeptId).FirstOrDefault(); Employee newEmployee = new Employee() { Name = employee.Name, Gender = employee.Gender, DepartmentId = departmentId, SalaryId = Convert.ToInt32(employee.Salary), StartDate = employee.StartDate, Description = employee.Description }; Employee returnData = dbContext.Employees.Add(newEmployee); } int result = dbContext.SaveChanges(); if (result > 0) { return(true); } else { return(false); } } catch (Exception e) { return(false); } }
public async Task <IActionResult> Post([FromBody] RegisterRequestModel model) { model.RoleName = "GooiosVip0"; if (ModelState.IsValid) { //check the verification code var verification = await _verificationProxy.GetVerification(BizCode.Register, model.Mobile); if (verification == null) { return(new BadRequestObjectResult("验证码不正确.")); } if (verification.Code != model.VerificationCode) { return(new BadRequestObjectResult("验证码不正确.")); } var role = await _roleManager.FindByNameAsync(model.RoleName); if (role == null) { return(new BadRequestObjectResult("找不到指定角色.")); } var user = new ApplicationUser { UserName = model.Mobile, PhoneNumber = model.Mobile }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await _verificationProxy.SetVerificationUsed(verification); var r = await _userManager.AddToRoleAsync(user, model.RoleName); return(new OkResult()); } else { return(new BadRequestObjectResult("创建用户失败.")); } } else { var errors = ModelState.Values.Select(o => o.Errors); var messageBuilder = new StringBuilder(); foreach (var error in errors) { string errMsg = string.Join(",", error.Select(o => o.ErrorMessage)); messageBuilder.Append(errMsg); messageBuilder.Append(";"); } return(new BadRequestObjectResult($"参数错误: {messageBuilder.ToString()}")); } }
public async Task <IActionResult> Register([FromBody] RegisterRequestModel model) { var response = await accountService.Register(model); if (response != null) { return(Ok(response)); } return(NotFound("Prisiregistruoti nepavyko")); }