public UserCreateResponse CreateUser(UserCreateRequest createRequest) { var response = new UserCreateResponse(); var validationErrors = _validation.createRequestValidation.Validate(createRequest); var DBErrors = new List <DatabaseErrors>(); if (validationErrors.Count != 0 && validationErrors != null) { response.ValidationErrors = validationErrors; } else { try { var user = AddUserToDB(createRequest); response.User = user; } catch (NullReferenceException) { DBErrors.Add(DatabaseErrors.DB_CONNECTION_FAILED); } response.DBErrors = DBErrors; } return(response); }
public UserResponse Execute(UserCreateRequest createRequestData) { string createdUserId = null; try { createdUserId = _authGateway.CreateUser(createRequestData); } catch (AmazonCognitoIdentityProviderException e) { LoggingHandler.LogError(e.Message); LoggingHandler.LogError(e.StackTrace); return(null); } var userDomain = SaveNewUser(createRequestData, createdUserId); var userCreateResponse = new UserResponse { Id = userDomain.Id, CreatedAt = userDomain.CreatedAt, Email = createRequestData.Email, Name = createRequestData.Name, SubId = createdUserId, Status = userDomain.Status }; return(userCreateResponse); }
public async Task Can_update_user_metadata() { // Add a new user with metadata var newUserRequest = new UserCreateRequest { Connection = connection.Name, Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa", EmailVerified = true, Password = "******", AppMetadata = new { a = 1, b = 2 }, UserMetadata = new { c = 3, d = 4 } }; var newUserResponse = await apiClient.Users.CreateAsync(newUserRequest); // Do some updating var updateUserRequest = new UserUpdateRequest(); updateUserRequest.AppMetadata = new ExpandoObject(); updateUserRequest.AppMetadata.IsSubscribedTo = "1"; var updateUserResponse = await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest); // Get the user to ensure the metadata was set var user = await apiClient.Users.GetAsync(newUserResponse.UserId); // Delete the user await apiClient.Users.DeleteAsync(user.UserId); }
public async Task InitializeAsync() { string token = await GenerateManagementApiToken(); _managementApiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")); // We will need a connection to add the users to... _connection = await _managementApiClient.Connections.CreateAsync(new ConnectionCreateRequest { Name = Guid.NewGuid().ToString("N"), Strategy = "auth0", EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") } }); // Add a new user var newUserRequest = new UserCreateRequest { Connection = _connection.Name, Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa", EmailVerified = true, Password = Password }; _newUser = await _managementApiClient.Users.CreateAsync(newUserRequest); _authenticationApiClient = new TestAuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL")); }
public async Task <IActionResult> CreateUser([FromBody] UserCreateRequest userRequest) { if (string.IsNullOrEmpty(userRequest.Email) || string.IsNullOrEmpty(userRequest.DisplayName) || string.IsNullOrEmpty(userRequest.Password)) { return(BadRequest()); } GoNorthUser user = new GoNorthUser { UserName = userRequest.Email, Email = userRequest.Email, DisplayName = userRequest.DisplayName }; IdentityResult result = await _userCreator.CreateUser(Url, Request.Scheme, userRequest.DisplayName, userRequest.Email, userRequest.Password, string.Empty); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); await _timelineService.AddTimelineEntry(null, TimelineEvent.NewUser, user.Email); return(Ok(user.Email)); } else { return(ReturnErrorResultFromIdentityResult(result)); } }
public async Task <HttpResponseMessage> Create(UserCreateRequest userCreateRequest) { int newId; if (userCreateRequest == null) { ModelState.AddModelError(" ", "missing body data"); } if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } try { newId = await userService.Create(userCreateRequest); } catch (DuplicateEmailException) { return(Request.CreateResponse(HttpStatusCode.BadRequest, new ErrorResponse("Email already in use"))); } return(Request.CreateResponse(HttpStatusCode.Created, new ItemResponse <int> { Item = newId })); }
public async Task LoadTestAddUsers() { string token = await GenerateManagementApiToken(); var apiClient = new ManagementApiClient(token, new Uri(GetVariable("AUTH0_MANAGEMENT_API_URL"))); var connection = await apiClient.Connections.CreateAsync(new ConnectionCreateRequest { Name = Guid.NewGuid().ToString("N"), Strategy = "auth0", EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") } }); // Add a new user for (int i = 1; i <= 200; i++) { TestContext.Out.WriteLine($"Adding user {i}"); var newUserRequest = new UserCreateRequest { Connection = connection.Name, Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa", EmailVerified = true, Password = "******" }; await apiClient.Users.CreateAsync(newUserRequest); } await apiClient.Connections.DeleteAsync(connection.Id); }
public ActionResult Create(UserCreateRequest model) { if (ModelState.IsValid == false) { return(View(model)); } if (_userManageService.ExistsUser(model.UserName) == false) { _userManageService.Create(new User { UserName = model.UserName, UserPwd = model.Password.ToMd5(), Nick = model.Nick, CreateTime = DateTime.Now, IsEnable = model.IsEnable }); return(RedirectToAction("Index")); } ModelState.AddModelError("_error", "登录账号已存在"); return(View(model)); }
public async Task <IResultResponse> Create(UserCreateRequest request) { IResultResponse response = new ResultResponse(); User user = _mapper.Map <User>(request); UserValidator validator = new UserValidator(); var result = await validator.ValidateAsync(user); if (result.IsValid) { User userExist = await _unitOfWork.UserRepository.GetByDocument(user.Document.Value); if (userExist == null) { await _unitOfWork.UserRepository.Create(user); _logger.LogInformation(LoggingEvent.Create, "Usuário criado com sucesso"); } else { response.AddMessage($"Usuário com o Cpf {request.Document} já está cadastrado"); _logger.LogInformation(LoggingEvent.Create, $"Usuário com o Cpf {request.Document} já está cadastrado"); } } else { response.AddMessage(result.Errors); _logger.LogInformation(LoggingEvent.Create, $"Encontrado algum erro de validação"); } return(response); }
public async Task InitializeAsync() { string token = await GenerateManagementApiToken(); _apiClient = new TestManagementApiClient(token, GetVariable("AUTH0_MANAGEMENT_API_URL")); _authenticationApiClient = new TestAuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL")); // We will need a connection to add the users to... _connection = await _apiClient.Connections.CreateAsync(new ConnectionCreateRequest { Name = "Temp-Int-Test-" + MakeRandomName(), Strategy = "auth0", EnabledClients = new[] { GetVariable("AUTH0_CLIENT_ID"), GetVariable("AUTH0_MANAGEMENT_API_CLIENT_ID") } }); // Add a new user var newUserRequest = new UserCreateRequest { Connection = _connection.Name, Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa", EmailVerified = true, Password = Password }; _user = await _apiClient.Users.CreateAsync(newUserRequest); // Now try and sign in with a wrong password until we get "too many attempts" bool userBlocked = false; int attempts = 0; do { try { attempts++; await _authenticationApiClient.GetTokenAsync(new ResourceOwnerTokenRequest { ClientId = GetVariable("AUTH0_CLIENT_ID"), ClientSecret = GetVariable("AUTH0_CLIENT_SECRET"), Realm = _connection.Name, Scope = "openid", Username = _user.Email, Password = "******" }); } catch (RateLimitApiException) { await Task.Delay(1000); } catch (ErrorApiException ex) { if (ex.ApiError.Error == "too_many_attempts") { userBlocked = true; } } } while (!userBlocked && attempts < 20); // Add failsafe to stop if we go over 20 attempts. User should be blocked by then, but just to make sure... }
public async Task Test_users_crud_sequence() { // Get all the users var usersBefore = await apiClient.Users.GetAllAsync(); // Add a new user var newUserRequest = new UserCreateRequest { Connection = connection.Name, Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa", EmailVerified = true, Password = "******" }; var newUserResponse = await apiClient.Users.CreateAsync(newUserRequest); newUserResponse.Should().NotBeNull(); newUserResponse.Email.Should().Be(newUserRequest.Email); // Get all the users again. Verify we now have one more var usersAfter = await apiClient.Users.GetAllAsync(); usersAfter.Count.Should().Be(usersBefore.Count + 1); // Update the user var updateUserRequest = new UserUpdateRequest { Email = $"{Guid.NewGuid():N}@nonexistingdomain.aaa", VerifyEmail = false }; var updateUserResponse = await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest); updateUserResponse.Should().NotBeNull(); updateUserResponse.Email.Should().Be(updateUserRequest.Email); // Ensure firstname, lastname etc are ignored and not sent to Auth0. If not, the following will throw an exception updateUserRequest = new UserUpdateRequest { EmailVerified = true, // We need to pass in at least one property, so we set this as the other properties below will not be serialized FirstName = "firstname", LastName = "lastname", NickName = "nickname", FullName = "fullname", Picture = "picture url.." }; await apiClient.Users.UpdateAsync(newUserResponse.UserId, updateUserRequest); // Get a single user var user = await apiClient.Users.GetAsync(newUserResponse.UserId); user.Should().NotBeNull(); user.Email.Should().Be(updateUserResponse.Email); // Delete the user and ensure we get an exception when trying to fetch them again await apiClient.Users.DeleteAsync(user.UserId); Func <Task> getFunc = async() => await apiClient.Users.GetAsync(user.UserId); getFunc.ShouldThrow <ApiException>().And.ApiError.ErrorCode.Should().Be("inexistent_user"); }
public ActionResult Create() { var viewModel = new UserCreateRequest { IsEnable = true }; return(View(viewModel)); }
public UserCreateResponse Create([FromBody] UserCreateRequest request) { var response = new UserCreateResponse(); response.Id = _facade.Create(request.User); return(response); }
public async Task <Guid> Create(UserCreateRequest request) { var user = UserAggregate.CreateFromRequest(request); await _repo.Add(user); return(user.Id); }
public IActionResult Register(RegisterUserViewModel model) { var username = model.UserName; var request = new UserCreateRequest(username); var response = bus.Handle(request); return(Redirect("Index")); }
public OperationResult <int> Post([FromBody] UserCreateRequest dto) { return(_userService.Create(new UserCreateDto { BirthDate = dto.BirthDate, FirstName = dto.FirstName, LastName = dto.LastName })); }
public bool Create(UserCreateRequest entity) { string gmail = entity.Gmail; string gmailToken = entity.GmailToken; string facebook = entity.Facebook; string facebookToken = entity.FacebookToken; string name = entity.Name; string img = entity.Img; string address = entity.Address; string phone = entity.Phone; DateTime dob = entity.BirthDate; if (gmail == null && facebook == null) { return(false); } User newEntity = new User(); newEntity.Name = name; newEntity.Address = address; newEntity.BirthDate = dob; newEntity.CreatedDate = DateTime.Now; newEntity.Img = img; newEntity.Phone = phone; newEntity.Gmail = gmail; newEntity.GmailToken = gmailToken; newEntity.Facebook = facebook; newEntity.FacebookToken = facebookToken; //facebook if (util.ValidRangeLengthInput(facebook, 1, 100) && util.ValidRangeLengthInput(facebookToken, 1, 500)) { if (!_userRepo.ExistedFacebook(facebook)) { User existed = _userRepo.GetAll().FirstOrDefault(e => e.Facebook.Equals(facebook) || e.FacebookToken.Equals(facebookToken)); if (existed == null) { return(_userRepo.Create(newEntity)); } } } //gmail if (util.ValidRangeLengthInput(gmail, 1, 100) && util.ValidRangeLengthInput(gmailToken, 1, 500)) { if (!_userRepo.ExistedGmail(gmail)) { User existed = _userRepo.GetAll().FirstOrDefault(e => e.Gmail.Equals(gmail) || e.GmailToken.Equals(gmailToken)); if (existed == null) { return(_userRepo.Create(newEntity)); } } } return(false); }
public async Task <IWrappedResponse> Create(UserCreateRequest request) { var cmd = ServiceCommand <User, Rules.User.Create.MainRule> .Create(_serviceProvider) .When(new Rules.User.Create.MainRule(request)) .Then(CreateAction); return(await cmd.Execute()); }
public IActionResult CreateUser([FromBody] UserCreateRequest request) { //if (!ModelState.IsValid) //{ // return BadRequest(ModelState); //} return(Created("", request)); }
public async Task <UserResponse> CreateAsync(UserCreateRequest req) { return(await Task.FromResult(new UserResponse { Id = req.Id, Name = req.Name, Code = req.Code, })); }
public async Task <ActionResult <UserGetViewModel> > PostCurrent([FromBody] UserCreateRequest request) { var model = _mapper.Map <UserCreateModel>(request); model.Id = User.UserId().Value; var user = await _userService.CreateUserAsync(model); return(Ok(_mapper.Map <UserGetViewModel>(user))); }
public async Task <IActionResult> CreateUser([FromBody] UserCreateRequest userCreateRequestDto) { var user = await _userService.Create(userCreateRequestDto).ConfigureAwait(false); return(Ok(new UserCreateResponse { UserId = user.Id, Username = user.Username })); }
public Task <UserResponse> CreateAsync(UserCreateRequest request) { return(base.ExecuteWithExceptionHandledOperation(async() => { var user = Mapper.Map <User>(request); _userRepository.Add(user); await _userRepository.SaveChangeAsync(); return Mapper.Map <UserResponse>(user); })); }
public async override Task <UserResponse> Register(UserCreateRequest request, ServerCallContext context) { var isRegistred = await _userService.Register(request.Username, request.Password, request.FirstName, request.LastName); return(new UserResponse { Status = isRegistred ? StatusCode.Ok : StatusCode.Error }); }
public async Task <User> Create(UserCreateRequest dto) { var user = _userFactory.Create(dto.Username, dto.Name, dto.Password, dto.Email); await _context.AddAsync(user).ConfigureAwait(false); await _context.SaveChangesAsync().ConfigureAwait(false); return(user); }
public ActionResult <User> PostUser(UserCreateRequest entity) { bool success = _ser.Create(entity); if (success) { return(Ok(entity)); } return(Problem("Create failed!")); }
public ActionResult <User> PostAuthentication(UserCreateRequest entity) { var user = _ser.Authentication(entity); if (user == null) { return(Problem("Server is maintain. Please try later")); } return(Ok(user)); }
public void CreateUser(UserCreateRequest user) { var result = ValidateUser(user); if (result) { var newUser = new Users(user.Name, user.Email, user.Password, user.Role); _repository.CreateUser(newUser); } }
public ActionResult Create() { BindSelectListDataSource(); var viewModel = new UserCreateRequest { IsEnable = true }; return(View(viewModel)); }
public UserCreateResponse Post([FromBody] UserCreateRequest Model) { // TODO: insert the user in the db and return the UserId int userId = this.GetFakeUserId(); return(new UserCreateResponse { UserId = userId }); }