public Task <PackedList <T> > GetContracts <T>(IOrganizationRecruiter re, ContractFilters filters)
where T : RecruiterContractOutput
{
return(Repository.Queryable().ForOrganizationRecruiter(re)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Contract, T>(filters, ProjectionMapping));
}
public async Task <IActionResult> GetContractsForCustomer([FromRoute] Guid organizationId,
[FromQuery] ContractFilters filters)
{
var contracts = await _contractService.GetContracts <CustomerContractOutput>(_customer, filters);
AddPagination(filters, contracts.Total);
return(Ok(contracts.Data));
}
private static Expression <Func <Notification, bool> > WhereFilter(ContractFilters filters)
{
var expr = PredicateBuilder.True <Notification>();
return(expr);
}
public async Task <IActionResult> GetRecruitingContracts([FromRoute] Guid organizationId,
[FromQuery] ContractFilters filters)
{
var contracts = await _contractService
.GetRecruitingContracts <AgencyOwnerRecruitingContractOutput>(_rao.Value, filters);
AddPagination(filters, contracts.Total);
return(Ok(contracts.Data));
}
public Task <PackedList <T> > GetContracts <T>(IOrganizationCustomer cu, ContractFilters filters)
where T : CustomerContractOutput
{
return(Repository.Queryable().ForOrganizationCustomer(cu)
.Where(x => x.Project.Proposal != null && x.Project.Proposal.Status == ProposalStatus.Accepted)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Contract, T>(filters, ProjectionMapping));
}
private static Expression <Func <Contract, bool> > WhereFilter(ContractFilters filters)
{
var expr = PredicateBuilder.True <Contract>();
if (filters.CustomerId.HasValue)
{
expr = expr.And(x => x.CustomerId == filters.CustomerId);
}
if (filters.CustomerOrganizationId.HasValue)
{
expr = expr.And(x => x.BuyerOrganizationId == filters.CustomerOrganizationId);
}
if (filters.ProjectManagerId.HasValue)
{
expr = expr.And(x => x.ProjectManagerId == filters.ProjectManagerId);
}
if (filters.ProjectManagerOrganizationId.HasValue)
{
expr = expr.And(x => x.ProjectManagerOrganizationId == filters.ProjectManagerOrganizationId);
}
if (filters.AccountManagerId.HasValue)
{
expr = expr.And(x => x.AccountManagerId == filters.AccountManagerId);
}
if (filters.AccountManagerOrganizationId.HasValue)
{
expr = expr.And(x => x.AccountManagerOrganizationId == filters.AccountManagerOrganizationId);
}
if (filters.ProjectId.HasValue)
{
expr = expr.And(x => x.ProjectId == filters.ProjectId);
}
if (filters.ContractorId.HasValue)
{
expr = expr.And(x => x.ContractorId == filters.ContractorId);
}
if (filters.ContractorOrganizationId.HasValue)
{
expr = expr.And(x => x.ContractorOrganizationId == filters.ContractorOrganizationId);
}
if (filters.Statuses.Any())
{
expr = expr.And(x => filters.Statuses.Contains(x.Status));
}
return(expr);
}
public static IQueryable <Contract> ApplyWhereFilters(this IQueryable <Contract> entities,
ContractFilters filters)
{
return(entities.Where(WhereFilter(filters)));
}
public Task <PackedList <T> > GetRecruitingContracts <T>(IRecruitingAgencyOwner ao, ContractFilters filters) where T : AgencyOwnerRecruitingContractOutput
{
return(Repository.Queryable().ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Contract, T>(filters, ProjectionMapping));
}
