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());
}
