public async Task <IActionResult> Post([FromBody] User value) { var response = await _dataRepository.Add(value, "User"); if (response.Length > 0) { return(Conflict(response)); } return(Ok(response)); }
public void ShouldCreateAndGetUser() { User testUser = new User { Name = "Tony", Email = "*****@*****.**" }; var newUser = _usersRepository.Add(testUser.Name, testUser.Email); var result = _usersRepository.Get(newUser.UserId); Assert.AreEqual(newUser.Name, result.Name); Assert.AreEqual(newUser.Email, result.Email); }
public async Task <IActionResult> FollowOrganization(int userId, int organizationId) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var follow = await _repo.GetOrganizationFollow(userId, organizationId); if (follow != null) { return(BadRequest("You already follow this organization")); } if (await _repo.GetOrganizationById(organizationId) == null) { return(NotFound()); } follow = new OrganizationFollow { FollowerId = userId, FolloweeId = organizationId }; _repo.Add <OrganizationFollow>(follow); if (await _repo.SaveAll()) { return(Ok()); } return(BadRequest("Failed to follow organization")); }
public async Task <IActionResult> RegisterAccount([FromBody] Models.Users user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } bool bDuplicateEmail = _usersRepository.FindDuplicateEmail(user.Email); if (bDuplicateEmail) { return(Conflict("Duplicate Email")); } bool bDuplicateaUserName = _usersRepository.FindDuplicateEmail(user.UserName); if (bDuplicateaUserName) { return(Conflict("Duplicate UserName")); } user = await _usersRepository.Add(user); var results = new ObjectResult(user) { StatusCode = (int)HttpStatusCode.OK }; return(results); }
public ActionResult Create(User user) { _repository.Add(user); var fu = _repository.FindByName(user.UserName); return(Json(fu, JsonRequestBehavior.AllowGet)); }
public async Task <HttpResponseMessage> Add([FromBody] UsersModel objUsersModel) { HttpRequestMessage request = new HttpRequestMessage(); try { if (!ModelState.IsValid) { return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } Users objUsers = new Users { Name = objUsersModel.name }; await Task.Run(() => { _usersRepository.Add(objUsers); }); return(request.CreateResponse(HttpStatusCode.OK, objUsers, Configuration.Formatters.JsonFormatter)); } catch (Exception ex) { return(request.CreateResponse(HttpStatusCode.BadRequest, ex.Message)); } }
public IActionResult Create([FromBody] CreateUsers usrToCreate) { User user = Data.Domain.Entities.User.Create(usrToCreate.Name, usrToCreate.IsAdmin, usrToCreate.Email, usrToCreate.Password, usrToCreate.Token, usrToCreate.Description); _repository.Add(user); return(Ok(user)); }
public async Task <Response> Execute(Request request) { request.Treatment(); Validate(request); var user = await _usersRepository.GetByCpf(request.Cpf); if (user != null) { _notifications.Add($"Já existe um usuário com o CPF {request.Cpf}.", nameof(Request.Cpf)); } if (!_notifications.IsValid()) { return(new Response() { Errors = _notifications.Notifications }); } user = request.ToUser(); await _usersRepository.Add(user); var token = await _tokenService.GenerateToken(user); return(new Response() { User = UserDto.From(user), Token = token, Errors = _notifications.Notifications }); }
public void ShouldAddNewUser() { var user = UsuarioBuilder.New().WithId(id).Build(); var ret = usersRepository.Add(user); ret.Should().BeGreaterThan(0); }
public void Create([FromBody] User user) { if (user != null) { _UsersRepo.Add(user); } }
public IActionResult Post([FromBody] User user) { if (ModelState.IsValid) { string hashedPassword = Convert.ToBase64String(KeyDerivation.Pbkdf2( password: user.PasswordHash, salt: Salt.SALT, prf: KeyDerivationPrf.HMACSHA1, iterationCount: 10000, numBytesRequested: 256 / 8)); user.PasswordHash = hashedPassword; if (user.Role != "admin" && String.IsNullOrWhiteSpace(user.Role)) { user.Role = "user"; } _usersRepository.Add(user); return(Ok()); } return(BadRequest()); }
public async Task <IActionResult> LikeUser(int id, int recipientId) { if (checkUser(id)) { return(Unauthorized()); } var like = await _usersRepository.GetLike(id, recipientId); if (like != null) { return(BadRequest("You already like this user")); } if (await _usersRepository.GetUser(recipientId) == null) { return(NotFound()); } like = new Like { LikerId = id, LikeeId = recipientId }; await _usersRepository.Add <Like>(like); if (await _usersRepository.SaveAll()) { return(Ok()); } return(BadRequest("Failed to like user")); }
public async Task <IActionResult> CreateMessage(int userId, MessageForCreationDto messageForCreationDto) { var sender = await _repo.GetUser(userId); if (sender.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } messageForCreationDto.SenderId = userId; var recipient = await _repo.GetUser(messageForCreationDto.RecipientId); if (recipient == null) { return(BadRequest("Could not find user")); } var message = _mapper.Map <Message>(messageForCreationDto); _repo.Add(message); if (await _repo.SaveAll()) { var messageToReturn = _mapper.Map <MessageForReturnDto>(message); return(CreatedAtRoute("GetMessage", new { id = message.Id }, messageToReturn)); } throw new Exception("Creating the message failed on save"); }
public void Create(CreateUserInputDto userInput, string password) { if (string.IsNullOrEmpty(password)) { throw new PasswordIsRequiredException(); } if (_usersRepository.Get(e => e.Email == userInput.Email).Any()) { throw new EmailIsAlreadyTakenException(userInput.Email); } CreatePasswordHash(password, out var passwordHash, out var passwordSalt); var user = new User { FirstName = userInput.FirstName, LastName = userInput.LastName, Email = userInput.Email, PasswordHash = passwordHash, PasswordSalt = passwordSalt }; _usersRepository.Add(user); }
public CreatedUserDTO Create( string name, string cpf, string email, string phone, string state, string city, string district, string zipCode, string houseNumber, string addressComplement, UserProfile profile, string password ) { var crypt = new Crypt(); var cryptPassword = crypt.CreateMD5(password); var user = new User(name, cpf, email, phone, state, city, district, zipCode, houseNumber, addressComplement, profile, cryptPassword); var userValidation = user.Validate(); if (userValidation.isValid) { _usersRepository.Add(user); return(new CreatedUserDTO(user.Id)); } return(new CreatedUserDTO(userValidation.errors)); }
public async Task <UserModel> Register(UserRegisterModel userRegisterModel) { var user = await _userRepository.GetByUsername(userRegisterModel.UserName); if (user != null) { return(null); } var newUser = new User( userRegisterModel.UserName, userRegisterModel.Email, _passwordHasher.CreateHash(userRegisterModel.Password), userRegisterModel.Role, userRegisterModel.FirstName, userRegisterModel.LastName, userRegisterModel.PhoneNumber); newUser.UpdateAddress(userRegisterModel.Address); await _userRepository.Add(newUser); if (userRegisterModel.Role == Role.Student) { await _studentService.AddStudentToFaculty(userRegisterModel.UniversityId, userRegisterModel.FacultyId, newUser.Id); } await _userRepository.SaveChanges(); return(_mapper.Map <UserModel>(newUser)); }
public StatusModel SignUp(User user) { var response = new StatusModel(); var exist = _usersRepository.CheckIfExists(user.Username, user.Email); if (exist) { response.IsSuccessful = false; response.Message = "User with username or email already exists"; return(response); } else { var newUser = new User() { Username = user.Username, Email = user.Email, DateCreated = DateTime.Now, Password = BCrypt.Net.BCrypt.HashPassword(user.Password), }; _usersRepository.Add(newUser); return(response); } }
public object Post(User added) { object json; try { User posted = repository.Add(added); json = new { total = 1, data = posted, success = true }; } catch (Exception ex) { LogManager.Write("ERROR:" + Environment.NewLine + "\tMETHOD = " + this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + Environment.NewLine + "\tMESSAGE = " + ex.Message); json = new { message = ex.Message, success = false }; }; return(json); }
public void RegisterUser(RegisterInputModel registerInputModel) { var user = new Users() { DateAdded = DateTime.Now, EmailAddress = registerInputModel.EmailAddress, FirstName = registerInputModel.FirstName, LastName = registerInputModel.LastName, Id = Guid.NewGuid(), Password = registerInputModel.Password }; _usersRepository.Add(user); _usersRepository.SaveChanges(); if (registerInputModel.Score.HasValue) { _quizScoresRepository.Add(new QuizScores() { Id = Guid.NewGuid(), Score = registerInputModel.Score.Value, DateAdded = DateTime.Now, UserId = user.Id, User = user }); _quizScoresRepository.SaveChanges(); } }
public async Task <ActionResult <Users> > PostUsers(Users users) { userRepo.Add(users); await userRepo.SaveChangesAsync(); return(CreatedAtAction("GetUsers", new { id = users.UserId }, users)); }
public IHttpActionResult AddUser([FromBody] UserDTO userData) { if (userData == null) { return(BadRequest()); } User user = Mapper.Map <UserDTO, User>(userData); User newUser = null; if (userData.UserId == 0) { newUser = _usersRepository.Add(user); if (newUser.UserId > 0) { return(Created(Request.RequestUri + "/" + user.UserId.ToString(), Mapper.Map <User, UserDTO>(newUser))); } } return(BadRequest()); }
public async Task <IActionResult> CreateMessage(int id, [FromBody] MessageForCreationDto messageForCreationDto) { if (checkUser(id)) { return(Unauthorized()); } var recipient = await this._userRepo.GetUser(messageForCreationDto.RecipientId); if (recipient == null) { return(BadRequest("Could not find user")); } messageForCreationDto.SenderId = id; var message = _mapper.Map <Message>(messageForCreationDto); await _userRepo.Add(message); if (await _userRepo.SaveAll()) { var messageToReturn = _mapper.Map <MessageToReturnDto>(await _userRepo.GetMessage(message.Id)); return(CreatedAtRoute("GetMessage", new { id, messageId = message.Id }, messageToReturn)); } throw new Exception("Creating the message failed on save"); }
public StatusModel SignUp(User user) { var response = new StatusModel(); var exist = _usersRepository.CheckIfExists(user.Username, user.Email); if (exist) { response.Success = false; response.Message = "This username has alredy been taken. Please try with another username."; } else { var newUser = new User() { Username = user.Username, Name = user.Name, Lastname = user.Lastname, Password = BCrypt.Net.BCrypt.HashPassword(user.Password), Address = user.Address, Email = user.Email, DateCreated = DateTime.Now, }; _usersRepository.Add(newUser); response.Success = true; } return(response); }
public async Task <IdentityResult> CreateAsync(ApplicationUser user, CancellationToken cancellationToken) { user.Id = Guid.NewGuid().ToString(); await _repo.Add(user); return(await Task.FromResult(IdentityResult.Success)); }
public void Create(User user) { lockService.Execute(() => { user.Assert(() => new ArgumentNullException("user")) .Do(u => ValidateAndThrowIfErrors(u)) .Do(u => usersRepository.Add(u)); }); }
public async Task SaveAccount(RegisterRequest register) { await Validate(register); var user = _mapper.Map <User>(register); user.PasswordHash = _hasher.HashPassword(user, register.Password); await _repository.Add(user); }
public User Add(UserDTO UserDTO) { IEnumerable <UserRole> userRoles = _usersRepo.GetUserRoles(UserDTO.UserRoles); User user = _mapper.Map <User>(UserDTO); _usersRepo.Add(user, userRoles); return(user); }
public async Task <Guid> Handle(CreateUserCommand command, CancellationToken cancellationToken) { var user = new User(command.Email, command.FirstName, command.LastName, _passwordService.HashPassword(command.Password)); await _usersRepository.Add(user); await _usersRepository.UnitOfWork.SaveEntitiesAsync(); return(user.Id); }
public async Task <IActionResult> Create([Bind("Id,Name,Password,Username,Email,Gender,Age,FollowId,CurrentFollowers")] Users users) { if (ModelState.IsValid) { await _dataAccessProvider.Add(users); return(RedirectToAction(nameof(Index))); } return(View(users)); }
public IActionResult Post([FromBody] UserItem item) { var result = repository.Add(item); if (result == null) { return(NotFound()); } return(Ok()); }