public async Task <IActionResult> Get([FromBody] UserRequestDto value) { var privMessage = await CheckPriv(value); if (!string.IsNullOrEmpty(privMessage)) { return(BadRequest(privMessage)); } var users = await _ctx.Users .Select(u => new { u.UserId, u.UserName }) .ToListAsync(); var result = users.Select(x => new UserCardDto() { UserId = x.UserId, UserName = x.UserName }).ToList(); if (result.Any()) { return(Ok(result)); } return(NotFound()); }
public async Task <IActionResult> Update([FromBody] UserRequestDto user) { //Before updating find user by id var userData = await _uow.Users.GetAsync(user.ID); if (userData != null && userData.ID > 0) { //Map update data _mapper.Map(user, userData); //Change Modified Data userData.ModifyDate = DateTime.Now; _uow.Users.Update(userData); var result = await _uow.CompleteAsync(); if (result > 0) { //Before returning updated user data, map user => UserSharedDto return(Ok(_mapper.Map <UserSharedDto>(userData))); } else { return(new JsonResult(new { Success = false, Message = "User changes are not updated" })); } } else { return(NotFound(new { Success = false, Message = "User not found with sended details." })); } }
public async Task InsertBrandAsync_Return_Created_Result(Mock <IUserService> userService, UserResponseDto expected) { // Arrange var sut = new AccountController(userService.Object); sut.ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() }; UserRequestDto requestDto = new UserRequestDto() { Name = "testName", Surname = "testSurname" }; userService.Setup(setup => setup.RegisterUserAsync(requestDto)).Returns(Task.FromResult(expected)); // Act var result = sut.RegisterUserAsync(requestDto); var apiResult = result.Result.Should().BeOfType <CreatedAtActionResult>().Subject; var model = Assert.IsType <ApiResult>(apiResult.Value); UserResponseDto response = model.Data as UserResponseDto; // Assert Assert.IsType <CreatedAtActionResult>(result.Result); Assert.IsNotType <OkObjectResult>(result.Result); Assert.IsNotType <BadRequestObjectResult>(result.Result); Assert.IsNotType <AcceptedAtActionResult>(result.Result); Assert.NotNull(result.Result); Assert.NotNull(expected); Assert.IsAssignableFrom <UserResponseDto>(expected); }
public IActionResult JoinChat([FromQuery(Name = "id")] int id, [FromBody] UserRequestDto user) { if (id == 0) { return(new NotFoundObjectResult("Cannot resolve this url")); } var chatRoom = ChatRoomRepository.GetById(id); if (chatRoom == null) { return(new NotFoundObjectResult($"Cannot find chat room with id {id}")); } var existingUser = chatRoom.Users.FirstOrDefault(x => x.UserName == user.Name); if (existingUser != null) { return(new ConflictObjectResult($"User with name {user.Name} already in room")); } chatRoom.Users.Add(new Connection { UserName = user.Name, }); ChatRoomRepository.Save(); return(new OkResult()); }
public async Task <UserSharedDto> Create([FromBody] UserRequestDto user) { //Map dto user object var mappedUser = _mapper.Map <User>(user); //Add not mapped fields mappedUser.CreateDate = DateTime.Now; mappedUser.ModifyDate = DateTime.Now; mappedUser.IsDeleted = false; await _uow.Users.AddAsync(mappedUser); var result = await _uow.CompleteAsync(); if (result > 0) { //Map User => UserSharedDto var resultUser = _mapper.Map <UserSharedDto>(mappedUser); return(resultUser); } else { return(null); } }
public async Task <IActionResult> Register([FromBody] UserRequestDto userRequestDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } User newUser = new User { Email = userRequestDto.Email, Name = userRequestDto.Name, LastName = userRequestDto.LastName, UserName = userRequestDto.Email }; IdentityResult result = await _userManager.CreateAsync(newUser, userRequestDto.Password); if (!result.Succeeded) { foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(BadRequest(ModelState)); } newUser = await _userManager.FindByEmailAsync(userRequestDto.Email); return(Ok()); }
// POST api/values public IHttpActionResult Post([FromBody] UserRequestDto req) { try { if (context.User.Where(x => x.Username == req.Username || x.Email == req.Email).Count() > 0) { return(BadRequest("username is already exits")); } // var data = Mapper.Map<CameraRequestDto, Camera>(req); User user = new User() { CreateDate = DateTime.Now, Email = req.Email, FullName = req.FullName, Password = req.Password, IsDeleted = "N", Username = req.Username, PhoneNumber = req.PhoneNumber, UserTypeId = 2 // citizen }; context.User.Add(user); context.SaveChanges(); return(Ok("Done")); } catch (Exception ex) { throw ex; } }
public string CreateNewUser(UserRequestDto userRequestDto) { using (var unitOfWork = new UnitOfWork()) { var userData = unitOfWork.UserUnitRepository.GetFirst(x => x.EmailId.Equals(userRequestDto.EmailId, StringComparison.OrdinalIgnoreCase)); if (userData != null) { return(null); } var user = new User() { EmailId = userRequestDto.EmailId, UserName = userRequestDto.UserName, Password = userRequestDto.Password, TimeStamp = DateTime.Now, }; unitOfWork.UserUnitRepository.Insert(user); unitOfWork.SaveChanges(); userData = unitOfWork.UserUnitRepository.GetFirst(x => x.EmailId.Equals(userRequestDto.EmailId, StringComparison.OrdinalIgnoreCase)); var userProduceDTO = new UserProduceDTO() { UserId = userData.Id, EmailId = userData.EmailId, UserName = userData.UserName, Password = userData.Password }; var message = JsonConvert.SerializeObject(userProduceDTO); var codeSignKafkaProducer = new CodeSignKafkaProducer(); codeSignKafkaProducer.CodeSignProducer(message, "userResister"); return("Success"); } }
public async Task <long> AddUser(UserRequestDto requestDto) { var user = await _unitOfWork.FindAsyncByPredicateWithIncludeProperty <UserEntity>(x => x.UserName == requestDto.UserName); if (user.Count > 0) { throw new ConflictException($"{requestDto.UserName} user name already exists"); } var userRoles = new List <UserRoleEntity>() { new UserRoleEntity() { RoleId = 2 } }; var userEntity = new UserEntity(); userEntity.UserName = requestDto.UserName; userEntity.FullName = requestDto.FullName; userEntity.UserRoles = userRoles; userEntity.Password = _cryptographer.Encrypt(requestDto.Password); _unitOfWork.Add <UserEntity>(userEntity); await _unitOfWork.SaveChanges(); return(userEntity.Id); }
public async Task <ActionResult> Put( Guid id, UserRequestDto userRequestDto, [FromServices] ICommandDispatcher commandDispatcher) { return(Ok(await commandDispatcher.Dispatch(new UpdateUserCommand(id, userRequestDto)).ConfigureAwait(false))); }
public async Task <IActionResult> Get(int id, [FromBody] UserRequestDto value) { var privMessage = await CheckPriv(value); if (!string.IsNullOrEmpty(privMessage)) { return(BadRequest(privMessage)); } var userInfo = await _ctx.Users .Include(u => u.Author) .FirstOrDefaultAsync(u => u.UserId == id); if (userInfo == null) { return(NotFound()); } var result = new UserDetailDto() { AuthorId = (int)userInfo.AuthorId, AuthorName = userInfo.Author.AuthorName, AuthorPicLink = userInfo.Author.AuthorPicLink, Privs = userInfo.Privs, UserId = userInfo.UserId, UserName = userInfo.UserName }; return(Ok(result)); }
public Task <int> AddUser(UserRequestDto user) { var maxUserId = _usersList.Max(x => x.Id); (_usersList as List <User>).Add(new User() { Name = user.Name, Email = user.Email, Phone = user.Phone, Id = maxUserId + 1 }); if (user.CitiesIds != null) { foreach (var item in user.CitiesIds) { var maxUserCitiesId = _userCitiesList.Max(x => x.Id); (_userCitiesList as List <UserCities>).Add(new UserCities() { CityId = item, UserId = maxUserId + 1, Id = maxUserCitiesId + 1 }); } } return(Task.Run(() => maxUserId + 1)); }
public async Task <UserResponseDto> CreateAsync(UserRequestDto user) { var appUser = MapToRequest(user); await _userManager.CreateAsync(appUser, user.Password); return(MapToResponse(appUser)); }
public async Task <UserResponseDto> RegisterUserAsync([NotNull] UserRequestDto dto) { var response = mapper.Map <UserResponseDto>(await userRepository.AddAsync(mapper.Map <User>(dto))); response.AccessToken = configuration.GetValue <string>("AccessToken"); return(response); }
private static void CheckParameterUpdateUser(UserRequestDto request) { if (request == null) { throw new UserRequestDtoNullException($"El parametro: {nameof(request)} es obligatorio"); } if (request.UsuarioId == default || request?.UsuarioId == null) { throw new UsuarioIdNullException($"El parametro: {nameof(request.UsuarioId)} es obligatorio"); } if (string.IsNullOrEmpty(request.Nombre)) { throw new NombreNullException($"El parametro: {nameof(request.Nombre)} es obligatorio"); } if (string.IsNullOrEmpty(request.Apellido)) { throw new ApellidoNullException($"El parametro: {nameof(request.Apellido)} es obligatorio"); } if (string.IsNullOrEmpty(request.Correo)) { throw new CorreoNullException($"El parametro: {nameof(request.Correo)} es obligatorio"); } if (string.IsNullOrEmpty(request.Contrasena)) { throw new ContrasenaNullException($"El parametro: {nameof(request.Contrasena)} es obligatorio"); } if (request.FechaRegistro == default || request?.FechaRegistro == null) { throw new FechaRegistroNullException($"El parametro: {nameof(request.FechaRegistro)} es obligatorio"); } }
public Result <UserDto> CreateUser(UserRequestDto user) { if (user == null) { throw new ArgumentNullException("user"); } return(WorkWithDb(db => { if (db.Set <User>() .FirstOrDefault(u => u.Login.Equals(user.Login, StringComparison.InvariantCultureIgnoreCase)) != null) { return Result <UserDto> .Fail(Errors.UserAlreadyExists); } var newUser = MapNewUser(user); db.Set <User>().Add(newUser); db.SaveChanges(); var createdUser = db.Set <User>() .Single(u => u.Login.Equals(user.Login, StringComparison.InvariantCultureIgnoreCase)); return Result <UserDto> .Success(createdUser.Dto); })); }
public async Task UpdateUser_ValidUser_Success() { // Arrange var userRequestDtos = new UserRequestDto { Id = "1", Email = "*****@*****.**", FullName = "Test Full Name", UserName = "******", Password = "******" }; var userResponseDtos = new UserResponseDto { Id = "1", Email = "*****@*****.**", FullName = "Test Full Name", UserName = "******" }; _userServiceMock.Setup(c => c.UpdateAsync(userRequestDtos.Id, userRequestDtos)).ReturnsAsync(userResponseDtos); _usersApiController = new UsersApiController(_userServiceMock.Object, _httpContextAccessorMock.Object); // Act var result = await _usersApiController.Put(userRequestDtos.Id, userRequestDtos); // Assert var resultStatusCode = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode; var resultValue = (UserResponseDto)((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value; Assert.Equal((int)HttpStatusCode.Accepted, resultStatusCode); Assert.Equal(userRequestDtos.Email, resultValue.Email); }
public UserRequestDto GetUser(UserRequestDto request) { var user = _repoUser .SearchMatching <UserEntity>(x => x.UsuarioId == request.UsuarioId); return(_mapper.Map <UserRequestDto>(user.FirstOrDefault())); }
public async Task <int> AddUser(UserRequestDto user) { using (var context = new CitiesUsersContext()) { User newUser = new User() { Name = user.Name, Email = user.Email, Phone = user.Phone }; context.Users.Add(newUser); await context.SaveChangesAsync(); if (user.CitiesIds != null) { foreach (var item in user.CitiesIds) { UserCities userCities = new UserCities() { CityId = item, UserId = newUser.Id }; context.UserCities.Add(userCities); } await context.SaveChangesAsync(); } return(newUser.Id); } }
public bool AddAdmin(UserRequestDto userRequestDto) { var admin = _ecommerceContext.Admin.AsNoTracking().FirstOrDefault(x => x.Username == userRequestDto.Username); if (admin == null) { byte[] passwordHash, passwordSalt; CreatePasswordHash(userRequestDto.Password, out passwordHash, out passwordSalt); var newAdmin = new Admin { AdminId = Guid.NewGuid(), Username = userRequestDto.Username, PasswordHash = passwordHash, PasswordSalt = passwordSalt }; _ecommerceContext.Add(newAdmin); if (_ecommerceContext.SaveChanges() == 1) { return(true); } } return(false); }
public async Task <UserDataResultResponseDto> CreateUserAsync(UserRequestDto userRequest) { UserDataResultResponseDto response = new UserDataResultResponseDto(); List <string> errorList = new List <string>(); var user = new CustomUser { UserName = userRequest.userName, Email = userRequest.userName }; var result = await _userManager.CreateAsync(user, userRequest.password); if (result.Succeeded) { response.Token = await BuildTokenAsync(user); return(response); } //verify how read error foreach (IdentityError error in result.Errors) { //to ModelState errorList.Add(error.Description); } response.ErrorList = errorList; return(response); }
public async Task <IEnumerable <ApplicationUser> > GetClientAsync(UserRequestDto req) { Expression <Func <ApplicationUser, bool> > predicate = c => true; if (!string.IsNullOrEmpty(req.FullName)) { predicate = predicate.And(p => p.FullName.Contains(req.FullName)); } if (!string.IsNullOrEmpty(req.FullNameAr)) { predicate = predicate.And(p => p.FullNameAr.Contains(req.FullNameAr)); } if (req.IsActive != null) { predicate = predicate.And(p => p.IsActive == req.IsActive); } if (!string.IsNullOrEmpty(req.Email)) { predicate = predicate.And(p => p.Email == req.Email); } if (req.DateFrom != null && req.DateTo != null) { predicate = predicate.And(p => p.CreatedDate >= req.DateFrom && p.CreatedDate <= req.DateTo); } predicate = predicate.And(p => p.Claims.Any(c => c.ClaimType == "UserType" && c.ClaimValue == "Client")); return(await userManager.Users.Where(predicate).ToListAsync()); }
public async Task <IActionResult> Post([FromBody] UserRequestDto requestDto) { m_Logger.Information($"{nameof(Post)} Invoked"); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var request = m_Mapper.Map <UserDto>(requestDto); bool result = false; if (requestDto.Silent) { result = await m_UserManager.AddUserSilentAsync(request).ConfigureAwait(false); } else { result = await m_UserManager.AddUserAsync(request).ConfigureAwait(false); } if (result) { return(Ok(result)); } } catch (Exception ex) { m_Logger.Error(ex, "Error caught in the controller class."); } return(BadRequest(HttpStatusCode.BadRequest)); }
public async Task <IHttpActionResult> UpdateUser(UserRequestDto model) { var controllerEndpoint = _configurationManager.GetByKey("IS.UpdateUser"); var response = await PutAsync(controllerEndpoint, model); return(ResponseMessage(response)); }
public async Task <IActionResult> Post([FromBody] UserRequestDto user) { if (!ModelState.IsValid) { return(BadRequest()); } return(Created(nameof(Get), await _userService.CreateAsync(user))); }
public async Task <User> Create(UserRequestDto dto) { User entity = _mapper.Map <UserRequestDto, User>(dto); User User = await _unitOfWork._userRepository.Create(entity); await _unitOfWork.SaveChanges(); return(User); }
public void Check_Dtos_UserAdd_implements_DataTransferObject() { var usertDto = new UserDto(); var userRequestDto = new UserRequestDto(); var userResponseDto = new UserResponseDto(); _ = Assert.IsAssignableFrom <DataTransferObject>(usertDto); _ = Assert.IsAssignableFrom <UserDto>(userRequestDto); _ = Assert.IsAssignableFrom <DataTransferObject>(userResponseDto); }
public async Task <IActionResult> AddNewUser([FromBody] UserRequestDto newUser) { if (!ModelState.IsValid) { return(BadRequest()); } var userId = await _userCitiesProvider.AddUser(newUser); return(Ok(new { addedUserId = userId })); }
public async Task <IActionResult> PostUser(UserRequestDto userRequestDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userResponseDto = await _userManager.CreateAsync(userRequestDto); return(Ok(userResponseDto)); }
public async Task <IActionResult> Delete([FromBody] UserRequestDto userRequestDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _userManager.DeleteAsync(userRequestDto); return(Ok()); }