// GET: Employee
public async Task <IActionResult> Index()
{
////List<Department> departments = await _context.Set<Department>()
//// .Where(d => d.Employees.Any(e => e.EmployeeName == "Tanvir Ahmad")).ToListAsync();
////Specification<Department> specification = new Specification<Department>();
////specification.Conditions.Add(d => d.Employees.Any(e => e.EmployeeName == "Tanvir Ahmad"));
////List<string> departments1 = await _repository.GetListAsync(specification, d => d.Name);
////PaginatedList<Employee> paginatedList = await _repository.GetQueryable<Employee>().ToPaginatedListAsync(1, 10);
IQueryable <EmployeeDto> queryable = _repository.GetQueryable <Employee>()
.Where(e => e.EmployeeName.Contains("Ta")).Select(e => new EmployeeDto
{
EmployeeName = e.EmployeeName,
DepartmentName = e.DepartmentName
}).OrderBy(e => e.DepartmentName);
PaginationSpecification <Employee> specification = new PaginationSpecification <Employee>();
specification.Conditions.Add(e => e.EmployeeName.Contains("Ta"));
specification.Includes = q => q.Include(e => e.Department);
specification.PageIndex = 1;
specification.PageSize = 2;
PaginatedList <Employee> paginatedList1 = await _repository.GetPaginatedListAsync(specification);
List <Employee> lists = _repository.GetQueryable <Employee>().ToList();
return(View(lists));
}
public async Task <Result <DataTableResult <UserAttributeTableModel> > > Get(string userId, DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(DataTableRequest).Name} model");
return(Result.Fail <DataTableResult <UserAttributeTableModel> >(validationResult.Errors));
}
PaginationSpecification <UserAttributeEntity, UserAttributeTableModel> paginationSpecification = new PaginationSpecification <UserAttributeEntity, UserAttributeTableModel>();
paginationSpecification.AddFilter(x => x.UserId == userId);
paginationSpecification.AddSelect(x => new UserAttributeTableModel(
x.Id,
x.Key,
x.Value));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <UserAttributeTableModel> paginatedData = await _userAttributeRepository.GetPaginated(paginationSpecification);
DataTableResult <UserAttributeTableModel> dataTableResult = new DataTableResult <UserAttributeTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: paginatedData.Count,
recordsFilterd: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public Result <DataTableResult <EmailTableModel> > Get(DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <EmailTableModel> >(validationResult.Errors));
}
PaginationSpecification <EmailEntity, EmailTableModel> paginationSpecification = new PaginationSpecification <EmailEntity, EmailTableModel>();
paginationSpecification.AddSelect(x => new EmailTableModel(
x.Id,
x.Type.GetDescription()));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <EmailTableModel> paginatedData = _emailRepository.GetPaginated(paginationSpecification);
DataTableResult <EmailTableModel> dataTableResult = new DataTableResult <EmailTableModel>(
draw: dataTableRequest.Draw,
recordsFilterd: paginatedData.Count,
recordsTotal: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public Result <DataTableResult <PermissionTableModel> > Get(DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <PermissionTableModel> >(validationResult.Errors));
}
PaginationSpecification <PermissionEntity, PermissionTableModel> paginationSpecification =
new PaginationSpecification <PermissionEntity, PermissionTableModel>();
if (!string.IsNullOrEmpty(dataTableRequest.Search))
{
paginationSpecification.AddFilter(x => x.Name.ToUpper().Contains(dataTableRequest.Search.ToUpper()));
}
paginationSpecification.AddSelect(x => new PermissionTableModel(
x.Id,
x.Name));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <PermissionTableModel> paginatedData = _permissionRepository.GetPaginated(paginationSpecification);
DataTableResult <PermissionTableModel> dataTableResult = new DataTableResult <PermissionTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: paginatedData.Count,
recordsFilterd: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public Result <DataTableResult <SessionViewModel> > GetSessions(string userId, DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invlid DataTableRequest");
return(Result.Fail <DataTableResult <SessionViewModel> >(validationResult.Errors));
}
PaginationSpecification <SessionEntity, SessionViewModel> specification = new PaginationSpecification <SessionEntity, SessionViewModel>();
specification.AddFilter(x => x.UserId == userId);
specification.AppalyPaging(request.Start, request.Length);
specification.AddSelect(x => new SessionViewModel(
x.Id,
x.Ip,
x._CreatedDate,
x.LastAccess));
PaginatedData <SessionViewModel> paginatedData = _sessionRepository.GetPaginated(specification);
DataTableResult <SessionViewModel> dataTableResult = new DataTableResult <SessionViewModel>(
draw: request.Draw,
recordsTotal: paginatedData.Count,
recordsFilterd: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public async Task <PaginatedList <EmployeeDetailsDto> > GetListAsync(int pageNumber, int pageSize)
{
pageNumber.ThrowIfOutOfRange(1, 50, nameof(pageNumber));
pageNumber.ThrowIfOutOfRange(1, 50, nameof(pageSize));
Expression <Func <Employee, EmployeeDetailsDto> > selectExpression = e => new EmployeeDetailsDto
{
EmployeeId = e.Id,
EmployeeName = e.Name,
DepartmentId = e.DepartmentId,
DepartmentName = e.Department.Name,
DateOfBirth = e.DateOfBirth,
Email = e.Email,
PhoneNumber = e.PhoneNumber,
IsActive = e.IsActive,
CreatedAtUtc = e.CreatedAtUtc,
LastModifiedAtUtc = e.LastModifiedAtUtc
};
PaginationSpecification <Employee> paginationSpecification = new PaginationSpecification <Employee>
{
PageIndex = pageNumber,
PageSize = pageSize
};
PaginatedList <EmployeeDetailsDto> employeeDetailsDtos = await _repository.GetPaginatedListAsync(paginationSpecification, selectExpression);
return(employeeDetailsDtos);
}
public Result <DataTableResult <UserTableModel> > GetGroupUsers(string roleId, DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <UserTableModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
BaseSpecification <RoleEntity> roleSpecification = new BaseSpecification <RoleEntity>();
roleSpecification.AddFilter(x => x.Id == roleId);
roleSpecification.AddFilter(x => x.Type == RoleTypes.Group);
bool existResult = _roleRepository.Exist(roleSpecification);
if (!existResult)
{
_logger.LogWarning($"GroupRole with id {roleId} does not exist");
return(Result.Fail <DataTableResult <UserTableModel> >("no_role", "No Role"));
}
PaginationSpecification <GroupUserEntity, UserTableModel> baseSpecification = new PaginationSpecification <GroupUserEntity, UserTableModel>();
baseSpecification.AddFilter(x => x.RoleId == roleId);
baseSpecification.AddSelect(x => new UserTableModel(
x.User.Id,
x.User.UserName,
x.Group.Name));
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.User.Id.ToUpper().Contains(search) ||
x.User.Email.ToUpper().Contains(search) ||
x.User.UserName.ToUpper().Contains(search) ||
x.User.FirstName.ToUpper().Contains(search) ||
x.User.LastName.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddInclude(x => x.User);
PaginatedData <UserTableModel> paginationData = _groupUserRepository.GetPaginated(baseSpecification);
DataTableResult <UserTableModel> result = new DataTableResult <UserTableModel>(
draw: request.Draw,
recordsTotal: paginationData.Count,
recordsFilterd: paginationData.Count,
error: null,
data: paginationData.Data);
return(Result.Ok(result));
}
/// <summary>
/// Returns a query of a paginated subsection of the original <paramref name="source"/>, paginated based on <paramref name="paginationSpecification"/>.
/// </summary>
/// <param name="source">The query of items to paginate.</param>
/// <param name="paginationSpecification">Specifies how the <paramref name="source"/> should be paginated.</param>
/// <typeparam name="T">The type of items to paginate.</typeparam>
/// <returns>A <see cref="PageQuery{T}"/> representing the paginated results.</returns>
/// <remarks>Assumes <paramref name="source.Provider"/> is able to translate and evaluate queries generated via <see cref="FGS.Linq.Expressions.QueryProviderExtensions.CreateScalarQuery{TResult}(IQueryProvider, System.Linq.Expressions.Expression{System.Func{TResult}})"/>.</remarks>
public static PageQuery <T> Paginate <T>(this IQueryable <T> source, PaginationSpecification paginationSpecification)
{
var queryOfItemsOnResultPagePlusEverAfter = source.Skip(paginationSpecification.PageNumber * paginationSpecification.PageSize);
var queryOfItemsOnResultPage = queryOfItemsOnResultPagePlusEverAfter.Take(paginationSpecification.PageSize);
var queryOfItemAfterResultPage = queryOfItemsOnResultPagePlusEverAfter.Skip(paginationSpecification.PageSize).Take(1);
var queryOfAnyItemAfterResultPage = source.Provider.CreateScalarQuery(() => queryOfItemAfterResultPage.Any());
return(new PageQuery <T>(queryOfItemsOnResultPage, paginationSpecification, queryOfAnyItemAfterResultPage));
}
/// <summary>
/// Returns a paginated subsection of the original <paramref name="items"/>, paginated based on <paramref name="paginationSpecification"/>.
/// </summary>
/// <param name="items">The items to paginate.</param>
/// <param name="paginationSpecification">Specifies how the <paramref name="items"/> should be paginated.</param>
/// <typeparam name="T">The type of items to paginate.</typeparam>
/// <returns>A page of items of type <typeparamref name="T"/>.</returns>
public static Page <T> Paginate <T>(this IEnumerable <T> items, PaginationSpecification paginationSpecification)
{
var queryOfItemsOnResultPagePlusEverAfter = items.Skip(paginationSpecification.PageNumber * paginationSpecification.PageSize);
var queryOfItemsOnResultPage = queryOfItemsOnResultPagePlusEverAfter.Take(paginationSpecification.PageSize);
var queryOfItemAfterResultPage = queryOfItemsOnResultPagePlusEverAfter.Skip(paginationSpecification.PageSize).Take(1);
var itemsOnResultPage = queryOfItemsOnResultPage.ToArray();
var hasNextPage = queryOfItemAfterResultPage.Any();
return(new Page <T>(itemsOnResultPage, paginationSpecification, hasNextPage));
}
public async Task <PaginatedList <T> > GetPaginatedListAsync <T>(
PaginationSpecification <T> specification)
where T : class
{
if (specification == null)
{
throw new ArgumentNullException(nameof(specification));
}
PaginatedList <T> paginatedList = await _dbContext.Set <T>().ToPaginatedListAsync(specification);
return(paginatedList);
}
public Result <DataTableResult <UserListViewModel> > GetAll(DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
return(Result.Fail <DataTableResult <UserListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
PaginationSpecification <AppUserEntity, UserListViewModel> baseSpecification = new PaginationSpecification <AppUserEntity, UserListViewModel>();
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.Id.ToUpper().Contains(search) ||
x.Email.ToUpper().Contains(search) ||
x.UserName.ToUpper().Contains(search) ||
x.FirstName.ToUpper().Contains(search) ||
x.LastName.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddSelect(x => new UserListViewModel(
x.Id,
x.UserName,
x.Email,
x.FirstName,
x.LastName));
PaginatedData <UserListViewModel> paginationData = _userRepository.GetPaginated(baseSpecification);
DataTableResult <UserListViewModel> result = new DataTableResult <UserListViewModel>(
draw: request.Draw,
recordsTotal: paginationData.Count,
recordsFilterd: paginationData.Count,
error: null,
data: paginationData.Data);
return(Result.Ok(result));
}
public Result <DataTableResult <GroupInviteTableModel> > Get(string groupId, DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableRequestValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <GroupInviteTableModel> >(validationResult.Errors));
}
PaginationSpecification <InviteEntity, GroupInviteTableModel> paginationSpecification =
new PaginationSpecification <InviteEntity, GroupInviteTableModel>();
paginationSpecification.AddFilter(x => x.GroupId == groupId);
if (!string.IsNullOrEmpty(dataTableRequest.Search))
{
paginationSpecification.AddFilter(x => x.Email.ToUpper().Contains(dataTableRequest.Search.ToUpper()));
}
paginationSpecification.AddSelect(x => new GroupInviteTableModel(
x.Id,
x.Email,
x.GroupRole.Name,
x.Status.ToString(),
x.ExpiresAt.ToString(DateTimeFormats.DEFAULT_DATE_TIME_FORMAT)));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <GroupInviteTableModel> paginatedData = _inviteRepository.GetPaginated(paginationSpecification);
DataTableResult <GroupInviteTableModel> dataTableResult = new DataTableResult <GroupInviteTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: paginatedData.Count,
recordsFilterd: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public Result <DataTableResult <RoleListViewModel> > GetAll(DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid DataTableRequest model");
return(Result.Fail <DataTableResult <RoleListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
PaginationSpecification <RoleEntity, RoleListViewModel> baseSpecification = new PaginationSpecification <RoleEntity, RoleListViewModel>();
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.Id.ToUpper().Contains(search) ||
x.Name.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddSelect(x => new RoleListViewModel(
x.Id,
x.Name,
x.Type.ToString()));
PaginatedData <RoleListViewModel> pagedResult = _roleRepository.GetPaginated(baseSpecification);
DataTableResult <RoleListViewModel> result = new DataTableResult <RoleListViewModel>(
draw: request.Draw,
recordsTotal: pagedResult.Count,
recordsFilterd: pagedResult.Count,
error: null,
data: pagedResult.Data);
return(Result.Ok(result));
}
public Result <DataTableResult <RoleAssignmentTableModel> > Get(string roleId, DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <RoleAssignmentTableModel> >(validationResult.Errors));
}
PaginationSpecification <RoleEntity, RoleAssignmentTableModel> paginationSpecification =
new PaginationSpecification <RoleEntity, RoleAssignmentTableModel>();
paginationSpecification.AddFilter(x => x.Id != roleId);
paginationSpecification.AddFilter(x => x.Type == Core.Data.Enums.Entity.RoleTypes.Group);
if (!string.IsNullOrEmpty(dataTableRequest.Search))
{
paginationSpecification.AddFilter(x => x.NormalizedName.Contains(dataTableRequest.Search.ToUpper()));
}
paginationSpecification.AddSelect(x => new RoleAssignmentTableModel(
x.Id,
x.Name,
x.CanBeAssignedBy.Any(c => c.RoleId == roleId)));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <RoleAssignmentTableModel> paginatedResult = _roleRepository.GetPaginated(paginationSpecification);
DataTableResult <RoleAssignmentTableModel> dataTableResult = new DataTableResult <RoleAssignmentTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: paginatedResult.Count,
recordsFilterd: paginatedResult.Count,
error: null,
data: paginatedResult.Data);
return(Result.Ok(dataTableResult));
}
public Result <DataTableResult <GroupUserTableModel> > Get(string id, DataTableRequest dataTableRequest)
{
ValidationResult validationResult = _dataTableValidator.Validate(dataTableRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid DataTableRequest model");
return(Result.Fail <DataTableResult <GroupUserTableModel> >(validationResult.Errors));
}
PaginationSpecification <GroupUserEntity, GroupUserTableModel> paginationSpecification = new PaginationSpecification <GroupUserEntity, GroupUserTableModel>();
paginationSpecification.AddFilter(x => x.GroupId == id);
if (!string.IsNullOrEmpty(dataTableRequest.Search))
{
paginationSpecification.AddFilter(x => x.User.NormalizedUserName.Contains(dataTableRequest.Search.ToUpper()));
}
paginationSpecification.AddSelect(x => new GroupUserTableModel(
x.Id,
x.User.Id,
x.User.UserName,
x.Role.Id,
x.Role.Name));
paginationSpecification.AppalyPaging(dataTableRequest.Start, dataTableRequest.Length);
PaginatedData <GroupUserTableModel> paginatedData = _groupUserRepository.GetPaginated(paginationSpecification);
DataTableResult <GroupUserTableModel> dataTableResult = new DataTableResult <GroupUserTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: paginatedData.Count,
recordsFilterd: paginatedData.Count,
error: null,
data: paginatedData.Data);
return(Result.Ok(dataTableResult));
}
public async Task <PaginatedList <TProjectedType> > GetPaginatedListAsync <T, TProjectedType>(
PaginationSpecification <T> specification,
Expression <Func <T, TProjectedType> > selectExpression)
where T : class
where TProjectedType : class
{
if (specification == null)
{
throw new ArgumentNullException(nameof(specification));
}
if (selectExpression == null)
{
throw new ArgumentNullException(nameof(selectExpression));
}
IQueryable <T> query = _dbContext.Set <T>().GetSpecifiedQuery <T>((SpecificationBase <T>)specification);
PaginatedList <TProjectedType> paginatedList = await query.Select(selectExpression)
.ToPaginatedListAsync(specification.PageIndex, specification.PageSize);
return(paginatedList);
}
/// <summary>
/// Initializes a new instance of the <see cref="PageQuery{T}"/> class.
/// </summary>
/// <param name="items">The query of the items on this page.</param>
/// <param name="paginationSpecification">The specification of how the items for this page are selected.</param>
/// <param name="hasNextPage">A query of single <see cref="bool"/> evaluating whether or not future pages are expected, given the original source and an incremented <see cref="PaginationSpecification"/>.</param>
public PageQuery(IQueryable <T> items, PaginationSpecification paginationSpecification, IQueryable <bool> hasNextPage)
{
Items = items;
PaginationSpecification = paginationSpecification;
HasNextPage = hasNextPage;
}
public PaginatedData <T> GetPaginated <T>(PaginationSpecification <GroupUserEntity, T> paginationSpecification)
{
paginationSpecification = ApplayGroupUserFilter(paginationSpecification);
return(_groupUserRepository.GetPaginated(paginationSpecification));
}
