public async Task GivenValidRequest_WhenAgencyIsInQuery_FiltersByAgency()
{
// Arrange
var searchRequest = new EmployeeSalarySearchRequestDto(agency: nameof(EmployeeAgency.Redding));
var query = new GetEmployeeSalariesQuery(searchRequest, TestUri, default);
var handler = new GetEmployeeSalariesQueryHandler(Context);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.Results.ShouldNotBeNull();
result.Results.ShouldNotBeEmpty();
result.ShouldBeOfType <OpenReddingSearchResultAggregate <EmployeeSalarySearchResultDto> >();
result.Count.ShouldBe(2);
result.Results.ShouldBeOfType <List <EmployeeSalarySearchResultDto> >();
result.Results.ShouldContain(e => e.Name == "John Smith");
result.Results.FirstOrDefault(e => e.Name == "John Smith")?.JobTitle.ShouldBe("Software Engineer");
result.Results.FirstOrDefault(e => e.Name == "John Smith")?.Agency.ShouldBe(nameof(EmployeeAgency.Redding));
result.Results.FirstOrDefault(e => e.Name == "John Smith")?.Status.ShouldBe(EmployeeStatus.FullTime.ToFriendlyString());
result.Results.ShouldContain(e => e.Name == "Mary Smith");
result.Results.FirstOrDefault(e => e.Name == "Mary Smith")?.JobTitle.ShouldBe("Software Engineering Manager");
result.Results.FirstOrDefault(e => e.Name == "Mary Smith")?.Agency.ShouldBe(nameof(EmployeeAgency.Redding));
result.Results.FirstOrDefault(e => e.Name == "Mary Smith")?.Status.ShouldBe(EmployeeStatus.FullTime.ToFriendlyString());
}
public async Task GivenValidRequest_WhenSearchQueryDoesNotFindMatch_ReturnsEmptyResultList()
{
// Arrange
var searchRequest = new EmployeeSalarySearchRequestDto(name: "This Employee Doesn't Exist!");
var query = new GetEmployeeSalariesQuery(searchRequest, TestUri, default);
var handler = new GetEmployeeSalariesQueryHandler(Context);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <OpenReddingSearchResultAggregate <EmployeeSalarySearchResultDto> >();
result.Results.ShouldBeEmpty();
}
public async Task GivenValidRequest_WhenSearchQueryOrdersByNameDescending_ReturnsOrderedDescendingResultList()
{
// Arrange
var searchRequest = new EmployeeSalarySearchRequestDto(name: "Joe", sortField: nameof(SalarySortField.Name), sortBy: nameof(SalarySortByOption.Descending));
var query = new GetEmployeeSalariesQuery(searchRequest, TestUri, default);
var handler = new GetEmployeeSalariesQueryHandler(Context);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <OpenReddingSearchResultAggregate <EmployeeSalarySearchResultDto> >();
result.Results.ShouldBeOfType <List <EmployeeSalarySearchResultDto> >();
result.Results.ShouldNotBeEmpty();
result.Count.ShouldBe(2);
result.Results.First()?.Name.ShouldBe("Joe Schmoe");
result.Results.ShouldContain(e => e.Name == "Joey Mckenzie");
}
public static SalariesState ReduceLoadEmployeeSalariesOnSearchClickedAction(SalariesState state, LoadEmployeesOnSearchClickedAction action)
{
if (state.SearchRequest is null)
{
return(new SalariesState(false, null, true, state.SalaryResults, state.SalaryDetail, new EmployeeSalarySearchRequestDto(name: action.Name, jobTitle: action.JobTitle)));
}
var updatedSearchRequest = new EmployeeSalarySearchRequestDto(
name: action.Name,
jobTitle: action.JobTitle,
agency: state.SearchRequest.Agency,
status: state.SearchRequest.Status,
sortBy: state.SearchRequest.SortBy,
year: state.SearchRequest.Year,
sortField: state.SearchRequest.SortField,
basePayRange: state.SearchRequest.BasePayRange,
totalPayRange: state.SearchRequest.TotalPayRange);
return(new SalariesState(false, null, true, state.SalaryResults, state.SalaryDetail, updatedSearchRequest));
}
public async Task GivenValidRequest_WhenSearchQueryOrdersByTotalPayDecending_ReturnsOrderedDescendingResultList()
{
// Arrange
var searchRequest = new EmployeeSalarySearchRequestDto(jobTitle: "Software", sortField: nameof(SalarySortField.TotalWithBenefitsSalary), sortBy: nameof(SalarySortByOption.Descending));
var query = new GetEmployeeSalariesQuery(searchRequest, TestUri, default);
var handler = new GetEmployeeSalariesQueryHandler(Context);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <OpenReddingSearchResultAggregate <EmployeeSalarySearchResultDto> >();
result.Results.ShouldBeOfType <List <EmployeeSalarySearchResultDto> >();
result.Results.ShouldNotBeEmpty();
result.Count.ShouldBe(3);
result.Results.ToList()[2].Name.ShouldBe("John Smith");
result.Results.ToList()[1].Name.ShouldBe("Joey Mckenzie");
result.Results.ToList()[0].Name.ShouldBe("Mary Smith");
}
public async Task GivenValidRequest_WhenStatusIsInQuery_FiltersByStatus()
{
// Arrange
var searchRequest = new EmployeeSalarySearchRequestDto(status: nameof(EmployeeStatus.PartTime));
var query = new GetEmployeeSalariesQuery(searchRequest, TestUri, default);
var handler = new GetEmployeeSalariesQueryHandler(Context);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <OpenReddingSearchResultAggregate <EmployeeSalarySearchResultDto> >();
result.Count.ShouldBe(2);
result.Results.ShouldBeOfType <List <EmployeeSalarySearchResultDto> >();
result.Results.ShouldContain(e => e.Name == "Joe Schmoe");
result.Results.FirstOrDefault()?.JobTitle.ShouldBe("Accountant");
result.Results.FirstOrDefault()?.Agency.ShouldBe(EmployeeAgency.ShastaCounty.ToFriendlyString());
result.Results.FirstOrDefault()?.Status.ShouldBe(EmployeeStatus.PartTime.ToFriendlyString());
}
public static SalariesState SetEmployeeStatusActionReducer(SalariesState state, SetEmployeeStatusAction action)
{
if (state.SearchRequest is null)
{
return(InitializeSearchRequest(state, SalarySearchContext.Status, action.Status.ToString()));
}
var updatedSearchRequest = new EmployeeSalarySearchRequestDto(
name: state.SearchRequest.Name,
jobTitle: state.SearchRequest.JobTitle,
agency: state.SearchRequest.Agency,
status: action.Status.ToString(),
sortBy: state.SearchRequest.SortBy,
year: state.SearchRequest.Year,
sortField: state.SearchRequest.SortField,
basePayRange: state.SearchRequest.BasePayRange,
totalPayRange: state.SearchRequest.TotalPayRange);
return(new SalariesState(false, null, true, state.SalaryResults, state.SalaryDetail, updatedSearchRequest));
}
public async Task <OpenReddingPagedViewModel <EmployeeSalarySearchResultDto> > GetEmployeeSalaries(
[FromQuery] string?name,
[FromQuery] string?jobTitle,
[FromQuery] string?agency,
[FromQuery] string?status,
[FromQuery] string?sortBy,
[FromQuery] int?year,
[FromQuery] int?basePayRange,
[FromQuery] int?totalPayRange,
[FromQuery] int?page,
[FromQuery] string?sortField)
{
_logger.LogInformation($"Querying salaries:\n" +
$"name [{name}]\n" +
$"jobTitle [{jobTitle}]\n" +
$"agency [{agency}]\n" +
$"status [{status}]\n" +
$"sortBy [{sortBy}]\n" +
$"year [{year}]\n" +
$"basePayRange [{basePayRange}]\n" +
$"totalPayRange [{totalPayRange}]\n" +
$"page [{page}]\n" +
$"sortField [{sortField}]");
_logger.LogInformation("Sending employee salary search request...");
var searchRequest = new EmployeeSalarySearchRequestDto(name, jobTitle, agency, status, sortBy, year, sortField, basePayRange, totalPayRange);
var response = await Mediator.Send(new GetEmployeeSalariesQuery(searchRequest, new Uri(_gatewayBaseUrl), page));
_logger.LogInformation($"Request was successful, {response.Results.Count()} found with {response.Count} results");
return(new OpenReddingPagedViewModel <EmployeeSalarySearchResultDto>
{
Results = response.Results,
Count = response.Count,
Pages = response.Pages,
CurrentPage = response.CurrentPage,
Links = _linkBuilder.BuildPaginationLinks(HttpContext.Request.Query, response.Pages, page)
});
}
public DownloadSalariesCommand(EmployeeSalarySearchRequestDto searchRequest) =>
public GetEmployeeSalariesQuery(EmployeeSalarySearchRequestDto searchRequest, Uri gatewayBaseUrl, int?page) => (SearchRequest, GatewayBaseUrl, Page) = (searchRequest, gatewayBaseUrl, page ?? 1);
public static IQueryable <Employee> FromSearchRequest(this IQueryable <Employee> queriedSalaries, EmployeeSalarySearchRequestDto searchRequest)
{
if (queriedSalaries is null)
{
throw new ArgumentNullException(nameof(queriedSalaries), "Queryable cannot be null, please check LINQ statement");
}
// Filter by job title, if available
if (!string.IsNullOrWhiteSpace(searchRequest.JobTitle))
{
// NOTE: As of EF Core 3.0, StringComparison no longer works due to server-side evaluation of queries
Expression <Func <Employee, bool> > canFilterByEmployeeJobTitle = e =>
!string.IsNullOrWhiteSpace(e.JobTitle) && e.JobTitle.Contains(searchRequest.JobTitle);
queriedSalaries = queriedSalaries.Where(canFilterByEmployeeJobTitle);
}
// Filter by name, if available
if (!string.IsNullOrWhiteSpace(searchRequest.Name))
{
// NOTE: As of EF Core 3.0, StringComparison no longer works due to server-side evaluation of queries
Expression <Func <Employee, bool> > canFilterByEmployeeName = e =>
!string.IsNullOrWhiteSpace(e.FirstName) && !string.IsNullOrWhiteSpace(e.LastName) &&
(e.FirstName.Contains(searchRequest.Name) || e.LastName.Contains(searchRequest.Name));
queriedSalaries = queriedSalaries.Where(canFilterByEmployeeName);
}
// Filter by year, if available
if (searchRequest.Year.HasValue)
{
var parsedEmploymentYear = (EmploymentYear)searchRequest.Year.Value;
queriedSalaries = parsedEmploymentYear switch
{
EmploymentYear._2011 => queriedSalaries.Where(e => e.Year == 2011),
EmploymentYear._2012 => queriedSalaries.Where(e => e.Year == 2012),
EmploymentYear._2013 => queriedSalaries.Where(e => e.Year == 2013),
EmploymentYear._2014 => queriedSalaries.Where(e => e.Year == 2014),
EmploymentYear._2015 => queriedSalaries.Where(e => e.Year == 2015),
EmploymentYear._2016 => queriedSalaries.Where(e => e.Year == 2016),
EmploymentYear._2017 => queriedSalaries.Where(e => e.Year == 2017),
EmploymentYear._2018 => queriedSalaries.Where(e => e.Year == 2018),
EmploymentYear._2019 => queriedSalaries.Where(e => e.Year == 2019),
_ => queriedSalaries
};
}
// Filter by status, if available
if (!string.IsNullOrWhiteSpace(searchRequest.Status) && Enum.TryParse(searchRequest.Status, true, out EmployeeStatus employeeStatus))
{
queriedSalaries = employeeStatus switch
{
EmployeeStatus.FullTime => queriedSalaries.Where(e => e.EmployeeStatus == employeeStatus),
EmployeeStatus.PartTime => queriedSalaries.Where(e => e.EmployeeStatus == employeeStatus),
_ => queriedSalaries
};
}
// Filter by agency, if available
if (!string.IsNullOrWhiteSpace(searchRequest.Agency) && Enum.TryParse(searchRequest.Agency, true, out EmployeeAgency employeeAgency))
{
queriedSalaries = employeeAgency switch
{
EmployeeAgency.Redding => queriedSalaries.Where(e => e.EmployeeAgency == employeeAgency),
EmployeeAgency.ShastaCounty => queriedSalaries.Where(e => e.EmployeeAgency == employeeAgency),
_ => queriedSalaries
};
}
// Filter by base pay range, if available
if (searchRequest.BasePayRange.HasValue && Enum.IsDefined(typeof(SalarySearchRange), searchRequest.BasePayRange.Value))
{
var parsedRange = (SalarySearchRange)searchRequest.BasePayRange.Value;
queriedSalaries = parsedRange switch
{
SalarySearchRange._0To49 => queriedSalaries.Where(e => e.BasePay >= 0 && e.BasePay < 50000m),
SalarySearchRange._50To100 => queriedSalaries.Where(e => e.BasePay >= 50000m && e.BasePay < 100000m),
SalarySearchRange._100To149 => queriedSalaries.Where(e => e.BasePay >= 100000m && e.BasePay < 150000m),
SalarySearchRange._150To199 => queriedSalaries.Where(e => e.BasePay >= 150000m && e.BasePay < 200000m),
SalarySearchRange._200To249 => queriedSalaries.Where(e => e.BasePay >= 200000m && e.BasePay < 250000m),
SalarySearchRange._250To299 => queriedSalaries.Where(e => e.BasePay >= 250000m && e.BasePay < 300000m),
SalarySearchRange._300AndGreater => queriedSalaries.Where(e => e.BasePay >= 300000),
_ => queriedSalaries
};
}
// Filter by total pay with benefits range, if available
if (searchRequest.TotalPayRange.HasValue && Enum.IsDefined(typeof(SalarySearchRange), searchRequest.TotalPayRange.Value))
{
var parsedRange = (SalarySearchRange)searchRequest.TotalPayRange.Value;
queriedSalaries = parsedRange switch
{
SalarySearchRange._0To49 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 0 && e.TotalPayWithBenefits < 50000m),
SalarySearchRange._50To100 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 50000m && e.TotalPayWithBenefits < 100000m),
SalarySearchRange._100To149 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 100000m && e.TotalPayWithBenefits < 150000m),
SalarySearchRange._150To199 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 150000m && e.TotalPayWithBenefits < 200000m),
SalarySearchRange._200To249 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 200000m && e.TotalPayWithBenefits < 250000m),
SalarySearchRange._250To299 => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 250000m && e.TotalPayWithBenefits < 300000m),
SalarySearchRange._300AndGreater => queriedSalaries.Where(e => e.TotalPayWithBenefits >= 300000),
_ => queriedSalaries
};
}
// Sort by the request field, if available
if (!string.IsNullOrWhiteSpace(searchRequest.SortField) && Enum.TryParse(searchRequest.SortField, true, out SalarySortField sortOption))
{
var sortBy = SalarySortByOption.Default;
// Check for the sort order
if (Enum.TryParse(searchRequest.SortBy, true, out SalarySortByOption option))
{
sortBy = option;
}
queriedSalaries = sortBy switch
{
SalarySortByOption.Ascending => sortOption switch
{
SalarySortField.BaseSalary => queriedSalaries.OrderBy(e => e.BasePay),
SalarySortField.JobTitle => queriedSalaries.OrderBy(e => e.JobTitle),
SalarySortField.Name => queriedSalaries.OrderBy(e => e.LastName),
SalarySortField.Year => queriedSalaries.OrderBy(e => e.Year),
SalarySortField.TotalWithBenefitsSalary => queriedSalaries.OrderBy(e => e.TotalPayWithBenefits),
_ => queriedSalaries
},
