public async Task <IActionResult> CreateAsync([FromBody] UserCreationDto userDto) { return(await userService.CreateAsync(userDto.Role, userDto.Login, userDto.FirstName, userDto.LastName, userDto.Password, userDto.PermitNumber)); }
public IActionResult CreateUser([FromBody] UserCreationDto user) { if (user == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(UnprocessableEntity(ModelState)); } // if (String.IsNullOrEmpty(user.Login) || user.Login.Any(c => !Char.IsLetterOrDigit(c))) if (user.Login.Any(c => !Char.IsLetterOrDigit(c))) { ModelState.AddModelError("login", "Некорректный логин"); return(UnprocessableEntity(ModelState)); } var userEntity = mapper.Map <UserEntity>(user); var createdUserEntity = userRepository.Insert(userEntity); return(CreatedAtRoute( nameof(GetUserById), new { userId = createdUserEntity.Id }, createdUserEntity.Id)); }
public ApplicationResult <UserDto> Create(UserCreationDto userDto) { var userEdit = UserEdit.Create(userDto.ExternalId, userDto.UserName, userDto.FullName, userDto.Email); var brokenRules = userEdit.GetBrokenValidationRules(); if (!brokenRules.IsValid) { return new ApplicationResult <UserDto> { Errors = brokenRules.Errors.ToList(), IsSuccessful = false, IsFailure = true } } ; userEdit = _userRepository.Create(userEdit); if (userDto.Keys.Any()) { foreach (var key in userDto.Keys) { var keyEdit = KeyEdit.Create(userEdit, key.Password); _userRepository.CreateKey(userEdit.Id, keyEdit); } } UnitOfWork.Commit(); return(new ApplicationResult <UserDto>() { Data = Mapper.Map <UserDto>(userEdit), IsSuccessful = true, IsFailure = false }); }
public int AddUser(UserCreationDto user) { var client = _context.Clients.Where(c => c.ClientId == user.ClientEntityId) .FirstOrDefault(); if (client == null) { return(-1); } UserEntity userEntity = mapperConfiguration.CreateMapper() .Map <UserEntity>(user); userEntity.ClientEntityId = client.ClientId; userEntity.ClientEntity = client; _context.Users.Add(userEntity); if (_context.SaveChanges() > 0) { return(userEntity.Id); } else { return(-1); } }
public async Task <IHttpActionResult> CreateUser(UserCreationDto dto) { if (UserNameExists(dto.UserName)) { return(BadRequest("已存在此登录名")); } //create user var user = new User { UserName = dto.UserName, DisplayName = dto.DisplayName, Class = dto.ClassNumber, Grade = dto.Grade, Roles = new HashSet <UserRole>() }; var result = await _userManager.CreateAsync(user, dto.Password); if (!result.Succeeded) { return(BadRequest(string.Join(" ", result.Errors))); } var userId = (await _userManager.FindByNameAsync(user.UserName)).Id; //add to role dto.Roles.ToList().ForEach(rs => { _userManager.AddToRole(userId, rs); }); return(StatusCode(HttpStatusCode.Accepted)); }
public async Task <AppSrvResult <long> > CreateAsync(UserCreationDto input) { if (await _userRepository.AnyAsync(x => x.Account == input.Account)) { return(Problem(HttpStatusCode.BadRequest, "账号已经存在")); } var user = Mapper.Map <SysUser>(input); user.Id = IdGenerater.GetNextId(); user.Account = user.Account.ToLower(); user.Salt = SecurityHelper.GenerateRandomCode(5); user.Password = HashHelper.GetHashedString(HashType.MD5, user.Password, user.Salt); var cacheKey = _cacheService.ConcatCacheKey(CachingConsts.UserValidateInfoKeyPrefix, user.Id); var bloomFilterCacheKey = _bloomFilterFactory.GetBloomFilter(nameof(BloomFilterCacheKey)); await bloomFilterCacheKey.AddAsync(cacheKey); var bloomFilterAccount = _bloomFilterFactory.GetBloomFilter(nameof(BloomFilterAccount)); await bloomFilterAccount.AddAsync(user.Account); await _userRepository.InsertAsync(user); return(user.Id); }
public void CreateUser(UserCreationDto dto) { var newUser = _userRepository.Create(new User { DateCreated = DateTime.Now, DateModified = DateTime.Now, FirstName = dto.FirstName, LastName = dto.LastName, Username = dto.Username, Password = dto.Password, RoleId = dto.RoleId, TeamId = dto.TeamId, DepartmentId = dto.DepartmentId }); _userRepository.Save(); if (dto.ContractStartDate == null || dto.ContractEndDate == null) { return; } _contractRepository.Create(new Contract { EmployeeId = newUser.Id, ContractNumber = new Random().Next(), DateCreated = DateTime.Now, StartTime = dto.ContractStartDate.Value, EndDateTime = dto.ContractEndDate.Value }); _contractRepository.Save(); }
public async Task <string> SignIn(UserCreationDto model) { IdentityResult userResult = await userManager.CreateAsync(new User { Email = model.Email, NormalizedEmail = model.Email.ToUpper(), UserName = model.Email, NormalizedUserName = model.Email.ToUpper() }, model.Password); if (!userResult.Succeeded) { throw new SignInException("Error while registring the user"); } User user = await userManager.FindByEmailAsync(model.Email); IdentityResult roleResult = await userManager.AddToRoleAsync(user, model.Role); if (!roleResult.Succeeded) { throw new SignInException("Error on assigning role to the user"); } return(await Login(new Credentials { Email = model.Email, Password = model.Password })); }
public async void CreateUser() { // Delete it if it already exists foreach (var existingUser in await PortalClient.GetAllAsync(new Filter <User> { FilterItems = new List <FilterItem <User> > { new Eq <User>(nameof(User.UserName), "test") } }).ConfigureAwait(false)) { await PortalClient.DeleteAsync(existingUser).ConfigureAwait(false); } var userCreationDto = new UserCreationDto { ViewPermission = new ViewPermission { Alerts = true, Dashboards = true, Devices = true, Reports = true, Websites = true, Settings = true }, Username = "******", FirstName = "first", LastName = "last", Email = "*****@*****.**", #pragma warning disable SCS0015 // Hardcoded password Password = "******", #pragma warning restore SCS0015 // Hardcoded password Password1 = "Abc123!!!", ForcePasswordChange = true, TwoFAEnabled = false, SmsEmail = "", SmsEmailFormat = "sms", Timezone = "", ViewPermissions = new List <bool> { true, true, true, true, true, true }, Status = "active", Note = "note", Roles = new List <Role> { new Role { Id = 1 } }, ApiTokens = new List <object>(), Phone = "+447761503941", ApiOnly = false }; var user = await PortalClient.CreateAsync(userCreationDto).ConfigureAwait(false); // Delete again await PortalClient.DeleteAsync(user).ConfigureAwait(false); }
public async Task <IActionResult> Register([FromBody] UserCreationDto user, [FromHeader(Name = "Accept")] string mediaType) { if (user == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(new UnprocessableEntityObjectResult(ModelState)); } var newUser = _mapper.Map <User>(user); var result = await _userManager.CreateAsync(newUser, user.Password); if (!result.Succeeded) { return(new UnprocessableEntityObjectResult(result)); } result = await _userManager.AddToRoleAsync(newUser, nameof(Roles.User)); if (!result.Succeeded) { return(new UnprocessableEntityObjectResult(result)); } if (!await _userService.Save()) { throw new Exception("Creating a user failed on save."); } var token = await _userManager.GenerateEmailConfirmationTokenAsync(newUser); var confirmationUrl = Url.Action("ConfirmEmail", "Users", new { token, email = newUser.Email }, protocol: HttpContext.Request.Scheme); //TODO Activate Mailing Service + Edit appsettings.json //var confirmAccountModel = new AccountEmailViewModel(confirmationUrl, user.UserName); //var body = await _razorViewRenderer.RenderViewToStringAsync("/Views/ConfirmAccountEmail.cshtml", confirmAccountModel); //await _emailService.SendAsync(user.Email, "Activate your account", body, MailType.Confirmation); var returnedUser = _mapper.Map <UserDto>(newUser); if (mediaType == "application/json+hateoas") { var links = CreateUserLinks(returnedUser.Id, null); var linkedResource = returnedUser.ShapeData(null) as IDictionary <string, object>; linkedResource.Add("links", links); return(CreatedAtRoute("GetUser", new { id = returnedUser.Id }, linkedResource)); } else { return(CreatedAtRoute("GetUser", new { id = returnedUser.Id }, returnedUser)); } }
public async Task <ActionResult <UserDto> > Add(UserCreationDto item) { var na = new User(ObjectId.Empty, ObjectId.Empty, item.Name, item.DateOfBirth, item.Gender, item.GoalWeight, item.Height, item.Email, item.PhoneNumber, item.Weight, new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), new List <ObjectId>(), item.ActivityLevel); await userCollection.InsertOneAsync(na); return(CreatedAtRoute(nameof(GetSingleUser), new { id = na.Id }, new UserDto(na.Id.ToString(), na.Name, na.DateOfBirth, na.Gender, na.GoalWeight, na.Height, na.Email, na.PhoneNumber, na.Weight, na.ActivityLevel))); }
public async Task <IActionResult> Upload(List <IFormFile> files, UserCreationDto userDto) { if (ModelState.IsValid) { if (_userRepository.DoesExist(x => x.Email == userDto.Email)) { return(BadRequest("Email already exist")); } var Userfiles = new List <Document>(); foreach (var file in files) { var ext = Path.GetExtension(file.FileName); if (!IsValidFile(ext)) { continue; } var path = Path.Combine(_env.WebRootPath, "uploads", file.FileName); using (var stream = new FileStream(path, FileMode.Create)) { await file.CopyToAsync(stream); } var url = string.Format("{0}://{1}/{2}", HttpContext.Request.Scheme, HttpContext.Request.Host, "Uploads"); Userfiles.Add(new Document { Name = file.FileName, Path = path, Url = $"{url}/{file.FileName}" }); } var user = _mapper.Map <User>(userDto); user.Id = Guid.NewGuid(); user.TransactionNumber = Guid.NewGuid().ToString().Replace("-", ""); user.Documents = Userfiles; _userRepository.Add(user); await _userRepository.Save(); await _emailSendingChannel.AddMessageAsync(new EmailData { Email = user.Email, Message = "Uploaded Documents", Subject = "Documents", Documents = _mapper.Map <List <DocumentDto> >(user.Documents) }); return(Ok(user.TransactionNumber)); } return(BadRequest()); }
/// <summary> /// /// </summary> /// <param name="createUser"></param> /// <returns></returns> public CreateUserResult CreateNewUser(UserCreationDto createUser, ClaimsPrincipal claims) { CreateUserResult result = new CreateUserResult() { CreationError = UserCreationError.NoError, IsCreatedSuccesfully = true }; // First check if user alredy exists in database var users = userRepo.GetUsers(new UserQueryParameters() { UserName = createUser.UserName }); if (users.Any(u => string.Compare(u.UserName, createUser.UserName, StringComparison.OrdinalIgnoreCase) == 0)) { result.IsCreatedSuccesfully = false; result.CreationError = UserCreationError.LoginAlreadyExists; return(result); } Users user = Mapper.Map <Users>(createUser); // Create appropriate user data according to flags if (createUser.IsTeacher) { Teachers teacher = Mapper.Map <Teachers>(createUser); teacherRepo.AddTeacher(teacher, claims); teacherRepo.Save(); user.TeacherId = teacher.TeacherId; result.CreatedUser = Mapper.Map <UserDto>(teacher); } if (createUser.IsStudent) { Students student = Mapper.Map <Students>(createUser); studentRepo.AddStudent(student, claims); studentRepo.Save(); user.StudentId = student.StudentId; result.CreatedUser = Mapper.Map <UserDto>(student); } if (createUser.IsParent) { Parents parent = Mapper.Map <Parents>(createUser); parentRepo.AddParent(parent, claims); parentRepo.Save(); user.ParentId = parent.ParentId; result.CreatedUser = Mapper.Map <UserDto>(parent); } userRepo.CreateUser(user, claims); userRepo.Save(); result.CreatedUser.UserId = user.UserId.ToString(); return(result); }
public async Task <IActionResult> SignIn(UserCreationDto model) { string token = await userService.SignIn(model); return(Ok(new TokenDto { Token = token })); }
public User Create(UserCreationDto userDto) { var user = this.iUserMapper.Convert(userDto); this.iUserRepository.Insert(user); var result = this.iUserRepository.GetAll().FirstOrDefault(x => x.Username == user.Username); return(result); }
/// <summary> /// The create user. /// </summary> /// <param name="userCreationDto"> /// The user creation dto. /// </param> /// <param name="userName"> /// The user name. /// </param> /// <returns> /// The <see cref="Task"/>. /// </returns> private async Task <ActionResult <UserDto> > CreateUser(UserCreationDto userCreationDto, string userName) { var user = await userManager.FindByNameAsync(userName).ConfigureAwait(false); userCreationDto.UserName = userName; if (user == null) { var newUser = Mapper.Map <ApplicationUser>(userCreationDto); newUser.UserName = userName; var claims = Mapper.Map <Claim[]>(userCreationDto); using (var transaction = await context.Database.BeginTransactionAsync().ConfigureAwait(false)) { var result = await userManager.CreateAsync(newUser, userCreationDto.Password).ConfigureAwait(false); if (result.Succeeded) { result = await userManager.AddClaimsAsync(newUser, claims).ConfigureAwait(false); if (result.Succeeded) { transaction.Commit(); var userDto = Mapper.Map <UserDto>(newUser); Mapper.Map(claims, userDto); return(Created($"{Request.Scheme}://{Request.Host}{Request.PathBase}/users/{newUser.UserName}", userDto)); } transaction.Rollback(); } } } else { var lastCharIdx = -1; for (lastCharIdx = userName.Length - 1; lastCharIdx >= 0; lastCharIdx--) { if (char.IsDigit(userName[lastCharIdx])) { continue; } break; } if (lastCharIdx == userName.Length - 1) { return(await CreateUser(userCreationDto, $"{userName}1").ConfigureAwait(false)); } return(await CreateUser(userCreationDto, $"{userName.Substring(0, lastCharIdx + 1)}{int.Parse(userName.Substring(lastCharIdx + 1)) + 1}").ConfigureAwait(false)); } return(StatusCode((int)HttpStatusCode.InternalServerError, "There was an error encountered creating the user")); }
public async Task <IActionResult> Post(UserCreationDto userCreationDto) { var result = await _usersService.CreateUserAsync(userCreationDto); var json = new { message = string.Join(", ", result.Errors.Select(x => x.Description)) }; return(Ok(json)); }
public async Task <UserDto> CreateUser(UserCreationDto userDto) { var user = _mapper.Map <User>(userDto); var addedUser = await _context.Users.AddAsync(user); await _context.SaveChangesAsync(); var dto = _mapper.Map <UserDto>(addedUser.Entity); return(dto); }
public async Task <ActionResult <UserDto> > Post([FromBody] UserCreationDto userCreationDto) { if (userCreationDto == null) { return(BadRequest()); } var userName = $"{userCreationDto.FirstName[0]}{userCreationDto.LastName}"; return(await CreateUser(userCreationDto, userName).ConfigureAwait(false)); }
public UserCreationDto Convert(UserRegisterRequest source) { var result = new UserCreationDto { Email = source.Email, Username = source.Username, Password = source.Password }; return(result); }
public async Task <UserDto> RegisterUser(UserCreationDto userDto) { var usernameValid = await _userRepository.IfValid(userDto.Username); if (!usernameValid) { _logger.LogInformation("Error while registering a user"); throw new InvalidUsernameException(); } var result = await _userRepository.CreateUser(userDto); return(result); }
public User Convert(UserCreationDto source) { var result = new User { Email = source.Email, Username = source.Username, Password = source.Password, CreatedAd = DateTime.Now, LastModifiedAt = DateTime.Now }; return(result); }
public async Task <IActionResult> DeleteUser(UserCreationDto dto) { try { await _userRepository.Delete(dto); return(Ok()); } catch (Exception e) { return(NotFound("This User cannot be delete")); } }
public async Task <ActionResult <UserDto> > CreateUser([FromBody] UserCreationDto userToAdd) { var client = await MicrosoftGraphClient.GetGraphServiceClient(); try { await _azureAdRepository.GetUser(client, userToAdd.Id.ToString()); } catch (ServiceException e) { if (e.StatusCode == HttpStatusCode.NotFound) { ModelState.AddModelError("azureAdUserNotFound", $"User with id: {userToAdd.Id} was not found on Azure AD"); } } var userExists = await _userRepository.UserExists(userToAdd.Id); if (userExists) { return(Conflict("User already exists")); } if (userToAdd.SmartLockUsers.Count > 0) { foreach (var smartLockUser in userToAdd.SmartLockUsers) { var smartLockExist = await _smartLockRepository.SmartLockExists(smartLockUser.SmartLockId); if (!smartLockExist) { ModelState.AddModelError("smartLockNotExist", $"Smart lock with id: {smartLockUser.SmartLockId} doesn't exist"); } } } if (!ModelState.IsValid) { return(ValidationProblem(ModelState)); } var userEntity = _mapper.Map <User>(userToAdd); _userRepository.AddUser(userEntity); await _userRepository.Save(); var userDto = _mapper.Map <UserDto>(userEntity); return(CreatedAtAction("GetUser", new { userId = userDto.Id }, userDto)); }
public async Task <IActionResult> Post([FromBody] UserCreationDto dto) { var cmd = new CreateUserCommand { UserName = dto.UserName, Password = dto.Password }; var result = await _sagaBus.InvokeAsync <CreateUserCommand, UserCreationResult>(cmd); if (result.Succeed) { return(Created(Url.Action(nameof(GetById), new { id = result.UserId }), null)); } // currently, the only reason for failure is that a user of the same username exists. return(StatusCode(412, result.Message)); }
public async Task CreateUserAsync(UserCreationDto userDto) { var user = Mapper.Map <User>(userDto); await _usersRepository.AddAsync(user); await _unitOfWorkEf.CommitAsync(); user.Titles.ToList().ForEach(x => x.UserId = user.Id); await _titlesRepository.AddRangeAsync(user.Titles); await _unitOfWorkMongo.CommitAsync(); }
public UserDE Create(UserCreationDto user) { // default password when admin creates a user if (string.IsNullOrWhiteSpace(user.Password)) { user.Password = "******"; } // validation if (_context.tbl_user.Any(x => x.UserName == user.UserName)) { throw new AppException("Username \"" + user.UserName + "\" is already taken"); } if (user.Email != null) { if (_context.tbl_user.Any(x => x.Email == user.Email)) { throw new AppException("Email \"" + user.Email + "\" is already taken"); } } if (user.PhoneNo == null) { if (_context.tbl_user.Any(x => x.PhoneNo == user.PhoneNo)) { throw new AppException("Phone number \"" + user.PhoneNo + "\" is already taken"); } } byte[] passwordHash, passwordSalt; CreatePasswordHash(user.Password, out passwordHash, out passwordSalt); UserDE newUser = new UserDE { UserId = new Guid(), UserName = user.UserName, PasswordHash = passwordHash, PasswordSalt = passwordSalt, Email = user.Email, PhoneNo = user.PhoneNo, Role = user.Role }; _context.tbl_user.Add(newUser); _context.SaveChanges(); return(newUser); }
public async Task <IActionResult> CreateUser(UserCreationDto dto) { var newUser = new UserCreationDto { UserName = dto.UserName, Password = dto.Password, IsBlocked = dto.IsBlocked, Admin = dto.Admin, PersonId = dto.PersonId }; await _userRepository.Create(newUser); return(Ok(dto)); }
public async Task <IActionResult> CreateUser([FromBody] UserCreationDto user) { var userEntity = _mapper.Map <User>(user); AuthExtensions.CreatePasswordHash(user.password, out byte[] passwordHash, out byte[] passwordSalt); userEntity.passwordHash = passwordHash; userEntity.passwordSalt = passwordSalt; _repository.User.CreateUser(userEntity); await _repository.SaveAsync(); var createdUser = _mapper.Map <UserDto>(userEntity); return(CreatedAtRoute("UserById", new { id = createdUser.userId }, createdUser)); }
public async Task <AppSrvResult <long> > CreateAsync(UserCreationDto input) { if (await _userRepository.AnyAsync(x => x.Account == input.Account)) { return(Problem(HttpStatusCode.BadRequest, "账号已经存在")); } var user = Mapper.Map <SysUser>(input); user.Id = IdGenerater.GetNextId(); user.Salt = SecurityHelper.GenerateRandomCode(5); user.Password = HashHelper.GetHashedString(HashType.MD5, user.Password, user.Salt); await _userRepository.InsertAsync(user); return(user.Id); }