public void QueryOrganizationUsers_Test()
{
var transactionMock = new Mock <IDbContextTransaction>();
database.Setup(d => d.BeginTransaction()).Returns(transactionMock.Object);
context.Setup(e => e.Database).Returns(database.Object);
SetupOrganizationUsersDbSet(new List <OrganizationUserEntity>(new[] {
new OrganizationUserEntity
{
OrganizationUserEntityId = 5,
OrganizationId = 1,
UserType = 2,
FirstName = "Andrei",
LastName = "Daniel",
Email = "*****@*****.**",
IsActive = true,
TransactionId = "abc0"
}
}));
var orgUserRoles = Ext.MockDbSet(new List <OrganizationUserRoleEntity> {
new OrganizationUserRoleEntity()
});
context.Setup(ctx => ctx.OrganizationUserRoles).Returns(orgUserRoles.Object);
var rolePermissions = Ext.MockDbSet(new List <RolePermissionEntity> {
});
context.Setup(ctx => ctx.RolePermissions).Returns(rolePermissions.Object);
var criteria = new QueryOrganizationUsersCriteria
{
OrganizationId = 1,
Q = "Andrei",
OrderBy = "firstName",
Direction = "asc",
Page = 1,
PageSize = 1,
UserTypes = new List <int> {
1, 2
}
};
var res = organizationUserRepository.QueryOrganizationUsers(criteria);
Assert.True(res.Result.Count > 0);
}
public Result <QueryOrganizationUsersResult> QueryOrganizationUsers(QueryOrganizationUsersCriteria criteria)
{
if (criteria == null)
{
return(new Result <QueryOrganizationUsersResult>(OrganizationUserServiceErrors.InvalidQueryParameters(nameof(criteria))));
}
if (criteria.Page == null || criteria.Page.Value <= 0)
{
criteria.Page = 1;
}
if (criteria.PageSize == null || criteria.PageSize.Value <= 0)
{
criteria.PageSize = 10;
}
string[] sortableFields = { "firstname", "lastname", "email", "username", "createdat", "islocked", "ispendingactivation", "isactive", "lastlogintime" };
if (!sortableFields.Contains(criteria.OrderBy, StringComparer.OrdinalIgnoreCase))
{
criteria.OrderBy = string.Empty;
}
if (string.IsNullOrWhiteSpace(criteria.Direction))
{
criteria.Direction = "ASC";
}
if (!criteria.Direction.ToUpper().Equals("ASC") && !criteria.Direction.ToUpper().Equals("DESC"))
{
criteria.Direction = "ASC";
}
var result = organizationUserRepository.QueryOrganizationUsers(criteria);
return(new Result <QueryOrganizationUsersResult>(result));
}
public QueryOrganizationUsersResult QueryOrganizationUsers(QueryOrganizationUsersCriteria criteria)
{
if (criteria.Page == null || criteria.PageSize == null)
{
return(null);
}
var pageSize = criteria.PageSize.Value;
var pageValue = criteria.Page.Value;
var queryable = this
.GetValidOrganizationUsers(criteria.OrganizationId);
if (criteria.UserTypes.Any())
{
queryable = queryable.Where(ou => criteria.UserTypes.Contains(ou.UserType));
}
if (!string.IsNullOrWhiteSpace(criteria.Q))
{
queryable = queryable.Where(
p => p.FirstName.Contains(criteria.Q, StringComparison.OrdinalIgnoreCase) ||
p.LastName.Contains(criteria.Q, StringComparison.OrdinalIgnoreCase) ||
p.Email != null && p.Email.Contains(criteria.Q, StringComparison.OrdinalIgnoreCase)
);
}
if (criteria.IsActive.HasValue)
{
var isActive = (bool)criteria.IsActive;
queryable = queryable.Where(p => p.IsActive == isActive);
}
if (!string.IsNullOrWhiteSpace(criteria.OrderBy))
{
bool orderByAscending = criteria.Direction.ToUpper() == "ASC";
var orderByField = criteria.OrderBy.ToLowerInvariant();
switch (orderByField)
{
case "firstname":
queryable = orderByAscending
? queryable.OrderBy(p => p.FirstName)
: queryable.OrderByDescending(p => p.FirstName);
break;
case "lastname":
queryable = orderByAscending
? queryable.OrderBy(p => p.LastName)
: queryable.OrderByDescending(p => p.LastName);
break;
case "email":
queryable = orderByAscending
? queryable.OrderBy(p => p.Email)
: queryable.OrderByDescending(p => p.Email);
break;
case "username":
queryable = orderByAscending
? queryable.OrderBy(p => p.Username)
: queryable.OrderByDescending(p => p.Username);
break;
case "createdat":
queryable = orderByAscending
? queryable.OrderBy(p => p.CreatedAt)
: queryable.OrderByDescending(p => p.CreatedAt);
break;
case "islocked":
queryable = orderByAscending
? queryable.OrderBy(p => !p.IsLocked)
: queryable.OrderByDescending(p => !p.IsLocked);
break;
case "ispendingactivation":
queryable = orderByAscending
? queryable.OrderBy(p => !p.IsPendingActivation)
: queryable.OrderByDescending(p => !p.IsPendingActivation);
break;
case "isactive":
queryable = orderByAscending
? queryable.OrderBy(p => !p.IsActive)
: queryable.OrderByDescending(p => !p.IsActive);
break;
case "lastlogintime":
queryable = orderByAscending
? queryable.OrderBy(p => p.LastLoginAt)
: queryable.OrderByDescending(p => p.LastLoginAt);
break;
}
}
//var resultQuery = queryable
// .Join(context.OrganizationUserRoles,
// organizationUser => organizationUser.OrganizationUserEntityId,
// organizationUserRoles => organizationUserRoles.OrganizationUserRoleEntityId,
// (organizationUser, organizationUserRoles) => new { organizationUser, organizationUserRoles })
// .Join(context.RolePermissions,
// rolePermission => rolePermission.organizationUserRoles.RoleId,
// r => r.RoleId,
// (rolePermission, r) => new { rolePermission, r }
// )
// ;
var count = queryable.Count();
int page = (pageValue - 1) * pageSize;
var views = queryable
.Skip(page)
.Take(pageSize)
.ToList();
var results = views.Select(p => this.mapper.Map <OrganizationUsersListModel>(p))
.ToList();
foreach (var x in results)
{
var roles = this
.GetValidOrganizationUserRoles(x.OrganizationUserId, x.OrganizationId)
.Join(context.RolePermissions,
organizationUserRoles => organizationUserRoles.RoleId,
rolePermissions => rolePermissions.RoleId,
(our, rp) => new OrganizationUserRoleCustomModel
{
RoleName = rp.RoleName,
Description = rp.Description,
IsDefault = rp.IsDefault,
DeletedAt = rp.DeletedAt,
DisplayName = rp.DisplayName
}
)
.Where(ourcm => ourcm.DeletedAt == null);
x.Roles = roles.Select(
p => this.mapper.Map <RoleListModel>(p)
).ToList();
}
var result = new QueryOrganizationUsersResult
{
Pagination = new PaginationModel(count, pageValue, pageSize),
Result = results
};
return(result);
}
