public IActionResult Get([FromQuery] UserResourceParameters resourceParameters)
{
if (!propertyMappingService.ValidMappingExistsFor <User>(resourceParameters.OrderBy))
{
return(BadRequest());
}
var data = userService.GetAll(resourceParameters);
var previousPageLink = data.HasPrevious ? urlHelper.CreateUserResourceUri("GetUsers", ResourceUriType.PreviousPage, resourceParameters) : null;
var nextPageLink = data.HasNext ? urlHelper.CreateUserResourceUri("GetUsers", ResourceUriType.PreviousPage, resourceParameters) : null;
var paginationMetadata = new
{
totalCount = data.TotalCount,
pageSize = data.PageSize,
currentPage = data.CurrentPage,
totalPages = data.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
List <UserViewModel> resources = mapper.Map <List <UserViewModel> >(data);
return(Ok(resources));
}
public async Task <IActionResult> GetUsersWithRolesAsync(UserResourceParameters parameters)
{
var result = new Result();
var loggedInUser = await GetUser();
try
{
var userQry = _userManager.Users.Where(u => u.IsActive && !u.IsDeleted);
if (!User.IsInRole(supAdminRole))
{
userQry = userQry.Where(u => u.SharedKey == _key);
}
var queryResult = _mapper.Map <IEnumerable <UserListModel> >(userQry).AsQueryable();
var data = queryResult.GetPaged(parameters.PageNo, parameters.PageSize);
result.Success = true;
result.Data = data;
return(Ok(result));
}
catch (Exception ex)
{
result.AddError(ex.Message);
}
return(BadRequest(result));
}
public async Task <IEnumerable <User> > GetUsers(UserResourceParameters userResourceParameters)
{
var phoneNumber = userResourceParameters.PhoneNumber;
var name = userResourceParameters.Name;
if (string.IsNullOrWhiteSpace(phoneNumber) && string.IsNullOrWhiteSpace(name))
{
return(await GetUsers());
}
var users = _context.Users as IQueryable <User>;
if (!string.IsNullOrWhiteSpace(phoneNumber))
{
phoneNumber = phoneNumber.Trim();
users = users.Where(user => user.PhoneNumber.Contains(phoneNumber));
}
if (!string.IsNullOrWhiteSpace(name))
{
name = name.Trim();
users = users.Where(user => user.FirstName.Contains(name) ||
user.LastName.Contains(name));
}
return(await users.ToListAsync());
}
public async Task <IActionResult> Get([FromQuery] UserResourceParameters resourceParameters)
{
var users = _userRepo.GetAllPagination(resourceParameters);
var mappedUsers = _mapper.Map <IEnumerable <UserToReturnDto> >(users);
//Construct links to previous+ next page
var previousPage = users.HasPrevious ?
_linkService.CreateResourceUri(resourceParameters, ResourceType.PreviousPage) : null;
var nextPage = users.HasNext ?
_linkService.CreateResourceUri(resourceParameters, ResourceType.NextPage) : null;
var paginationMetadata = new
{
totalCount = users.TotalCount,
pageSize = users.PageSize,
currentPage = users.CurrentPage,
totalPages = users.TotalPages,
previousPageLink = previousPage,
nextPageLink = nextPage
};
return(Ok(new
{
Values = mappedUsers,
Links = paginationMetadata
}));
}
private IEnumerable <LinkDto> CreateLinksForUsers(
UserResourceParameters userResourceParameters,
bool hasNext, bool hasPrevious)
{
var links = new List <LinkDto>();
// self
links.Add(
new LinkDto(CreateUsersResouceUri(userResourceParameters,
ResourceUriType.Current)
, "self", "GET"));
if (hasNext)
{
links.Add(
new LinkDto(CreateUsersResouceUri(userResourceParameters,
ResourceUriType.NextPage),
"nextPage", "GET"));
}
if (hasPrevious)
{
links.Add(
new LinkDto(CreateUsersResouceUri(userResourceParameters,
ResourceUriType.PreviousPage),
"previousPage", "GET"));
}
return(links);
}
public IActionResult GetUser(Guid id, [FromQuery] string fields, UserResourceParameters userResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <UserDto>
(userResourceParameters.Fields))
{
return(BadRequest());
}
var userFromRepo = _libraryRepository.GetUser(id);
if (userFromRepo == null)
{
return(NotFound());
}
var user = Mapper.Map <UserDto>(userFromRepo);
var links = CreateLinksForUser(id, fields);
var linkedResourceToReturn = user.ShapeData(fields)
as IDictionary <string, object>;
linkedResourceToReturn.Add("links", links);
return(Ok(linkedResourceToReturn));
}
private string CreateUsersResourceUri(UserResourceParameters userResourceParameters, ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link("GetUsers",
new
{
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber - 1,
pageSize = userResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link("GetUsers",
new
{
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber + 1,
pageSize = userResourceParameters.PageSize
}));
default:
return(_urlHelper.Link("GetUsers",
new
{
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber,
pageSize = userResourceParameters.PageSize
}));
}
}
public async Task <PagedList <AppUser> > GetUsers(UserResourceParameters paginationParameters)
{
IQueryable <AppUser> beforePaging = //(!string.IsNullOrEmpty(paginationParameters.Rol))?
// await _userManager.GetUsersForClaimAsync(new Claim(Helpers.Constants.Strings.JwtClaimIdentifiers.Rol, paginationParameters.Rol)) :
_userManager.Users.OrderBy(u => u.Email);
if (!string.IsNullOrEmpty(paginationParameters.SearchQuery))
{
var searchForWhereClause = paginationParameters.SearchQuery.Trim().ToLowerInvariant();
beforePaging = beforePaging.Where(a => (a.FirstName + " " + a.LastName + " " + a.Email + " " + a.PhoneNumber).ToLowerInvariant().Contains(searchForWhereClause));
}
if (paginationParameters.EmailConfirmed != null)
{
beforePaging = beforePaging.Where(u => u.EmailConfirmed == paginationParameters.EmailConfirmed);
}
if (!string.IsNullOrEmpty(paginationParameters.Rol))
{
beforePaging = beforePaging.Where(u =>
_dataContext.UserClaims.FirstOrDefault(c =>
c.UserId == u.Id && c.ClaimValue == paginationParameters.Rol) != null);
}
return(PagedList <AppUser> .Create(beforePaging.Include(u => u.ProfilePicture), paginationParameters.PageNumber, paginationParameters.PageSize));
}
public PagedList <User> Find(UserResourceParameters userResourceParameters)
{
if (userResourceParameters == null)
{
throw new ArgumentNullException(nameof(userResourceParameters));
}
var collection = _context.Users as IQueryable <User>;
if (!string.IsNullOrWhiteSpace(userResourceParameters.SearchQuery))
{
var searchQuery = userResourceParameters.SearchQuery.Trim();
collection = collection.Where(a => a.Name.Contains(searchQuery) ||
a.Email.Contains(searchQuery) ||
(a.Id != null && a.Id.ToString().Contains(searchQuery)));
}
if (!string.IsNullOrWhiteSpace(userResourceParameters.OrderBy))
{
// get property mapping dictionary
var authorPropertyMappingDictionary =
_propertyMappingService.GetPropertyMapping <UserDto, User>();
collection = collection.ApplySort(userResourceParameters.OrderBy,
authorPropertyMappingDictionary);
}
return(PagedList <User> .Create(collection,
userResourceParameters.PageNumber,
userResourceParameters.PageSize));
}
public PagedList <User> GetUsers([FromQuery] UserResourceParameters userResourceParameters)
{
var collectionBeforePaging =
_context.Users.ApplySort(userResourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <UserDto, User>());
return(PagedList <User> .Create(collectionBeforePaging, userResourceParameters.PageNumber, userResourceParameters.PageSize));
}
public async Task GetAll_ResourceParametersNull_ThrowsException()
{
// arrange
UserResourceParameters userResourceParameters = null;
// act & assert
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await _userRepository.GetAll(userResourceParameters);
});
}
public PagedList <User> GetUsers(
UserResourceParameters userResourceParameters)
{
var collectionBeforePaging =
_context.Users.ApplySort(userResourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <UserDto, User>());
//Search using search query (Firstname and Lastname)
if (!string.IsNullOrEmpty(userResourceParameters.SearchQuery))
{
//trim & ignore casing
var searhcQueryForWhereClause = userResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(a => a.FirstName.ToLowerInvariant().Contains(searhcQueryForWhereClause) ||
a.LastName.ToLowerInvariant().Contains(searhcQueryForWhereClause));
}
//Filter suing firstname
if (!string.IsNullOrEmpty(userResourceParameters.FirstName))
{
//trim & ignore casing
var firstnameForWhereClause = userResourceParameters.FirstName
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(a => a.FirstName.ToLowerInvariant() == firstnameForWhereClause);
}
//filter using lastname
if (!string.IsNullOrEmpty(userResourceParameters.LastName))
{
//trim & ignore casing
var lastnameForWhereClause = userResourceParameters.LastName
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(a => a.LastName.ToLowerInvariant() == lastnameForWhereClause);
}
//filter using imei
if (!string.IsNullOrEmpty(userResourceParameters.IMEI))
{
//trim & ignore casing
var imeiForWhereClause = userResourceParameters.IMEI
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(a => a.IMEI.ToLowerInvariant() == imeiForWhereClause);
}
return(PagedList <User> .Create(collectionBeforePaging,
userResourceParameters.PageNumber,
userResourceParameters.PageSize));
}
private bool CheckGetAllParameters(UserResourceParameters userResourceParameters)
{
if (userResourceParameters == null)
{
throw new ArgumentNullException(nameof(userResourceParameters));
}
if (string.IsNullOrWhiteSpace(userResourceParameters.Strength))
{
return(false);
}
return(true);
}
public async Task GetAll_OutOfRangeResourceParameters_ReturnsEmptyCollection()
{
// arrange
var userResourceParameters = new UserResourceParameters()
{
Strength = "-500"
};
// act
var users = await _userRepository.GetAll(userResourceParameters);
// assert
Assert.Empty(users);
}
public async Task GetAll_InvalidResourceParameters_ThrowsException()
{
// arrange
var userResourceParameters = new UserResourceParameters()
{
Strength = "abc"
};
// act
await Assert.ThrowsAsync <KeyNotFoundException>(async() =>
{
await _userRepository.GetAll(userResourceParameters);
});
}
//[NoCache]
//[ProducesResponseType(typeof(List<User>), 200)]
//[ProducesResponseType(typeof(ApiResponse), 400)]
public async Task <ActionResult> GetUsers(UserResourceParameters usersResourceParameters)
{
try
{
var users = await _UsersRepository.GetUsersAsync(usersResourceParameters);
return(Ok(users));
}
catch (Exception exp)
{
_Logger.LogError(exp.Message);
return(BadRequest(new ApiResponse {
Status = false
}));
}
}
public PagedList <User> GetAllPagination(UserResourceParameters resourceParams)
{
var collectionBeforPaging = _userManager.Users
.OrderBy(u => u.UserName)
.AsQueryable();
//searh if exists
if (!string.IsNullOrEmpty(resourceParams.SearchQuery))
{
collectionBeforPaging = collectionBeforPaging
.Where(a => a.NormalizedUserName.Contains(resourceParams.SearchQuery.ToUpper()) ||
a.NormalizedEmail.Contains(resourceParams.SearchQuery.ToUpper()));
}
return(PagedList <User> .Create(collectionBeforPaging, resourceParams.PageNumber, resourceParams.PageSize));
}
private string CreateUsersResouceUri(
UserResourceParameters userResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link("GetUsers",
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
firstname = userResourceParameters.FirstName,
lastname = userResourceParameters.LastName,
imei = userResourceParameters.IMEI,
pageNumber = userResourceParameters.PageNumber - 1,
pageSize = userResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link("GetUsers",
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
firstname = userResourceParameters.FirstName,
lastname = userResourceParameters.LastName,
imei = userResourceParameters.IMEI,
pageNumber = userResourceParameters.PageNumber + 1,
pageSize = userResourceParameters.PageSize
}));
case ResourceUriType.Current:
default:
return(_urlHelper.Link("GetUsers",
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
firstname = userResourceParameters.FirstName,
lastname = userResourceParameters.LastName,
imei = userResourceParameters.IMEI,
pageNumber = userResourceParameters.PageNumber,
pageSize = userResourceParameters.PageSize
}));
}
}
public List <ApplicationUser> GetUsersUnpaged(UserResourceParameters userResourceParameters)
{
var appUsers = _userManager.Users
.Include(u => u.UserRoles).ThenInclude(ur => ur.Role).AsQueryable();
var collection = appUsers.OrderBy($"{userResourceParameters.OrderBy}").AsQueryable();
if (!string.IsNullOrEmpty(userResourceParameters.SearchQuery))
{
var searchQueryForWhereClause = userResourceParameters.SearchQuery.Trim().ToLowerInvariant();
collection = collection
.Where(u => u.Email.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
u.UserName.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(collection.ToList());
}
public PagedList <ApplicationUser> GetUsers(UserResourceParameters userResourceParameters)
{
var appUsers = _userManager.Users.Include(u => u.UserRoles).ThenInclude(ur => ur.Role).AsQueryable();
var collectionBeforePaging = appUsers.OrderBy($"{userResourceParameters.OrderBy}").AsQueryable();
if (!string.IsNullOrEmpty(userResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = userResourceParameters.SearchQuery.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(u => u.Email.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
u.UserName.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(PagedList <ApplicationUser> .Create(collectionBeforePaging, userResourceParameters.PageNumber, userResourceParameters.PageSize));
}
public async Task <List <User> > GetAll(UserResourceParameters userResourceParameters)
{
if (!CheckGetAllParameters(userResourceParameters))
{
return(await GetAll());
}
var collection = Context.Users as IQueryable <User>;
if (!int.TryParse(userResourceParameters.Strength.Trim(), out var moduleId))
{
throw new KeyNotFoundException();
}
collection = collection.Where(u => u.Strengths.Any(s => s.ModuleId == moduleId));
return(await collection.Include(u => u.Strengths).ToListAsync());
}
public async Task GetALL_ResourceParameters_ReturnsUsersForStrength()
{
// arrange
var userResourceParameters = new UserResourceParameters()
{
Strength = "-1"
};
// act
var users = await _userRepository.GetAll(userResourceParameters);
var strengthsOfUser = users.First().Strengths;
var strengthOfModul = strengthsOfUser.Single(s => s.ModuleId == -1);
// assert
Assert.NotEmpty(users);
Assert.NotNull(strengthOfModul);
}
public IActionResult GetUsersUnpaged(UserResourceParameters userResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <UserDTO, ApplicationUser>(userResourceParameters.Fields))
{
return(BadRequest());
}
if (!_propertyMappingService.ValidMappingExistsFor <UserDTO, ApplicationUser>(userResourceParameters.OrderBy))
{
return(BadRequest());
}
var usersFromRepo = _userRepository.GetUsersUnpaged(userResourceParameters);
var users = Mapper.Map <IEnumerable <UserDTO> >(usersFromRepo);
var shapedData = users.ShapeData(userResourceParameters.Fields);
return(Ok(shapedData));
}
public IActionResult GetUsers([FromQuery] UserResourceParameters userResourceParameters)
{
var usersFromRepo = _userRepository.GetUsers(userResourceParameters);
if (usersFromRepo == null)
{
return(NotFound());
}
var previousPageLink = usersFromRepo.HasPrevious ?
CreateUsersResourceUri(userResourceParameters,
ResourceUriType.PreviousPage) : null;
var x = CreateUsersResourceUri(userResourceParameters,
ResourceUriType.NextPage);
var nextPageLink = usersFromRepo.HasNext ?
CreateUsersResourceUri(userResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = usersFromRepo.TotalCount,
pageSize = usersFromRepo.PageSize,
currentPage = usersFromRepo.CurrentPage,
totalPages = usersFromRepo.TotalPages,
previousPageLink = previousPageLink,
nextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination",
Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var userDtos = _mapper.Map <IEnumerable <UserDto> >(usersFromRepo);
Users users = new Users
{
UserDtos = userDtos
};
users.TotalCount = usersFromRepo.TotalCount;
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <UserDto> > > GetUsers(
[FromQuery] UserResourceParameters userResourceParameters)
{
try
{
var users = await _userRepository.GetAll(userResourceParameters);
if (users == null)
{
return(NotFound());
}
return(Ok(_mapper.Map <IEnumerable <UserDto> >(users)));
}
catch (Exception)
{
return(NotFound());
}
}
public async Task <IActionResult> GetUsers(UserResourceParameters resourceParameters)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var users = await _usersRepository.GetUsers(resourceParameters);
var prevLink = users.HasPrevious
? _resourceUriHelper.CreateResourceUri(resourceParameters, ResourceUriType.PrevoiusPage, nameof(GetUsers)) : null;
var nextLink = users.HasNext
? _resourceUriHelper.CreateResourceUri(resourceParameters, ResourceUriType.NextPage, nameof(GetUsers)) : null;
Response.Headers.Add("X-Pagination", Helpers.PaginationMetadata.GeneratePaginationMetadata(users, resourceParameters, prevLink, nextLink));
List <UserDto> userDtos = new List <UserDto>();
foreach (var user in users)
{
var userDto = Mapper.Map <UserDto>(user);
var claims = await _userManager.GetClaimsAsync(user);
foreach (var c in claims)
{
if (c.Type == Helpers.Constants.Strings.JwtClaimIdentifiers.Rol)
{
userDto.Roles.Add(c.Value);
}
if (c.Type == Helpers.Constants.Strings.JwtClaimIdentifiers.CustomerId ||
c.Type == Helpers.Constants.Strings.JwtClaimIdentifiers.DriverId ||
c.Type == Helpers.Constants.Strings.JwtClaimIdentifiers.AdminId)
{
userDto.Ids[c.Type] = c.Value;
}
}
userDto.ProfilePictureId = user.ProfilePicture?.Id;
userDtos.Add(userDto);
}
return(Ok(userDtos));
}
public PagedList <User> GetAll(UserResourceParameters resourceParameters)
{
var collectionBeforePaging = context.Users.ApplySort(resourceParameters.OrderBy, propertyMappingService.GetPropertyMapping <User>());
if (!string.IsNullOrEmpty(resourceParameters.Name))
{
var titleForWhereClause = resourceParameters.Name
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging.Where(x => x.FirstName.ToLowerInvariant() == titleForWhereClause);
}
if (!string.IsNullOrEmpty(resourceParameters.SearchQuery))
{
var searchQueryWhereClause = resourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging.Where(a => a.FirstName.ToLowerInvariant().Contains(searchQueryWhereClause) ||
a.LastName.ToLowerInvariant().Contains(searchQueryWhereClause) || a.Email.ToLowerInvariant().Contains(searchQueryWhereClause));
}
return(PagedList <User> .Create(collectionBeforePaging, resourceParameters.PageNumber, resourceParameters.PageSize));
}
//Todo: Create the Delete with return 204 No Content
private string CreateUsersResourceUri(
UserResourceParameters userResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(Url.Link(nameof(GetUsers),
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber - 1,
pageSize = userResourceParameters.PageSize,
searchQuery = userResourceParameters.SearchQuery
}));
case ResourceUriType.NextPage:
return(Url.Link(nameof(GetUsers),
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber + 1,
pageSize = userResourceParameters.PageSize,
searchQuery = userResourceParameters.SearchQuery
}));
default:
return(Url.Link(nameof(GetUsers),
new
{
fields = userResourceParameters.Fields,
orderBy = userResourceParameters.OrderBy,
pageNumber = userResourceParameters.PageNumber,
pageSize = userResourceParameters.PageSize,
searchQuery = userResourceParameters.SearchQuery
}));
}
}
public Task <List <User> > GetUsersAsync(UserResourceParameters authorsResourceParameters)
{
if (!string.IsNullOrEmpty(authorsResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = authorsResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
var collection = _Context.Users
.OrderBy(a => a.FirstName)
.ThenBy(a => a.LastName).Include(c => c.Department)
.AsQueryable();
collection = collection
.Where(a => a.FirstName.ToLowerInvariant().Contains(searchQueryForWhereClause) ||
a.LastName.ToLowerInvariant().Contains(searchQueryForWhereClause));
return(collection.ToListAsync());
}
return(_Context.Users.OrderBy(c => c.LastName)
.Include(c => c.Department).ToListAsync());
}
public async Task <ActionResult <LinkedCollectionResourceWrapperDto <UserIdentifierDto> > > GetUsersByIdentifier(
[FromQuery] UserResourceParameters userResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <UserIdentifierDto>
(userResourceParameters.OrderBy))
{
return(BadRequest());
}
var query = new UsersIdentifierQuery(
userResourceParameters.OrderBy,
userResourceParameters.PageNumber,
userResourceParameters.PageSize,
userResourceParameters.SearchTerm);
_logger.LogInformation(
"----- Sending query: UsersIdentifierQuery");
var queryResult = await _mediator.Send(query);
if (queryResult == null)
{
return(BadRequest("Query not created"));
}
// Prepare pagination data for response
var paginationMetadata = new
{
totalCount = queryResult.RecordCount,
pageSize = userResourceParameters.PageSize,
currentPage = userResourceParameters.PageNumber,
totalPages = queryResult.PageCount
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
return(Ok(queryResult));
}
