public async Task <IActionResult> Post([FromBody] NewUserDTO dto) { var newUser = new ApplicationUser { UserName = dto.UserName, Email = dto.Email, PhoneNumber = dto.Phone.ToString() }; bool RoleExists = await _roleManager.RoleExistsAsync(dto.RoleName); Console.WriteLine(dto.RoleName); IdentityResult roleResult; if (!RoleExists) { roleResult = await _roleManager.CreateAsync(new IdentityRole(dto.RoleName)); } IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password); if (result.Succeeded) { ApplicationUser current = await _userManager.FindByNameAsync(dto.UserName); result = await _userManager.AddToRoleAsync(current, dto.RoleName); } return((result.Succeeded) ? Ok() : (IActionResult)Unauthorized()); }
public async Task <ActionResult> RegisterUser(NewUserDTO input) { // Check that api key is correct to the one supplied in environment files if (!ValidAPIKey(input.APIKey)) { return(StatusCode(StatusCodes.Status403Forbidden, new GenericReturnMessageDTO { Status = 403, Message = ErrorMessages.APIKeyInCorrect })); } // Check that the username is not already in use in another keytab if (await _repo.UserExists(input.NewUserUsername)) { return(BadRequest(new GenericReturnMessageDTO { Status = 400, Message = ErrorMessages.UserAlreadyExists })); } // Create users principal and keytab $"create-user.sh {Regex.Escape(input.NewUserUsername)}".Bash(); var newUserKeyTabFilePath = $"/keytabs/{input.NewUserUsername}.user.keytab"; var user = await _repo.CreateNewUser(_mapper.Map <User>(input), input.NewUserPassword, newUserKeyTabFilePath); return(StatusCode(StatusCodes.Status201Created, new GenericReturnMessageDTO { Status = 201, Message = SuccessMessages.UserCreated })); }
public Task <bool> CreateNewUser(NewUserDTO data) => Task.Run(() => { Users user = new Users { Userid = Guid.NewGuid().ToString(), Usermoney = 0, Useremail = data.userEmail, Userlastname = data.userLastName, Username = data.userName, Userpassword = data.userPassword }; try { context.Users.Add(user); context.SaveChanges(); } catch (DbUpdateException e) { return(false); } bup.createNewBudget(new GetBudgetDTO { ownerId = user.Userid }); context.SaveChanges(); return(true); });
public async Task <ActionResult <UULResponse> > NewUser(NewUserDTO newUser) { UULResponse response; try { if (!newUser.isValid(out var msg)) { return(Error.ProfileValidationFailed.CreateErrorResponse(_logger, "NewProfile", new Exception(msg))); } var exist = await _context.Users.AnyAsync(u => u.Login.Equals(newUser.Login) && u.ApartmentCode == newUser.ApartmentCode); if (exist) { return(Error.ProfileAlreadyExists.CreateErrorResponse(_logger, "NewProfile")); } var user = UserDao.AddFromDto(_context, newUser); await _context.SaveChangesAsync(); var userInfo = new UserInfoDTO(user); var tokenString = SecHelper.GenerateJSONWebToken(userInfo.Login, userInfo.ApartmentCode, _config); response = new UULResponse() { Success = true, Message = tokenString, Data = userInfo }; } catch (Exception e) { response = Error.ProfileCreationFailed.CreateErrorResponse(_logger, "NewProfile", e); } return(response); }
public IActionResult AddNewUserToGroup(int groupId, [FromBody] NewUserDTO newUser) { var user = new NewUserDTO(newUser.FirstName, newUser.LastName, newUser.PhoneNumber); _userService.AddNewUserToGroup(user, groupId); return(Ok()); }
public static User NewUserDtoToUserModel(NewUserDTO userDto) => new User { FirstName = userDto.FirstName, LastName = userDto.LastName, PhoneNumber = userDto.PhoneNumber };
public async Task <IActionResult> PutUser([FromRoute] string userName, [FromBody] NewUserDTO user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var uti = await _context.User.SingleOrDefaultAsync(m => m.UserName == user.UserName); if (uti == null) { return(NotFound()); } uti.UserName = user.UserName; uti.Email = user.Email; uti.PhoneNumber = user.Phone.ToString(); await _userManager.RemovePasswordAsync(uti); await _userManager.AddPasswordAsync(uti, user.Password); _context.Entry(uti).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { throw; } return(NoContent()); }
public async Task <IActionResult> Post([FromBody] NewUserDTO dto) { ApplicationUser newUser = new ApplicationUser { UserName = dto.UserName, Email = dto.Email, IsCertified = dto.IsCertified, Language = dto.Language, NameCertified = dto.NameCertified, IsMale = dto.IsMale, BirthDate = dto.BirthDate }; IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password); bool userExist = await _roleManager.RoleExistsAsync("user"); if (!userExist) { await _roleManager.CreateAsync(new IdentityRole("user")); } await _userManager.AddToRoleAsync(newUser, "user"); // TODO: retourner un Created à la place du Ok; return((result.Succeeded)?Ok():(IActionResult)BadRequest()); }
public async Task <ReqResult> CreateNewUser(SignupDTO newUserInfo) { var emailIsUsed = await _context.Users .Where(user => user.email == newUserInfo.email) .FirstOrDefaultAsync(); if (emailIsUsed != null) { return(ReqResult.EmailInUse); } var newHash = BCrypt.Net.BCrypt.HashPassword(newUserInfo.password); var newUser = new NewUserDTO { email = newUserInfo.email, first_name = newUserInfo.first_name, last_name = newUserInfo.last_name, password_hash = newHash }; var dbInsertPayload = _mapper.Map <User>(newUser); await _context.AddAsync(dbInsertPayload); await _context.SaveChangesAsync(); return(ReqResult.Ok); }
private void SubmitASMX_Click(object sender, RoutedEventArgs e) { if (_CheckInput()) { NewUserDTO newUser = new NewUserDTO() { FirstName = textBoxFirstName.Text, LastName = textBoxLastName.Text, Email = textBoxEmail.Text, Password = passwordBox1.Password, CompanyId = _rCompanyService.GetCompanyIdByName(comboBoxCompany.SelectedItem.ToString()) }; var client = new RegistrationASMXServiceSoapClient(); var result = client.RegisterUser(newUser); if (string.IsNullOrWhiteSpace(result)) { errormessage.Text = ""; MessageBox.Show("You have Registered successfully!"); } else { errormessage.Text = result.ToString(); } } }
public static User AddFromDto(UULContext context, NewUserDTO newUser) { var salt = SecHelper.CreateSalt(); var habitant = new Habitant(newUser); context.Habitants.Add(habitant); var userToSave = new User { Login = newUser.Login, IsActivated = false, CreatedAt = DateOperations.Now(), Hash = SecHelper.SaltAndHashPwd(newUser.Pwd, salt), Salt = salt, ApartmentCode = newUser.ApartmentCode, Habitants = new List <Habitant>() { habitant } }; context.Users.Add(userToSave); return(userToSave); }
public User Create([FromBody] NewUserDTO NewUserData) { if (!NewUserData.Validate()) { throw new HttpResponseException(new HttpResponseMessage() { StatusCode = System.Net.HttpStatusCode.InternalServerError, ReasonPhrase = "Trying to Create invalid User", Content = new StringContent("The User is not valid and can't be created") }); } try { var NewUser = new User() { Name = NewUserData.Name, Birthdate = NewUserData.Birthdate, }; return(UserService.Create(NewUser)); } catch (HttpResponseException Ex) //catches an exception from a deeper layer. { throw Ex; } }
/// <summary> /// Creates a new user in the database and creates their empty main collection /// </summary> /// <param name="newUser">Object{FirstName: string, LastName: string, FirebaseUid:GUID, AvatarId:GUID}</param> /// <returns>True if no errors thrown</returns> public bool AddNewUserToDatabase(NewUserDTO newUser) { using (var db = new SqlConnection(_connectionString)) { newUser.DateCreated = DateTime.Now; var sql = @"INSERT INTO [User] ( [FirstName], [LastName], [FirebaseUid], [AvatarId], [DateCreated] ) OUTPUT INSERTED.Id VALUES ( @firstName, @lastName, @firebaseUid, @avatarId, @dateCreated )"; var userId = db.QueryFirst <Guid>(sql, newUser); return(_collectionRepo.addMainCollectionForNewUser(userId)); } }
public async Task <UserDTO> Register(NewUserDTO creatingUser) { var userSN = new NewUserSocialNetworkDTO() { UId = creatingUser.UId, ProviderName = creatingUser.ProviderName, SocialNetworkUrl = creatingUser.ProviderUrl, }; var user = _mapper.Map <User>(creatingUser); user.CreatedAt = DateTime.Now; _context.Add(user); await _context.SaveChangesAsync(); var userDto = _mapper.Map <UserDTO>(user); userSN.UserId = userDto.Id; var userSNEntity = _mapper.Map <UserSocialNetwork>(userSN); _context.Add(userSNEntity); await _context.SaveChangesAsync(); var emailModel = _emailBuilder.GetSignUpLetter(creatingUser.Email, creatingUser.FirstName); await _emailService.SendEmailAsync(new List <string> { emailModel.Email }, emailModel.Subject, emailModel.Title, emailModel.Body); return(_mapper.Map <UserDTO>(user)); }
public async Task <IActionResult> Put([FromRoute] string userName, [FromBody] NewUserDTO dto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var user = await _userManager.FindByNameAsync(userName); if (user != null) { var token = await _userManager.GeneratePasswordResetTokenAsync(user); if (dto.Email == user.Email) { IdentityResult result = await _userManager.ResetPasswordAsync(user, token, dto.Password); return((result.Succeeded)? Ok() : (IActionResult)BadRequest()); } return((IActionResult)BadRequest()); } else { return(NotFound()); } }
/// <summary> /// Create user with role organizer. /// </summary> /// <param name="newUserDTO">Details of new user to be created.</param> /// <returns>Returns created user or an appropriate error message.</returns> public async Task <UserDTO> CreateOrganizerAsync(NewUserDTO newUserDTO) { var user = new User() { FirstName = newUserDTO.FirstName ?? throw new ArgumentException(Exceptions.RequiredFirstName), LastName = newUserDTO.LastName ?? throw new ArgumentException(Exceptions.RequiredLastName), Email = newUserDTO.Email ?? throw new ArgumentException(Exceptions.RequiredEmail), UserName = newUserDTO.Email, Rank = await this.dbContext.Ranks.FirstOrDefaultAsync(r => r.Name.ToLower() == "organizer"), CreatedOn = DateTime.UtcNow }; if (await this.userManager.FindByEmailAsync(newUserDTO.Email) == null) { var result = await this.userManager.CreateAsync(user, newUserDTO.Password); if (result.Succeeded) { await this.userManager.AddToRoleAsync(user, "Organizer"); } else { throw new ArgumentException(Exceptions.IncorrectPassword); } } else { throw new ArgumentException(Exceptions.ExistingEmail); } await this.dbContext.SaveChangesAsync(); return(new UserDTO(user)); }
public async Task <IActionResult> CreateOrganizer(CreateUserViewModel model) { if (ModelState.IsValid) { try { var newUserDTO = new NewUserDTO() { FirstName = model.FirstName, LastName = model.LastName, Email = model.Email, EmailConfirmed = model.EmailConfirmed, Password = model.Password }; var user = await this.userService.CreateOrganizerAsync(newUserDTO); return(RedirectToAction(nameof(Index))); } catch (Exception e) { toastNotification.AddErrorToastMessage(e.Message, new NotyOptions()); return(View()); } } return(View()); }
public async Task <UserDTO> Register(NewUserDTO creatingUser) { var userSNEntity = new UserSocialNetwork() { UId = creatingUser.UId, ProviderName = creatingUser.ProviderName, SocialNetworkUrl = creatingUser.ProviderUrl, }; var user = _mapper.Map <User>(creatingUser, opt => opt.AfterMap((src, dst) => { dst.CreatedAt = DateTime.Now; dst.UserSocialNetworks = new List <UserSocialNetwork> { userSNEntity }; })); _context.Add(user); await _context.SaveChangesAsync(); var emailModel = _emailBuilder.GetSignUpLetter(creatingUser.Email, creatingUser.FirstName); await _emailService.SendEmailAsync(new List <string> { emailModel.Email }, emailModel.Subject, emailModel.Title, emailModel.Body); return(_mapper.Map <UserDTO>(user)); }
public async Task <IActionResult> Post([FromBody] NewUserDTO dto) { using (var contextTransaction = _context.Database.BeginTransaction()){ try{ var newUser = new ApplicationUser { UserName = dto.UserName, Email = dto.Email }; IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password); bool userExist = await _roleManager.RoleExistsAsync("USER"); if (!userExist) { await _roleManager.CreateAsync(new IdentityRole("USER")); } await _userManager.AddToRoleAsync(newUser, "USER"); // TODO: retourner un Created à la place du Ok; contextTransaction.Commit(); return((result.Succeeded)?Ok():(IActionResult)BadRequest()); }catch (Exception) { contextTransaction.Rollback(); return(StatusCode(500)); } } }
public UserDTO AddNew(NewUserDTO newUser, int userId) { var user = Mapper.Map <User>(newUser); user.CreatedAt = DateTime.Now; user.UpdatedAt = DateTime.Now; user.CreatedBy = userId; user.UpdatedBy = userId; user.Password = _hashService.Hash(user.Password); if (FindByCondition(u => u.Email == user.Email).Any()) { return(null); } try { Create(user); Save(); } catch (Exception) { return(null); } return(Mapper.Map <UserDTO>(user)); }
public IActionResult AddNewExternalUserToStep(AddResponsibleUserToStepDTO addExternalUserToStep) { Response.StatusCode = StatusCodes.Status202Accepted; if (string.IsNullOrEmpty(addExternalUserToStep.Step) && addExternalUserToStep.PlanId <= 0) { Response.StatusCode = StatusCodes.Status400BadRequest; return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); } var newExternaluser = addExternalUserToStep.NewResponsibleUser; if (TryValidateModel(newExternaluser)) { if (_userRepository.FindByCondition(u => u.Email == newExternaluser.Email).Any()) { ModelState.AddModelError("NewUser.Email", sharedResource.userAddNewExternalUserToStepEmailAlreadyExist); return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); } var newUser = new NewUserDTO { Email = newExternaluser.Email, FirstName = newExternaluser.FirstName, LastName = newExternaluser.LastName }; newUser.Password = _userRepository.GeneratePassword(); newUser.Role = Roles.External; var user = _userRepository.AddNew(newUser, HttpContext.GetUserId()); if (user == null) { ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepFailed); return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); } if (!_emailService.SendPasswordToUser(newUser.Password, user)) { ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepEmailNotSent); return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); } if (!_planRepository.AddUserToPlanStep(user.Id, addExternalUserToStep.PlanId, addExternalUserToStep.Step)) { ModelState.AddModelError(string.Empty, sharedResource.userAddNewExternalUserToStepNotAddedToteam); return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); } Response.StatusCode = StatusCodes.Status201Created; } return(PartialView("~/Views/User/Partials/_AddNewUser.cshtml")); }
public static void CreateDummyData(UULContext context) { for (int i = 0; i < 20; i++) { var user = new NewUserDTO() { Login = "******" + i, AvatarSrc = "Default", Name = "Inhabitant_" + i, ApartmentCode = "T" + i, Pwd = "12345" }; UserDao.AddFromDto(context, user); } context.SaveChanges(); List <TimeSlot> timeSlots = new(); var today = DateTime.UtcNow; for (int i = 0; i < 3; i++) { var slots = TimeSlotsFactory.CreateTimeSlotsForDateUTC(context, new DateTime(today.Year, today.Month, today.Day - i).ToUniversalTime(), 5); slots.Wait(); timeSlots.AddRange(slots.Result); } var habitants = context.Habitants.ToList(); var size = habitants.Count; var rnd = new Random(); foreach (TimeSlot timeSlot in timeSlots) { for (int i = 0; i < rnd.Next(4); i++) { if (timeSlot.OccupiedBy == null) { timeSlot.OccupiedBy = new List <Habitant>(); } timeSlot.OccupiedBy.Add(habitants.ElementAt(rnd.Next(size))); } } context.TimeSlots.AddRange(timeSlots); var newsList = new List <News>(); for (int i = 0; i < 5; i++) { newsList.Add(new News() { Title = "Title " + i, Content = " Content " + i + dummyContent, Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.GUESTS, NewsType = NewsType.INFO }); } newsList.Add(new News() { Title = "Title Registered", Content = " Content Registered", Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.REGISTERED, NewsType = NewsType.CALL_TO_ACTION }); newsList.Add(new News() { Title = "Title Activated", Content = " Content Activated", Author = "Dummy data generator", CreatedAt = DateTime.UtcNow, Auditory = Auditory.ACTIVATED, NewsType = NewsType.ALERT }); context.News.AddRange(newsList); }
public TwitterUser DtoToUser(NewUserDTO newUserDto) { return(new TwitterUser() { FirstName = newUserDto.FirstName, LastName = newUserDto.LastName, Email = newUserDto.Email, UserName = newUserDto.Email }); }
public async Task <IActionResult> Post([FromBody] NewUserDTO dto) { var newUser = new ApplicationUser { UserName = dto.UserName, Email = dto.Email }; IdentityResult result = await _userManager.CreateAsync(newUser, dto.Password); // TODO: retourner un Created à la place du Ok; return((result.Succeeded)?Ok():(IActionResult)BadRequest()); }
public ApplicationUserDTO AddNewApplicationUser(NewUserDTO newUser) { _uow.Users.Add(new ApplicationUser { UserName = newUser.UserName, Email = newUser.UserName, Name = newUser.Name, Registered = DateTime.Now }, newUser.Password); return(_applicationUserFactory.Transform(_uow.Users.FindByName(newUser.UserName))); }
public async Task <IActionResult> AddUser([FromBody] NewUserDTO data) { if (await Task.Run(() => _userProcessor.AddNewUser(data))) { return(Ok("User Added")); } else { return(BadRequest("This user already exists")); } }
public IActionResult AddNewUserToDatabase(NewUserDTO newUser) { if (_repo.AddNewUserToDatabase(newUser)) { return(Created($"user/{newUser.FirstName}", newUser)); } else { return(BadRequest()); } }
public async Task <IActionResult> AddUser([FromBody] NewUserDTO data) { if (await Task.Run(() => _userProcessor.CreateNewUser(data))) { return(Ok("User Added")); } else { return(BadRequest("User with that email already exists!")); } }
public UserDTO AddUser(NewUserDTO newUserDTO) { var user = DtoFactory.NewUserDtoToUserModel(newUserDTO); db.Users.AddEntity(user); db.Save(); var id = user.Id; var newUserModel = db.Users.GetUserById(id); return(DtoFactory.UserModelToUserDTO(newUserModel)); }
public IActionResult Admin([FromBody] NewUserDTO dto) { if (!IsInRole("Admin")) { return(Unauthorized()); } else { return(Ok()); } }