public IQueryable <User> Get(UserQueryOptions queryOptions)
{
var query = GetAll();
if (queryOptions.IncludeTokens)
{
query = query.Include(x => x.Tokens);
}
if (queryOptions.IncludeClaims)
{
query = query.Include(x => x.Claims);
}
if (queryOptions.IncludeUserRoles)
{
query = query.Include(x => x.UserRoles);
}
if (queryOptions.IncludeRoles)
{
query = query.Include("UserRoles.Role");
}
if (queryOptions.AsNoTracking)
{
query = query = query.AsNoTracking();
}
return(query);
}
public ViewResult List(FilterGridDTO values)
{
var gridBuilder = new UserGridBuilder(HttpContext.Session, values, nameof(AbsenceCoverageMS.Models.DomainModels.User.FirstName));
var options = new UserQueryOptions
{
Include = "Campus",
OrderByDirection = gridBuilder.CurrentGrid.SortDirection,
};
options.Search(gridBuilder);
options.Filter(gridBuilder);
options.Sort(gridBuilder);
var model = new UserListViewModel
{
Grid = gridBuilder.CurrentGrid,
Users = BuildQuery(options).ToList(),
Campuses = data.Campuses.List()
};
model.TotalPages = gridBuilder.GetTotalPages(model.Users.Count());
model.Users = model.Users.Skip((gridBuilder.CurrentGrid.PageNumber - 1) * gridBuilder.CurrentGrid.PageSize).Take(gridBuilder.CurrentGrid.PageSize);
return(View(model));
}
public async Task Get_ShouldReturnListOfUsers()
{
// Arrange
var url = HostServer.Url + "api/users/";
var accountService = Container.Resolve <IAccountService>();
var account = await accountService.GetAccounts().FirstAsync();
var userQueryOptions = new UserQueryOptions();
userQueryOptions.BuyerAccountIds.Add(account.BuyerAccountId);
var totalCount = await Container.Resolve <IUserService>().GetUsers(userQueryOptions).CountAsync();
var data = new
{
BuyerAccountUuid = account.BuyerAccountUuid,
PageNumber = 2,
PageSize = 5
};
// Act
var response = await url.SetQueryParams(data)
.WithOAuthBearerToken(await TestHelper.Token)
.GetAsync()
.ReceiveJson();
// Assert
Assert.That(response, Is.Not.Null);
Assert.That(response.Data, Is.Not.Null);
Assert.That(response.TotalItemCount, Is.EqualTo(totalCount));
}
public async Task <IActionResult> Index(int pageNumber = 0, int pageSize = 0)
{
var scope = AuthenticationService.GetScope(User, User.IsSuperAdmin());
var queryOptions = new UserQueryOptions(scope, pageSize, pageNumber);
var pagedItems = await UserService.GetUsers(queryOptions);
return(Ok(pagedItems));
}
public async Task Index()
{
var user = new User()
{
Id = Guid.NewGuid(),
FirstName = "1",
LastName = "2",
Email = "3",
UserName = "******",
OrganisationId = Guid.NewGuid(),
OrganisationName = "5",
BranchId = Guid.NewGuid(),
BranchName = "6",
Scope = Scope.Branch,
UserTypeId = Guid.NewGuid(),
};
var pagedItems = new PagedItems <User>()
{
TotalItems = 1,
Items = new List <User>()
{
user
}
};
var service = new Mock <IUserService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
UserQueryOptions queryOptions = null;
service.Setup(c => c.GetUsers(It.IsAny <UserQueryOptions>()))
.Callback((UserQueryOptions options) => queryOptions = options)
.ReturnsAsync(pagedItems);
var controller = new UsersController(service.Object, authService.Object);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.Index(2, 15);
Assert.Equal(Scope.Branch, queryOptions.Scope.Scope);
Assert.Equal(15, queryOptions.PageOptions.Size);
Assert.Equal(2, queryOptions.PageOptions.Number);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <PagedItems <User> >(okResult.Value);
Assert.Same(pagedItems, returnValue);
}
public List <UserDTO> GetUsers(UserQueryOptions query)
{
var users = _dispatcher.Dispatch(new GetUsersQuery
{
IncludeClaims = query.IncludeClaims,
IncludeUserRoles = query.IncludeUserRoles,
IncludeRoles = query.IncludeRoles,
AsNoTracking = query.AsNoTracking,
}).Select(x => new UserDTO
{
Id = x.Id,
UserName = x.UserName,
})
.ToList();
return(users);
}
public void ReturnGetUsers_WhenAdmin_CallsGetUsers()
{
var queryOptions = new UserQueryOptions
{
Page = 1
};
var userHelper = A.Fake <IUserHelper>();
A.CallTo(() => userHelper.IsAdmin(A <HttpContext> .Ignored)).Returns(true);
var userRepository = A.Fake <IUserRepository>();
var usersController = new UsersController(userRepository, userHelper, null);
var response = usersController.GetUsers(queryOptions);
A.CallTo(() => userRepository.GetUsers(queryOptions)).MustHaveHappenedOnceExactly();
A.CallTo(() => userRepository.HasMore(queryOptions)).MustHaveHappenedOnceExactly();
}
protected override void Configure()
{
CreateMap <UserQueryViewModel, UserQueryOptions>()
.ConstructUsing(ctx =>
{
var source = (UserQueryViewModel)ctx.SourceValue;
var retVal = new UserQueryOptions();
if (source.UserId.HasValue)
{
// retrieve all users under specified user's buyer accounts where the user is AgencyAdministrator
var userBuyerRoles = ctx.Resolve <IUserService>().GetUserBuyerRoles(source.UserId.Value)
.Where(x => x.RoleName == StandardRole.Administrator)
.ToList();
foreach (var userBuyerRole in userBuyerRoles)
{
retVal.BuyerAccountIds.Add(userBuyerRole.BuyerAccountId);
}
}
if (source.BuyerAccountUuid.HasValue)
{
// retrieve all users under specified buyer account
var buyerAccountId = ctx.Resolve <IAccountService>().GetAccount(source.BuyerAccountUuid.Value).WaitAndUnwrapException().BuyerAccountId;
if (!retVal.BuyerAccountIds.Contains(buyerAccountId))
{
retVal.BuyerAccountIds.Add(buyerAccountId);
}
}
if (source.UserId.HasValue && !source.BuyerAccountUuid.HasValue && retVal.BuyerAccountIds.Count == 0)
{
// note: just to make sure specified user is not any admin of any buyer account
// the service method should return empty user list
retVal.BuyerAccountIds.Add(-1);
}
return(retVal);
});
}
public async Task <PagedItems <User> > GetUsers(UserQueryOptions queryOptions)
{
var query = from user in ScopeQuery.GetUserEntityQuery(_context, queryOptions.Scope)
join branch in _context.Branch
on user.BranchId equals branch.Id
join organisation in _context.Organisation
on branch.OrganisationId equals organisation.Id
select new User()
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
UserName = user.UserName,
BranchId = user.BranchId,
BranchName = branch.Name,
OrganisationId = organisation.Id,
OrganisationName = organisation.Name,
Scope = user.Scope,
EmailConfirmed = user.EmailConfirmed,
LockoutEnd = user.LockoutEnd,
UserTypeId = user.UserTypeId,
Config = user.Config,
};
//Apply filters ----------------------------------------------------------------------------------------
if (!string.IsNullOrWhiteSpace(queryOptions.FirstName))
{
query = query.Where(m => EF.Functions.Like(m.FirstName, queryOptions.FirstName));
}
if (!string.IsNullOrWhiteSpace(queryOptions.LastName))
{
query = query.Where(m => EF.Functions.Like(m.LastName, queryOptions.LastName));
}
if (!string.IsNullOrWhiteSpace(queryOptions.Email))
{
query = query.Where(m => EF.Functions.Like(m.Email, queryOptions.Email));
}
if (queryOptions.EmailConfirmed.HasValue)
{
query = query.Where(m => m.EmailConfirmed == queryOptions.EmailConfirmed);
}
if (queryOptions.OrganisationId.Any())
{
query = query.Where(m => queryOptions.OrganisationId.Contains(m.OrganisationId));
}
if (queryOptions.BranchId.Any())
{
query = query.Where(m => queryOptions.BranchId.Contains(m.BranchId));
}
if (queryOptions.UserTypeId.Any())
{
query = query.Where(m => queryOptions.UserTypeId.Contains(m.UserTypeId));
}
//------------------------------------------------------------------------------------------------------
var pagedItems = new PagedItems <User>();
//Get total items
pagedItems.TotalItems = await query.CountAsync();
//Ordering
query = query.OrderBy(queryOptions.SortOptions.Column, queryOptions.SortOptions.Direction);
//Paging
pagedItems.Items = await query.TakePage(queryOptions.PageOptions.Number, queryOptions.PageOptions.Size).ToListAsync();
return(pagedItems);
}
public async Task GetUsers()
{
var options = TestHelper.GetDbContext("GetUsers");
var userDetailed1 = TestHelper.InsertUserDetailed(options);
var userDetailed2 = TestHelper.InsertUserDetailed(options);
var user1 = new UserEntity()
{
Id = Guid.NewGuid(),
FirstName = "Bob",
LastName = "Jones",
Email = "*****@*****.**",
Scope = Scope.Organisation,
BranchId = userDetailed1.Branch.Id,
UserTypeId = Guid.NewGuid(),
};
var user2 = new UserEntity()
{
Id = Guid.NewGuid(),
FirstName = "Jack",
LastName = "Reacher",
Email = "*****@*****.**",
Scope = Scope.Organisation,
BranchId = userDetailed1.Branch.Id,
UserTypeId = Guid.NewGuid(),
};
var user3 = new UserEntity()
{
Id = Guid.NewGuid(),
FirstName = "Joe",
LastName = "Soap",
Email = "*****@*****.**",
Scope = Scope.Organisation,
BranchId = userDetailed2.Branch.Id,
UserTypeId = Guid.NewGuid(),
};
using (var context = new DataContext(options))
{
context.Users.Add(user1);
context.Users.Add(user3);
context.Users.Add(user2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var userManager = TestHelper.MockUserManager(context.Users.ToList());
var auditService = new AuditServiceMock();
var service = new UserService(context, userManager.Object, auditService);
//When
var scope = TestHelper.GetScopeOptions(userDetailed1, Scope.Organisation);
var queryOptions = new UserQueryOptions(scope, 10, 1);
var users = await service.GetUsers(queryOptions);
//Then
Assert.Equal(3, users.TotalItems);
Assert.Equal(3, users.Items.Count());
var actual1 = users.Items.ToArray()[0];
Assert.Equal(userDetailed1.User.Id, actual1.Id);
var actual2 = users.Items.ToArray()[1];
Assert.Equal(user1.Id, actual2.Id);
Assert.Equal(user1.FirstName, actual2.FirstName);
Assert.Equal(user1.LastName, actual2.LastName);
Assert.Equal(user1.Email, actual2.Email);
Assert.Equal(user1.Scope, actual2.Scope);
Assert.Equal(user1.BranchId, actual2.BranchId);
Assert.Equal(user1.UserTypeId, actual2.UserTypeId);
Assert.Equal(userDetailed1.Branch.Name, actual2.BranchName);
Assert.Equal(userDetailed1.Organisation.Id, actual2.OrganisationId);
Assert.Equal(userDetailed1.Organisation.Name, actual2.OrganisationName);
var actual3 = users.Items.ToArray()[2];
Assert.Equal(user2.Id, actual3.Id);
}
}
