public async Task Handle(AddSampleUsers busCommand) { // Create some fake user data var users = Enumerable.Range(0, busCommand.NumberOfUsers).Select(idx => { var user = new CreateUser { UserId = Guid.NewGuid(), FirstName = Name.GetFirstName(), LastName = Name.GetLastName(), Password = PasswordPattern.Bothify() }; user.EmailAddress = string.Format("{0}[email protected]", Internet.GetUserName(user.FirstName, user.LastName)); return(user); }).ToArray(); // Get statement for recording sample users PreparedStatement prepared = await _statementCache.NoContext.GetOrAddAsync("INSERT INTO sample_data_users (userid) VALUES (?)"); // Add the user and record their Id in C* (not a big deal if we fail halfway through since this is sample data) foreach (CreateUser user in users) { await _userManagement.CreateUser(user).ConfigureAwait(false); BoundStatement bound = prepared.Bind(user.UserId); await _session.ExecuteAsync(bound).ConfigureAwait(false); } }
public IActionResult CreateUser([FromBody] CreateUserDto createUserDto) { //Validate Model if (!ModelState.IsValid) { Response.StatusCode = StatusCodes.Status412PreconditionFailed; return(Json(ModelState)); } //Check if user allready exits var allreadyExists = userRepositoryService.LoginOrEmailIsAllreadyInUser(createUserDto.UserName, createUserDto.Email); if (allreadyExists) { Response.StatusCode = StatusCodes.Status409Conflict; return(Json("User name or email is allready in use.")); } //Prepare user creation model var userCreationResult = userManagementService.CreateUser(createUserDto); if (userCreationResult.User == null) { Response.StatusCode = StatusCodes.Status400BadRequest; return(Json(userCreationResult.Errors)); } //add user to db userRepositoryService.Insert(userCreationResult.User); unitOfWork.Save(); return(StatusCode(201)); }
private Task PopulateData(IUserManagementService service) { Console.WriteLine("Quantity:"); var quantityString = Console.ReadLine(); if (!int.TryParse(quantityString, out int quantity)) { return(Task.CompletedTask); } var rand = new Random(); Parallel.ForEach( source: Enumerable.Range(0, quantity), parallelOptions: new ParallelOptions { MaxDegreeOfParallelism = 10 }, body: async index => { var user = await service.CreateUser("A", "1", 18); await service.ChangeUserFirstName(user.Id, "B"); await service.ChangeUserFirstName(user.Id, "User"); await service.ChangeUserLastName(user.Id, "2"); await service.ChangeUserLastName(user.Id, index.ToString()); await service.ChangeUserAge(user.Id, 20); await service.ChangeUserAge(user.Id, rand.Next(20, 50)); Console.WriteLine($"{index} user was populated."); } ); return(Task.CompletedTask); }
public async Task <JsonNetResult> RegisterUser(RegisterUserViewModel model) { if (ModelState.IsValid == false) { return(JsonFailure()); } // Generate a user Id and try to register the user account (map from view model first) Guid userId = Guid.NewGuid(); var createUser = new CreateUser { EmailAddress = model.EmailAddress, FirstName = model.FirstName, LastName = model.LastName, Password = model.Password, UserId = userId }; // TODO: Validation to try and minimize chance of duplicate users // if (await _userWriteModel.CreateUser(createUser) == false) // { // ModelState.AddModelError(string.Empty, "A user with that email address already exists."); // return JsonFailure(); //} await _userManagement.CreateUser(createUser); // Assume creation successful so sign the user in SignTheUserIn(userId); // Return success return(JsonSuccess(new UserRegisteredViewModel { UserId = userId })); }
public async Task <ActionResult <UserDto> > Register(RegisterDto registerData) { var user = await _userManagementService.CreateUser(registerData); if (user == null) { return(BadRequest("This username is already taken")); } return(Ok(user)); }
private async Task CreateCommand(IUserManagementService service) { Console.WriteLine("First Name:"); var firstName = Console.ReadLine(); Console.WriteLine("Last Name:"); var lastName = Console.ReadLine(); Console.WriteLine("Age:"); var age = int.Parse(Console.ReadLine()); var a = await service.CreateUser(firstName, lastName, age); Console.WriteLine($"Created {JsonConvert.SerializeObject(a)}"); }
public async Task <IActionResult> CreateUser([FromBody] User user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var added = await _userManagementService.CreateUser(user); if (added) { return(Ok("User created")); } else { return(Conflict("User already existing")); } }
public IHttpActionResult Register(RegisterBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = new UserDetail() { UserName = model.Email, Email = model.Email }; var result = userManagementService.CreateUser(user, model.Password); if (result.HasError) { return(GetErrorResult(result)); } return(Ok()); }
public HttpResponseMessage CreateUser(CreateUserRequest request) { HttpResponseMessage hrm; try { var operationResult = userManagement.CreateUser(request.Email, request.Password); if (operationResult.IsSuccess) { hrm = Request.CreateResponse(HttpStatusCode.OK, operationResult.Message); } else { hrm = Request.CreateErrorResponse(HttpStatusCode.BadRequest, operationResult.Message); } } catch (Exception e) { hrm = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e); } return(hrm); }
public async Task <ApiResponse> Register([FromBody] RegisterModel model) { if (!ModelState.IsValid) { throw new ApiException(ModelState.AllErrors()); } var idGenerator = new IdGenerator(IdGeneratorType.User); AuthUser user = new(model.Email, model.FirstName, model.LastName, new AppUserId(idGenerator.CreateId())); var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { throw new ApiException(result.Errors); } var addUser = new AddUserDto(user.AppUserId, user.FirstName, user.LastName, user.Email); try { await _userManagementService.CreateUser(addUser); return(new ApiResponse("Successfully registered", StatusCodes.Status201Created)); } catch (Exception ex) { await _userManager.DeleteAsync(user); throw new ApiException(ex); } }
public ClientRegistrationResponse Post([FromBody] ClientRegistrationRequest request) { try { _logger.Info("register new client: "); _logger.Info(JsonConvert.SerializeObject(request, Formatting.Indented)); var loginName = $"{request.FirstName[0].ToString().ToLowerInvariant()}.{request.LastName.ToLowerInvariant()}"; var clientId = _userService.CreateClient(new RegisteredClient { Country = request.Country, State = RegisteredClientState.Pending, CreationUser = loginName, CreationDate = DateTime.Now, }); var workContext = new WorkContext { UserId = Guid.Empty, LoginName = loginName }; var user = _userService.CreateUser(workContext, new User { RegisteredClientId = clientId, LoginName = loginName, FirstName = request.FirstName, LastName = request.LastName, Email = request.Email, EmailIsValidated = false, Password = request.EncryptedPassword, PasswordLastChangedDate = DateTime.Now, IsActive = true, }); var mailServerConfig = new MailServerConfiguration { Hostname = "smtp.gmail.com", Port = 587, Username = "******", Password = "******", From = "*****@*****.**", EnableSsl = true, IsActive = true }; var renderedMessage = _mailService.RenderMailContent("0000000000", "AppSolutions", "NewClientRegistrationUserMailAddressValidation", "EN", new { FirstName = request.FirstName, LastName = request.LastName, MailAddress = request.Email, VerificationLink = $"http://localhost:29328/User/EmailVerification/{clientId}/{user.UserId}" }); var message = new MailMessage { From = new MailAddress { Address = mailServerConfig.From }, To = new List <MailAddress> { new MailAddress { Address = request.Email } }, IsBodyHtml = renderedMessage.IsBodyHtml, Subject = renderedMessage.Subject, Body = renderedMessage.Body, }; _mailService.SendMail(mailServerConfig, message); return(ClientRegistrationResponse.Success(clientId, request.Email)); } catch (Exception e) { _logger.Error(e); return(ClientRegistrationResponse.Error(e)); } }
public async Task Register(CreateUserRequest request) { request.Password = _sha512Service.GetBase64Hash(request.Password); await _userManagementService.CreateUser(request);; }
public ResponseDTO <Session> SsoLogin(SsoUserRequestDTO request) { ResponseDTO <Session> response = new ResponseDTO <Session>(); // Before anything happens, validate that this request is coming from the known sso server if (!_signatureService.isValidSignature(request.GetStringToSign(), request.Signature)) { response.Data = null; response.Error = "My signature: " + _signatureService.Sign(request.GetStringToSign()) + " Compared to: " + request.Signature; _loggerService.LogError(LogConstants.FAIL_LOGIN, request.SsoUserId, "", response.Error, ""); return(response); } // Protect against replay attacks by checking the timestamp if (DateTimeOffset.Now.AddSeconds(5).ToUnixTimeMilliseconds() < request.Timestamp) { response.Data = null; response.Error = ErrorStrings.OLD_SSO_REQUEST; _loggerService.LogError(LogConstants.FAIL_LOGIN, request.SsoUserId, "", response.Error, ""); return(response); } // Convert request SsoId into Guid Guid ssoId = new Guid(request.SsoUserId); // Search for user in database ResponseDTO <UserAccountDTO> userAccountResponse = _userManagementService.GetUserBySsoId(ssoId); UserAccountDTO userDTO = userAccountResponse.Data; // If the user does not exist in the data store, register the user as a standard user if (userAccountResponse.Data == null) { // Verify the email is not null if (request.Email == null) { response.Data = null; response.Error = "User email may not be null."; _loggerService.LogError(LogConstants.FAIL_LOGIN, request.SsoUserId, "", response.Error, ""); return(response); } // Create an unassigned user account UserAccount user = new UserAccount() { SsoId = ssoId, Username = request.Email, IsActive = true, AcceptedTOS = false, RoleType = Roles.UNASSIGNED }; List <Claim> newClaims = _claimService.GetUserClaims(Roles.UNASSIGNED, request.Email).Data; // Add user to datastore ResponseDTO <bool> createUserResponse = _userManagementService.CreateUser(user, newClaims); // Check if user creation succeded if (!createUserResponse.Data) { response.Data = null; response.Error = createUserResponse.Error; _loggerService.LogError(LogConstants.FAIL_LOGIN, request.SsoUserId, "", response.Error, ""); return(response); } // User now exists in database, proceed with login as normal userDTO = new UserAccountDTO(user); } // Create session for user ResponseDTO <Session> sessionResponseDTO = _sessionService.CreateSession(userDTO.Id); _loggerService.LogAction(LogConstants.ACTION_LOGIN, userDTO.SsoId.ToString(), sessionResponseDTO.Data.SessionId.ToString()); return(sessionResponseDTO); }
public UserCreationResponse CreateUser(User user, bool sendEmail, string language) { var requestContext = OperationContext.Current.Extensions.Find <ConnectionContext>(); return(_userManagementService.CreateUser(user, sendEmail, language, requestContext.CustomerId)); }