public async Task <ActionResult <UserDTO> > UpdateUser(int id, [FromBody] SaveUserDTO saveUserResource)
        {
            /*
             *  TODO Validator yazılacak
             */
            // var validator = new CreateUserResourceValidator();
            // var validationResult = await validator.ValidateAsync(saveUserResource);

            // if (!validationResult.IsValid)
            //     return BadRequest(validationResult.Errors); // this needs refining, but for demo it is ok

            var userToBeUpdated = await _userService.GetUserById(id);

            if (userToBeUpdated == null)
            {
                return(NotFound());
            }

            var user = _mapper.Map <SaveUserDTO, User>(saveUserResource);

            user.PasswordHash = HashHelper.CreatePasswordHash(saveUserResource.Password, userToBeUpdated.SecretKey);
            await _userService.UpdateUser(userToBeUpdated, user);

            var updatedUser = await _userService.GetUserById(id);

            var updatedUserResource = _mapper.Map <User, UserDTO>(updatedUser);

            return(Ok(updatedUserResource));
        }
        public async Task <ActionResult> AddUserAsync(SaveUserDTO saveUserDTO)
        {
            var userAsync = await _unitOfWork.Users.FindAsync(u =>
                                                              u.Identifier.Equals(saveUserDTO.Identifier));

            if (userAsync.Count() != 0)
            {
                return(BadRequest(new {
                    Identifier = "CMND đã được sử dụng"
                }));
            }

            userAsync = await _unitOfWork.Users.FindAsync(u =>
                                                          u.Email.Equals(saveUserDTO.Email));

            if (userAsync.Count() != 0)
            {
                return(BadRequest(new {
                    Email = "Email đã được sử dụng"
                }));
            }

            saveUserDTO.Password = BCrypt.Net.BCrypt.HashPassword(_appSettings.DefaultPassword);

            var user = _mapper.Map <SaveUserDTO, User> (saveUserDTO);
            await _unitOfWork.Users.AddAsync(user);

            await _unitOfWork.CompleteAsync();

            return(Ok());
        }
        public async Task <ActionResult> UpdateUserAsync(int id, SaveUserDTO saveUserDTO)
        {
            var user = await _unitOfWork.Users.GetByAsync(id);

            // Check exists
            var userAsync = await _unitOfWork.Users.FindAsync(
                u => u.Identifier.Equals (saveUserDTO.Identifier) &&
                u.Id != id);

            if (userAsync.Count() != 0)
            {
                return(BadRequest(new {
                    Identifier = "CMND đã được sử dụng"
                }));
            }

            userAsync = await _unitOfWork.Users.FindAsync(
                u => u.Email.Equals (saveUserDTO.Email) &&
                u.Id != id);

            if (userAsync.Count() != 0)
            {
                return(BadRequest(new {
                    Email = "Email đã được sử dụng"
                }));
            }

            // Mapping: SaveUser
            _mapper.Map <SaveUserDTO, User> (saveUserDTO, user);

            await _unitOfWork.CompleteAsync();

            return(Ok());
        }
Beispiel #4
0
        public async Task <ActionResult> PostUserAsync([FromBody] SaveUserDTO saveUserDTO)
        {
            var res = await _service.AddUserAsync(saveUserDTO);

            return(res);
        }
Beispiel #5
0
        public async Task <ActionResult> PutUserAsync(int id, SaveUserDTO saveUserDTO)
        {
            var res = await _service.UpdateUserAsync(id, saveUserDTO);

            return(res);
        }
Beispiel #6
0
 public IResult AddUser([FromBody] SaveUserDTO user)
 => this.userService.AddUser(
     user.Name,
     user.SecondName,
     user.Email,
     user.Password);