public async Task<LoginDto> Register([FromBody] UserDto user) { var request = new RegisterUserRequest { User = user }; return await _mediator.ExecuteAsync(request).ConfigureAwait(false); }
public IActionResult Register([FromBody] RegisterUserRequest request) { try { _userOperationsHandler.RegisterNewUser(request); return(Created("", null)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <ActionResult> Register(RegisterAction action, CancellationToken token) { var request = new RegisterUserRequest { EmailAddress = action.EmailAddress, Password = action.Password }; await this._requestContext.Send(request, token).ConfigureAwait(false); await this._requestContext.CommitAsync(token); return(this.Ok()); }
protected override async Task <Response <CreateResult> > HandleCore(RegisterUserRequest request) { var user = new Database.Collections.User(request.UserName, request.Email); var result = await _userManager.CreateAsync(user, request.Password); if (result.Succeeded) { _logger.LogInformation(3, "User created a new account with password."); return(new Response <CreateResult>(CreateResult.Created)); } return(new Response <CreateResult>(CreateResult.NotCreated)); }
public async Task <IActionResult> Register(RegisterUserRequest registerUserRequest) { var registrationResult = await _authenticationService.RegisterAsync(registerUserRequest.UsernameOrEmail, registerUserRequest.Password); if (!registrationResult.Success) { return(BadRequest(new AuthenticationResult() { Errors = registrationResult.Errors })); } return(Ok(registrationResult.CastTo <RegisterUserResponse>())); }
public void RegisterUser(RegisterUserRequest req) { string userId = UserIdFactory.GetUserId(); db.User.Add(new User() { Id = userId, LoginId = req.LoginId, Name = req.Name, MailAddress = req.MailAddress }); db.SaveChanges(); }
public async Task <RegisterUserResponse> RegisterUser(RegisterUserRequest request) { //await ValidateToken(); var checkUserEmailRegistered = _userService.GetUserByEmail(request.Email); if (checkUserEmailRegistered != null) { throw new Exception("Email de usuário já cadastrado"); } return(new RegisterUserResponse() { User = _userService.RegisterUser(request.Email, request.Password, request.Name, request.PrimaryTelephone, request.SecundaryTelephone, request.Cpf, request.UserType, request.Cep, request.AverageTicketPoints, request.RegisterClientsPoints, request.SalesNumberPoints, request.AverageItensPerSalePoints, request.InviteAllyFlowersPoints, request.TemporadaId, request.MotherFlowerId, request.IsActive, request.Birthday) }); }
private static async Task SeedUser(IIdentityServiceClient client, string userName, string password) { var request = new RegisterUserRequest { Email = userName, Password = password, }; var seedResponse = await client.RegisterUserAsync(request); // Sanity check seedResponse.UserId.Should().NotBeNullOrWhiteSpace(); seedResponse.Errors.Should().BeEmpty(); }
//[InlineData(null)] //[InlineData("")] public async Task SecurityServiceManager_RegisterUser_UserIsRegistered(String password) { TestScenario testScenario = TestScenario.RegisterUserSuccess; SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario); RegisterUserRequest request = SecurityServiceManagerTestData.GetRegisterUserRequest; request.Password = password; RegisterUserResponse response = await securityServiceManager.RegisterUser(request, CancellationToken.None); response.ShouldNotBeNull(); response.UserId.ShouldNotBe(Guid.Empty); }
public IActionResult Register(string code, string state, string error, string error_description) { var req = new RegisterUserRequest() { AuthCode = code, State = state, Error = error, ErrorDescription = error_description }; var resp = ServiceRegistrar.Current.GetMediator().Send(req); return(Ok()); }
public static async Task <string> CreateUserAndSignIn(this HttpClient client) { string email = DataGenerator.RandomEmail(); var url = new Uri("api/users/Register", UriKind.Relative); StringContent content = new RegisterUserRequest { Email = email }.ToStringContent(); HttpResponseMessage response = await client.PostAsync(url, content); UserLoginResponse userLoginResponse = await response.OnSuccessDeserialize <UserLoginResponse>(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userLoginResponse.Token); return(email); }
public IHttpActionResult SignUp(RegisterUserRequest request) { try { var root = Request.RequestUri.GetLeftPart(UriPartial.Authority); var user = this.dataServiceAuth.RegisterUser(request); var thread = new Thread(delegate() { user.SendVerificationEmail(root); }); thread.Start(); return(new HttpActionResult <GenericResponse <UserEntity> >( HttpStatusCode.OK, new GenericResponse <UserEntity> { Result = user } )); } catch (GeneralException exception) { return(new HttpActionResult <GenericResponse <UserEntity> >( HttpStatusCode.OK, new GenericResponse <UserEntity> { Error = new Error { Code = exception.Code, ResponseCode = HttpStatusCode.OK, Message = exception.AllMessages() } } )); } catch (Exception exception) { return(new HttpActionResult <GenericResponse <UserEntity> >( HttpStatusCode.InternalServerError, new GenericResponse <UserEntity> { Error = new Error { Code = 10699, ResponseCode = HttpStatusCode.InternalServerError, Message = exception.AllMessages() } } )); } }
public void Add_Throws_User_Is_Already_Registered() { var registerUserRequest = new RegisterUserRequest { Email = "*****@*****.**", Password = "******" }; var userService = AddUserRequestValidatorMock.Create(); userService.UserSecurityRepositoryMock.Setup(us => us.GetByEmail(registerUserRequest.Email)).Returns(UserSecurity.CreateBasic(Guid.Empty, string.Empty, string.Empty)); var exception = Assert.Throws <DenialException>(() => userService.DataValidate(registerUserRequest, ActionType.Add)); Assert.AreEqual(exception.Message, "UserIsAlreadyRegistered"); Assert.AreEqual(exception.StatusCode, HttpStatusCode.BadRequest); }
public RegisterUserResponse RegisterUser(RegisterUserRequest request) { RegisterUserResponse retval = default; try { retval = _DAL.RegisterUser(request); } catch (Exception e) { //log retval = new RegisterUserResponseDontAdd(); } return(retval); }
//[Consumes("multipart/form-data")] //[AllowAnonymous] public async Task <IActionResult> Register([FromBody] RegisterUserRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _userService.Register(request); if (!result.IsSuccessed) { return(BadRequest(result)); } return(Ok(result)); }
public NewRegisterUserPage() { InitializeComponent(); NavigationPage.SetHasNavigationBar(this, false); _objGenderViewModel = new GenderViewModel(); RadioGenderCheck.ItemsSource = _objGenderViewModel.GetRadioType(); _objRegisterUserRequest = new RegisterUserRequest(); BindingContext = _objRegisterUserRequest; _objRegisterUserResponse = new RegisterUserResponse(); _apiServices = new RestApi(); _baseUrl = Settings.Url + Domain.RegisterUserApiConstant; }
public async Task <AuthenticationResult> RegisterAsync(RegisterUserRequest registerRequest) { var dbUser = this.mapper.Map <DbUser>(registerRequest); this.CheckCreateUserConflicts(dbUser); const string role = "User"; dbUser.Role = role; dbUser.Articles = new List <string>(); await this.context.Users.InsertOneAsync(dbUser); var credentials = this.mapper.Map <UserCredentials>(dbUser); return(this.AuthenticateUser(credentials)); }
public async Task RegisterSuccess(string password, string username, string email, string name, AccountType a) { var req = new RegisterUserRequest() { Password = password, AccountType = a.ToString(), Email = email, DisplayName = name, }; AuthorizationService service = new AuthorizationService(userRepo, userMapper); var resp = await service.RegisterAsync(req); resp.ShouldNotBeNull(); }
public ActionResult RegisterUser( [FromServices] ICommandHandler <CreateUserCommand> handler, [FromBody] RegisterUserRequest request) { var command = new CreateUserCommand { FirstName = request.FirstName, LastName = request.LastName, UserName = request.UserName }; handler.Handle(command); return(new OkResult()); }
public bool Register(RegisterUserRequest user) { try { HttpClient client = new HttpClient(); client.BaseAddress = new Uri(BASE_URL); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = client.PostAsync("users/register", new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json")).Result; return(response.IsSuccessStatusCode); } catch { return(false); } }
public void RegisterUser_UserNameIsAvailable_VerifyRepository() { var mockBlogUserRepo = new MockIBlogUserRepository(); var interactor = new RegisterUserInteractor(mockBlogUserRepo); mockBlogUserRepo.StubList(new List <BlogUser>()); var param_request = new RegisterUserRequest { UserName = "******" }; interactor.RegisterUser(param_request); mockBlogUserRepo.VerifyList(); mockBlogUserRepo.VerifyAddCalled(1); }
/// <summary> /// Creates a new instance of the <see cref="UserDataModel" /> class. /// </summary> /// <param name="request">The request.</param> /// <returns> /// The user data model. /// </returns> public UserDataModel NewUserDataModel(RegisterUserRequest request) { var encryptionModel = encryptionHelper.EncryptPassword(request.Password); return(new UserDataModel { DateOfBirth = request.DateOfBirth, EmailAddress = request.EmailAddress, FirstName = request.FirstName, LastName = request.LastName, Salt = encryptionModel.Salt, Hash = encryptionModel.Hash, Iterations = encryptionModel.Iterations }); }
public async Task <IActionResult> Register([FromBody] RegisterUserRequest userRequest) { var authResponse = await _account.RegisterAsync(userRequest); if (!authResponse.Success) { return(Ok(_mapper.Map <ConfirmMapResponse>(authResponse))); } //var callbackUrl = Url.Action("ConfirmEmail", "Manage", new { UserId = authResponse.UserId, Code = authResponse.Code }, HttpContext.Request.Scheme); //await _emailSender.SendEmailAsync(authResponse.Email, "ProjMAN - Confirm Your Email", "Please Confirm Your E-Mail by clicking this link: <a href=\"" + callbackUrl + "\">Click here </a>"); return(Ok(_mapper.Map <ConfirmMapResponse>(authResponse))); }
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserRequest registerUserRequest) { if (!ModelState.IsValid) { return(BadRequest()); } var response = await userProvider.RegisterUserAsync(registerUserRequest); if (response.Errors != null && response.Errors.Any()) { return(BadRequest(response)); } return(Created(registerUserRequest.Username, response)); }
/// <summary> /// 注册账户 /// </summary> /// <param name="account">账户</param> /// <param name="password">密码</param> /// <param name="inviteAccountId">邀请者账户id</param> /// <param name="appleId">应用id</param> /// <param name="referer">来源地址</param> /// <returns></returns> public static async Task <object> RegisterUser(string account, string password, string inviteAccountId = "", string appleId = "", string referer = "") { var client = GrpcDispatcher.Instance <Grpc.Service.Register.RegisterClient>("https://localhost:5001"); RegisterUserRequest request = new RegisterUserRequest() { Account = account, Password = password }; return(await client.RegisterAsync(request)); return(null); }
public async Task <bool> RegisterUserAsync(RegisterUserRequest registerUser) { var user = _mapper.Map <User>(registerUser); user.UserName = user.Name; var result = await _userManager.CreateAsync(user, registerUser.Password); if (result.Succeeded) { await _signInManager.SignInAsync(user, false); return(true); } return(false); }
public async Task Should_ReturnBadRequest_When_PassingParametersAreEmpty(string username, string password) { var cancellationToken = new CancellationToken(); var databaseContext = Create.MockedDbContextFor <DatabaseContext>(); var userPasswordUtility = Substitute.For <IUserPasswordUtility>(); var saltGeneratorUtility = Substitute.For <ISaltGeneratorUtility>(); saltGeneratorUtility.Generate().Returns(Encoding.ASCII.GetBytes("UserPasswordTest")); userPasswordUtility.HashPassword(password, Encoding.ASCII.GetBytes("UserPasswordTest")).Returns("HashedPassword"); databaseContext.Set <SystemUser>().Add(new SystemUser() { Id = 1, Password = "******", Username = "******", Salt = Encoding.ASCII.GetBytes("password1") }); databaseContext.Set <SystemUser>().Add(new SystemUser() { Id = 2, Password = "******", Username = "******", Salt = Encoding.ASCII.GetBytes("password2") }); databaseContext.Set <SystemUser>().Add(new SystemUser() { Id = 3, Password = "******", Username = "******", Salt = Encoding.ASCII.GetBytes("password3") }); databaseContext.SaveChanges(); var entity = new RegisterUserRequest(username, password); var handler = new RegisterUserHandler(databaseContext, userPasswordUtility, saltGeneratorUtility); var result = await handler.Handle(entity, cancellationToken); Assert.Multiple(() => { Assert.IsFalse(result.Success); Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest); }); }
/// <inheritdoc/> public async Task <AuthResponse> RegisterAsync(RegisterUserRequest request) { var existingWithUsername = await _userRepository.GetUserByUsernameAsync(request.Username); var existingWithEmail = await _userRepository.GetUserByEmailAsync(request.Email); if (existingWithUsername != null) { var errors = new List <string> { "User with this username already exists!" }; if (existingWithEmail != null) { errors.Add("User with this email already exists!"); } return(new AuthResponse { Success = false, Errors = errors }); } var userToCreate = _mapper.Map <User>(request); userToCreate.HashedPassword = _passwordHasher.HashPassword(_mapper.Map <User>(request), request.Password); UserRepository.PutFieldsToUppercase(userToCreate); try { userToCreate.Id = await _userRepository.CreateAsync(userToCreate); } catch (MySqlException ex) { Console.WriteLine(ex); return(new AuthResponse { Success = false, Errors = new List <string> { "Database error occured!" } }); } return(await GenerateAuthResultForUserAsync(userToCreate)); }
public async Task <IActionResult> Register([FromBody] RegisterUserRequest request) { Logger.Trace($"Executing '{nameof(Register)}'."); try { var result = await _mediator.Send(request).ConfigureAwait(false); return(result.GetResult()); } catch (Exception ex) { Logger.Error(ex, $"Unexpected error thrown while executing '{nameof(RegisterUserHandler)}'."); throw; } }
/// <summary> /// Register a user by giving username, password, and displayName /// </summary> /// <param name="emailAddress">Email address of the user</param> /// <param name="password">Password to login</param> /// <param name="displayName">Any string can be used as display name, make it more flexible than Usernam</param> /// <param name="callback">Returns a Result that contains UserData via callback</param> public void Register(string emailAddress, string password, string displayName, string country, DateTime dateOfBirth, ResultCallback <RegisterUserResponse> callback) { Report.GetFunctionLog(this.GetType().Name); var registerUserRequest = new RegisterUserRequest { authType = AuthenticationType.EMAILPASSWD, emailAddress = emailAddress, password = password, displayName = displayName, country = country, dateOfBirth = dateOfBirth.ToString("yyyy-MM-dd") }; this.coroutineRunner.Run(this.userAccount.Register(registerUserRequest, callback)); }
public async Task <bool> Handle(RegisterUserRequest message, IOutputPort <RegisterUserResponce> outputPort) { var responce = await _userReposytory.Create(message.FirstName, message.SecondName, message.Email, message.UserName, message.Password); outputPort.Handle(responce.Success ? new RegisterUserResponce(responce.Id, true) : new RegisterUserResponce(responce.Errors.Select(e => e.Description))); if (responce.Success) { var user = await _userReposytory.GetByIdentityId(responce.Id); await _email.SendMessage(message.Email, user.Id); } return(responce.Success); }
public ActionResult Register(RegisterModel model) { var handler = new RegisterUserHandle(new UserRepository()); var request = new RegisterUserRequest() { ConfirmPassword = model.ConfirmPassword, LoginEmail = model.UserName, Password = model.Password }; var response = handler.Handle(request); if (response.Status == ResponseCodes.Success) { FormsAuthentication.SetAuthCookie(model.UserName, true); return RedirectToAction("ChooseProfile", "Profile"); } var errorMessage = response.Status.GetMessage(); ModelState.AddModelError("", errorMessage); return View(model); }
/// <summary> /// Register user. /// </summary> /// <param name="request"> /// The request. /// </param> /// <returns> /// Register user response. /// </returns> public RegisterUserResponse RegisterUser(RegisterUserRequest request) { return null; }