public async Task Test_JobSearchQuery_DefaultCriteria_Should_ReturnAll()
{
// arrange
var jobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, jobs);
var search = new JobSearchCriteria()
{
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(100);
results.TotalPages.Should().Be(4);
results.Data.Should().HaveCount(25);
results.Data.Should().OnlyHaveUniqueItems(x => x.JobId);
}
public async Task Test_ListJobs_FindAll_Should_ReturnPagedList()
{
// arrange
var jobs = new JobFaker()
.Generate(100);
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, jobs);
var search = new JobSearchCriteria()
{
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var result = await _service.ListJobs(search, paging);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
var payload = result.Payload;
payload.TotalItems.Should().Be(100);
payload.TotalPages.Should().Be(4);
payload.Data.Should().HaveCount(25);
}
public async Task Test_JobSearchQuery_FindByTypeAndNamespace_Should_ReturnMatching()
{
// arrange
var jobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, jobs);
var expected = jobs[39];
var search = new JobSearchCriteria()
{
Type = expected.Type, Namespace = expected.Namespace
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(1);
results.TotalPages.Should().Be(1);
results.Data.Should().HaveCount(1);
results.Data.Should().OnlyContain(x => x.Type == expected.Type && x.Namespace == expected.Namespace);
}
public async Task GetJobsAsync_returns_Jobs_by_JobStatus(params JobStatus[] jobStatuses)
{
string ownerId = TestMemoryCacheJobRepositoryFactory.OwnerIds[0];
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Setup(jobCache => jobCache.Query())
.Returns(() => TestMemoryCacheJobRepositoryFactory.Jobs.AsQueryable())
.Verifiable();
var memoryCacheJobRepository = _testMemoryCacheJobRepositoryFactory.CreateMemoryCacheJobRepository();
var jobSearchCriteria = new JobSearchCriteria
{
JobOwnerId = ownerId
}
.WithJobStatuses(jobStatuses);
IReadOnlyCollection <Job> actualJobs = await memoryCacheJobRepository.GetJobsAsync(jobSearchCriteria);
IReadOnlyCollection <Job> expectedJobs = TestMemoryCacheJobRepositoryFactory.Jobs
.Where(job => job.JobOwnerId.Contains(ownerId) && jobStatuses.Contains(job.JobStatus))
.OrderBy(job => job.ExecuteAfter ?? job.CreatedAt)
.ToList()
.AsReadOnly();
Assert.Equal(expectedJobs, actualJobs);
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Verify(
jobCache => jobCache.Query(),
Times.Once);
}
public async Task Test_ListJobs_Find_ByCorrelationId_Should_ReturnPagedList()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
var relatedJobs = new JobFaker().SetCorrelationId(correlationId).Generate(10);
await using var context = DbContextFactory.Instance.CreateDbContext <PortAuthorityDbContext>();
await context.Setup(x => x.Jobs, bulkJobs);
await context.Setup(x => x.Jobs, relatedJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var result = await _service.ListJobs(search, paging);
// assert
result.Should().NotBeNull();
result.IsOk().Should().BeTrue();
var payload = result.Payload;
payload.TotalItems.Should().Be(10);
payload.TotalPages.Should().Be(1);
payload.Data.Should().HaveCount(10);
payload.Data.Should().OnlyContain(x => relatedJobs.Select(j => j.JobId).Contains(x.JobId));
}
public async Task Test_JobSearchQuery_FindByCorrelationId_None_Should_ReturnEmpty()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, bulkJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(0);
results.TotalPages.Should().Be(0);
results.Data.Should().BeNullOrEmpty();
}
public async Task Test_JobSearchQuery_FindByCorrelationId_Should_ReturnMatching()
{
// arrange
var correlationId = Guid.NewGuid();
var bulkJobs = new JobFaker().Generate(100);
var relatedJobs = new JobFaker().SetCorrelationId(correlationId).Generate(13);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, bulkJobs);
await dbContext.Setup(x => x.Jobs, relatedJobs);
var search = new JobSearchCriteria()
{
CorrelationId = correlationId
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(13);
results.TotalPages.Should().Be(1);
results.Data.Should().HaveCount(13);
results.Data.Should().OnlyContain(x => relatedJobs.Select(j => j.JobId).Contains(x.JobId));
}
public async Task GetJobsAsync_returns_Jobs_on_or_after_ExecuteAfter_marker(int minutesAfterMarker)
{
string ownerId = TestMemoryCacheJobRepositoryFactory.OwnerIds[0];
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Setup(jobCache => jobCache.Query())
.Returns(() => TestMemoryCacheJobRepositoryFactory.Jobs.AsQueryable())
.Verifiable();
var memoryCacheJobRepository = _testMemoryCacheJobRepositoryFactory.CreateMemoryCacheJobRepository();
DateTimeOffset executeAfter = TestMemoryCacheJobRepositoryFactory.ExecuteAfterMarker.AddMinutes(minutesAfterMarker);
var jobSearchCriteria = new JobSearchCriteria
{
JobOwnerId = ownerId,
ExecuteAfter = executeAfter
};
IReadOnlyCollection <Job> actualJobs = await memoryCacheJobRepository.GetJobsAsync(jobSearchCriteria);
IReadOnlyCollection <Job> expectedJobs = TestMemoryCacheJobRepositoryFactory.Jobs
.Where(job => job.JobOwnerId.Contains(ownerId) && executeAfter >= job.ExecuteAfter)
.OrderBy(job => job.ExecuteAfter ?? job.CreatedAt)
.ToList()
.AsReadOnly();
Assert.Equal(expectedJobs, actualJobs);
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Verify(
jobCache => jobCache.Query(),
Times.Once);
}
public async Task <IResult <PagedResult <JobSearchResult> > > ListJobs(JobSearchCriteria criteria, PagingCriteria paging)
{
var query = new JobSearchQuery(_dbContext);
var results = await query.Find(criteria, paging);
return(Result.Ok(results));
}
public async Task <IActionResult> ListJobs([FromQuery] JobSearchCriteria search, [FromQuery] PagingCriteria paging)
{
_logger.LogInformation("Finding all jobs for criteria = [{Criteria}]", search);
_logger.LogInformation("Page = [{Paging}]", paging);
var result = await _jobService.ListJobs(search, paging);
return(Ok(result.Payload));
}
/// Gets the search results and displays on the screen.
/// </summary>
/// <param name="criteria">The job search criteria.</param>
private void PopulateData(JobSearchCriteria criteria)
{
// get some results
// need to impersonate as the service account so we can access the Import Control database.
string serviceAccount = ConfigurationManager.AppSettings[Constants.ConfigurationKeys.ServiceAccount].ToString();
string domain = ConfigurationManager.AppSettings[Constants.ConfigurationKeys.ServiceAccountDomain].ToString();
string password = ConfigurationManager.AppSettings[Constants.ConfigurationKeys.ServiceAccountPassword].ToString();
WindowsImpersonationContext context = null;
try
{
context = IMS.NCS.CourseSearchService.Common.Utilities.impersonateValidUser(serviceAccount, domain, password);
if (context != null)
{
IDashboardService service = new DashboardService();
DashboardJob dashboardJob = service.GetJobList(criteria);
if (dashboardJob != null && dashboardJob.Jobs.Count() > 0)
{
divSearchResults.Visible = true;
ResultsOverviewLabel.Text = String.Format(Constants.StringFormats.ResultsOverviewStringFormat, dashboardJob.CurrentPageNo, dashboardJob.TotalPages, dashboardJob.TotalRecords);
SetupPageNavButtons(dashboardJob.TotalPages, dashboardJob.CurrentPageNo);
gridJobs.DataSource = dashboardJob.Jobs;
gridJobs.DataBind();
}
else
{
DisplayNoResults();
}
}
else
{
ResultsOverviewLabel.Text = "The service account cannot be impersonated.";
}
}
catch (Exception ex)
{
ResultsOverviewLabel.Text = ex.Message + "\n" + ex.StackTrace;
}
finally
{
if (context != null)
{
IMS.NCS.CourseSearchService.Common.Utilities.UndoImpersonation(context);
}
}
}
/// <summary>
/// Populates the search controls with the values from the search criteria.
/// </summary>
/// <param name="criteria">The populated search criteria.</param>
public void PopulatePage(JobSearchCriteria criteria)
{
string scriptName = "PopulateCriteria";
Type thisType = this.GetType();
ClientScriptManager mgr = Page.ClientScript;
if (!mgr.IsStartupScriptRegistered(thisType, scriptName))
{
StringBuilder scriptText = new StringBuilder();
scriptText.Append("<script type=text/javascript>" + Environment.NewLine);
if (criteria.StartDate != DateTime.MinValue)
{
scriptText.Append(Utilities.GetJavascriptSetValueSnippet("StartDate", criteria.StartDate.ToString("dd/MM/yyyy")));
}
if (criteria.EndDate != DateTime.MinValue)
{
scriptText.Append(Utilities.GetJavascriptSetValueSnippet("EndDate", criteria.EndDate.ToString("dd/MM/yyyy")));
}
scriptText.Append(Utilities.GetJavascriptSetValueSnippet("RecordsPerPage", criteria.RecordsPerPage.ToString()));
// only set dropdowns if the user selected a value
if (!string.IsNullOrEmpty(criteria.SortBy))
{
scriptText.Append(Utilities.GetJavascriptSetValueSnippet("SortBy", criteria.SortBy));
}
if (criteria.InProgressJobs)
{
scriptText.Append(Utilities.GetJavascriptSetCheckboxValueSnippet("JobStatus_InProgress", "Y"));
}
if (criteria.CompletedJobs)
{
scriptText.Append(Utilities.GetJavascriptSetCheckboxValueSnippet("JobStatus_Complete", "Y"));
}
if (criteria.FailedJobs)
{
scriptText.Append(Utilities.GetJavascriptSetCheckboxValueSnippet("JobStatus_Failed", "Y"));
}
// end
scriptText.Append("</script>");
mgr.RegisterStartupScript(thisType, scriptName, scriptText.ToString());
}
}
public Task <IReadOnlyCollection <Job> > GetJobsAsync(JobSearchCriteria jobSearchCriteria)
{
if (jobSearchCriteria == null)
{
throw new ArgumentNullException(nameof(jobSearchCriteria));
}
IQueryable <Job> jobQuery = _jobCache.Query();
if (!string.IsNullOrEmpty(jobSearchCriteria.JobOwnerId))
{
jobQuery = jobQuery.Where(job => job.JobOwnerId.Contains(jobSearchCriteria.JobOwnerId, StringComparison.OrdinalIgnoreCase));
}
if (jobSearchCriteria.JobStatuses.Count > 0)
{
jobQuery = jobQuery.Where(job => jobSearchCriteria.JobStatuses.Contains(job.JobStatus));
}
if (jobSearchCriteria.ExecuteAfter.HasValue)
{
jobQuery = jobQuery.Where(job => jobSearchCriteria.ExecuteAfter >= job.ExecuteAfter);
}
jobQuery = jobQuery.OrderBy(job => job.ExecuteAfter ?? job.CreatedAt);
if (jobSearchCriteria.ItemsToSkip.HasValue)
{
jobQuery = jobQuery.Skip(jobSearchCriteria.ItemsToSkip.Value);
}
if (jobSearchCriteria.MaximumItems.HasValue)
{
jobQuery = jobQuery.Take(jobSearchCriteria.MaximumItems.Value);
}
IReadOnlyCollection <Job> jobes = jobQuery
.ToList()
.AsReadOnly();
return(Task.FromResult(jobes));
}
public async Task GetJobsAsync_returns_constrained_results(int?skip, int?limit)
{
string ownerId = TestMemoryCacheJobRepositoryFactory.OwnerIds[0];
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Setup(jobCache => jobCache.Query())
.Returns(() => TestMemoryCacheJobRepositoryFactory.Jobs.AsQueryable())
.Verifiable();
var memoryCacheJobRepository = _testMemoryCacheJobRepositoryFactory.CreateMemoryCacheJobRepository();
var jobSearchCriteria = new JobSearchCriteria
{
JobOwnerId = ownerId,
ItemsToSkip = skip,
MaximumItems = limit
};
IReadOnlyCollection <Job> actualJobs = await memoryCacheJobRepository.GetJobsAsync(jobSearchCriteria);
IEnumerable <Job> expectedJobs = TestMemoryCacheJobRepositoryFactory.Jobs
.Where(job => job.JobOwnerId.Contains(ownerId))
.OrderBy(job => job.ExecuteAfter ?? job.CreatedAt);
if (skip != null)
{
expectedJobs = expectedJobs.Skip(skip.Value);
}
if (limit != null)
{
expectedJobs = expectedJobs.Take(limit.Value);
}
Assert.Equal(expectedJobs, actualJobs);
_testMemoryCacheJobRepositoryFactory.MockJobCache
.Verify(
jobCache => jobCache.Query(),
Times.Once);
}
public async Task Test_JobSearchQuery_NoData_Should_ReturnEmptyResult()
{
// arrange
var search = new JobSearchCriteria()
{
};
var paging = new PagingCriteria()
{
Page = 1, Size = 25
};
// act
var dbContext = GetDbContext();
var results = await new JobSearchQuery(dbContext).Find(search, paging);
// assert
results.Should().NotBeNull();
results.Page.Should().Be(1);
results.Size.Should().Be(25);
results.TotalItems.Should().Be(0);
results.TotalPages.Should().Be(0);
results.Data.Should().BeNullOrEmpty();
}
/// <summary>
/// Creates the search criteria from the QueryString.
/// </summary>
/// <param name="requestData">The query string data.</param>
/// <returns>A JobSearchCriteria with data.</returns>
private JobSearchCriteria CreateSearchCriteria(NameValueCollection requestData)
{
bool result;
JobSearchCriteria criteria = new JobSearchCriteria();
DateTime tempDateTime;
result = DateTime.TryParse(Utilities.GetQueryStringValue(requestData, "EndDate"), out tempDateTime);
if (result)
{
criteria.EndDate = tempDateTime.Date;
}
result = DateTime.TryParse(Utilities.GetQueryStringValue(requestData, "StartDate"), out tempDateTime);
if (result)
{
criteria.StartDate = tempDateTime.Date;
}
string[] jobStatuses = Utilities.GetQueryStringValues(Page.Request.QueryString, "JobStatus");
criteria.CompletedJobs = jobStatuses != null && jobStatuses.Contains("Completed");
criteria.InProgressJobs = jobStatuses != null && jobStatuses.Contains("InProgress");
criteria.FailedJobs = jobStatuses != null && jobStatuses.Contains("Failed");
// default SortBy if the user hasn't entered one
criteria.SortBy = Utilities.GetQueryStringValue(Page.Request.QueryString, Constants.QueryStrings.SortBy);
criteria.SortBy = criteria.SortBy == string.Empty ? "StartDate" : criteria.SortBy;
criteria.RecordsPerPage = Int32.Parse(Utilities.GetQueryStringValue(Page.Request.QueryString, Constants.QueryStrings.RecordsPerPage));
criteria.RecordsPerPage = criteria.RecordsPerPage == 0 ? 10 : criteria.RecordsPerPage;
// default to first page if next page not set
string nextPage = Utilities.GetQueryStringValue(Page.Request.QueryString, Constants.QueryStrings.GetPage);
criteria.NextPage = string.IsNullOrEmpty(nextPage) ? 1 : Int32.Parse(nextPage);
return(criteria);
}
/// <summary>
/// Gets a list of Jobs for the search criteria.
/// </summary>
/// <param name="searchCriteria">The search criteria.</param>
/// <returns>A DashboardJob of data.</returns>
DashboardJob IDashboardService.GetJobList(JobSearchCriteria searchCriteria)
{
IDashboardQuery query = new DashboardQuery();
return(query.GetJobList(searchCriteria));
}
public async Task Test_JobSearchQuery_PageForward_Should_ReturnNewPage()
{
// arrange
var jobs = new JobFaker().Generate(100);
await using var dbContext = GetDbContext();
await dbContext.Setup(x => x.Jobs, jobs);
var search = new JobSearchCriteria();
// act
var query = new JobSearchQuery(dbContext);
var page1 = await query.Find(search, new PagingCriteria()
{
Page = 1, Size = 5
});
var page2 = await query.Find(search, new PagingCriteria()
{
Page = 2, Size = 5
});
var page3 = await query.Find(search, new PagingCriteria()
{
Page = 3, Size = 5
});
var page10 = await query.Find(search, new PagingCriteria()
{
Page = 10, Size = 5
});
// assert
page1.Should().NotBeNull();
page1.Page.Should().Be(1);
page1.TotalItems.Should().Be(100);
page1.TotalPages.Should().Be(20);
page1.Data.Should()
.NotContain(page2.Data)
.And.NotContain(page3.Data)
.And.NotContain(page10.Data);
page2.Should().NotBeNull();
page2.Page.Should().Be(2);
page2.TotalItems.Should().Be(100);
page2.TotalPages.Should().Be(20);
page2.Data.Should()
.NotContain(page1.Data)
.And.NotContain(page3.Data)
.And.NotContain(page10.Data);
page3.Should().NotBeNull();
page3.Page.Should().Be(3);
page3.TotalItems.Should().Be(100);
page3.TotalPages.Should().Be(20);
page3.Data.Should()
.NotContain(page1.Data)
.And.NotContain(page2.Data)
.And.NotContain(page10.Data);
page10.Should().NotBeNull();
page10.Page.Should().Be(10);
page10.TotalItems.Should().Be(100);
page10.TotalPages.Should().Be(20);
page10.Data.Should()
.NotContain(page1.Data)
.And.NotContain(page2.Data)
.And.NotContain(page3.Data);
}
/// <summary>
/// Gets a list of Jobs for the search criteria.
/// </summary>
/// <param name="searchCriteria">The search criteria.</param>
/// <returns>A DashboardJob of data.</returns>
DashboardJob IDashboardQuery.GetJobList(JobSearchCriteria searchCriteria)
{
IDashboardGateway gateway = new DashboardGateway();
return(gateway.GetJobList(searchCriteria));
}
/// <summary>
/// Gets a list of Jobs for the search criteria.
/// </summary>
/// <param name="searchCriteria">The search criteria.</param>
/// <returns>A DashboardJob of data.</returns>
DashboardJob IDashboardGateway.GetJobList(JobSearchCriteria searchCriteria)
{
DashboardJob dashboardJob = new DashboardJob();
using (SqlConnection sqlConnection = new SqlConnection(Utilities.GetDatabaseConnection()))
{
using (SqlCommand command = new SqlCommand())
{
command.Connection = sqlConnection;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = Constants.Database.UspGetJobsByCriteria;
if (searchCriteria.StartDate != DateTime.MinValue)
{
AddParameter(command, SqlDbType.DateTime, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.StartDate, searchCriteria.StartDate);
}
else
{
AddParameter(command, SqlDbType.DateTime, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.StartDate, DBNull.Value);
}
if (searchCriteria.EndDate != DateTime.MinValue)
{
AddParameter(command, SqlDbType.DateTime, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.EndDate, searchCriteria.EndDate);
}
else
{
AddParameter(command, SqlDbType.DateTime, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.EndDate, DBNull.Value);
}
AddBoolParameter(command, SqlDbType.Bit, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.InProgressJobs, searchCriteria.InProgressJobs);
AddBoolParameter(command, SqlDbType.Bit, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.CompletedJobs, searchCriteria.CompletedJobs);
AddBoolParameter(command, SqlDbType.Bit, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.FailedJobs, searchCriteria.FailedJobs);
AddParameter(command, SqlDbType.VarChar, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.SortBy, searchCriteria.SortBy);
AddParameter(command, SqlDbType.Int, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.NoOfRecords, searchCriteria.RecordsPerPage);
AddParameter(command, SqlDbType.Int, ParameterDirection.Input, Constants.UspGetJobsByCriteriaParameters.PageNo, searchCriteria.NextPage);
AddParameter(command, SqlDbType.Int, ParameterDirection.Output, Constants.UspGetJobsByCriteriaParameters.TotalRows);
command.Connection.Open();
SqlDataReader reader = command.ExecuteReader();
List <Job> jobsList = new List <Job>();
while (reader.Read())
{
Job job = new Job();
job.CurrentStep = (string)reader[Constants.UspGetJobsByCriteriaColumns.CurrentStep];
object tempObj = reader[Constants.UspGetJobsByCriteriaColumns.ElapsedTime];
if (tempObj != DBNull.Value)
{
job.ElapsedTime = (long)tempObj;
}
tempObj = reader[Constants.UspGetJobsByCriteriaColumns.JobId];
if (tempObj != DBNull.Value)
{
job.JobId = (int)reader[Constants.UspGetJobsByCriteriaColumns.JobId];
}
tempObj = reader[Constants.UspGetJobsByCriteriaColumns.JobName];
if (tempObj != DBNull.Value)
{
job.JobName = (string)reader[Constants.UspGetJobsByCriteriaColumns.JobName];
}
tempObj = reader[Constants.UspGetJobsByCriteriaColumns.ProcessEnd];
if (tempObj != DBNull.Value)
{
job.ProcessEnd = (DateTime)reader[Constants.UspGetJobsByCriteriaColumns.ProcessEnd];
}
tempObj = reader[Constants.UspGetJobsByCriteriaColumns.ProcessStart];
if (tempObj != DBNull.Value)
{
job.ProcessStart = (DateTime)reader[Constants.UspGetJobsByCriteriaColumns.ProcessStart];
}
job.Status = (string)reader[Constants.UspGetJobsByCriteriaColumns.Status];
jobsList.Add(job);
}
// need to close the reader to get hold of the output params
// and create our paging values
reader.Close();
dashboardJob.CurrentPageNo = searchCriteria.NextPage;
dashboardJob.TotalRecords = Int32.Parse(GetOutputParameter(command, Constants.UspGetJobsByCriteriaParameters.TotalRows));
var result = Decimal.Divide((decimal)dashboardJob.TotalRecords, (decimal)searchCriteria.RecordsPerPage);
var totalPages = Math.Ceiling((decimal)result);
dashboardJob.TotalPages = (int)totalPages;
command.Connection.Close();
dashboardJob.Jobs = jobsList;
}
}
return(dashboardJob);
}
