/// <summary>
/// Get bookmarks asyncronously
/// </summary>
/// <param name="queryOperator">The query operator to apply</param>
/// <returns>List of bookmarks</returns>
public Task <PagedQueryResults <BookmarkDTO> > GetBookmarksAsync(QueryableOperator <BookmarkDTO> queryOperator)
{
var query = BookmarkQueries.CreateGetBookmarksQuery(Context);
query = query.Apply(queryOperator);
return(query.ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit));
}
public async Task TestGetFocusCategoriesByOfficeId_Sort()
{
var office = new Organization
{
OrganizationId = 1
};
var focus1 = new Focus
{
FocusId = 1,
FocusName = "focus1",
Office = office,
OfficeId = office.OrganizationId
};
var focus2 = new Focus
{
FocusId = 2,
FocusName = "focus2",
Office = office,
OfficeId = office.OrganizationId
};
var category1 = new Category
{
CategoryId = 1,
CategoryName = "cat1",
Focus = focus1,
FocusId = focus1.FocusId,
};
var category2 = new Category
{
CategoryId = 2,
CategoryName = "cat2",
Focus = focus2,
FocusId = focus2.FocusId,
};
context.Organizations.Add(office);
context.Foci.Add(focus2);
context.Foci.Add(focus1);
context.Categories.Add(category2);
context.Categories.Add(category1);
Action <PagedQueryResults <FocusCategoryDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(2, results.Results.Count);
Assert.AreEqual(category2.CategoryId, results.Results.First().Id);
Assert.AreEqual(category1.CategoryId, results.Results.Last().Id);
};
var defaultSorter = new ExpressionSorter <FocusCategoryDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <FocusCategoryDTO>(0, 10, defaultSorter);
queryOperator.Sorters.Add(new ExpressionSorter <FocusCategoryDTO>(x => x.FocusName, SortDirection.Descending));
var serviceResults = service.GetFocusCategoriesByOfficeId(office.OrganizationId, queryOperator);
var serviceResultsAsync = await service.GetFocusCategoriesByOfficeIdAsync(office.OrganizationId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetOrganizationTypes_CheckProperties()
{
var orgType = new OrganizationType
{
OrganizationTypeId = 1,
OrganizationTypeName = "theme"
};
context.OrganizationTypes.Add(orgType);
Action <PagedQueryResults <OrganizationTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(orgType.OrganizationTypeId, firstResult.Id);
Assert.AreEqual(orgType.OrganizationTypeName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <OrganizationTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <OrganizationTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var moneyFlowSourceRecipientType = new MoneyFlowSourceRecipientType
{
MoneyFlowSourceRecipientTypeId = 1,
TypeName = "type"
};
context.MoneyFlowSourceRecipientTypes.Add(moneyFlowSourceRecipientType);
Action <PagedQueryResults <MoneyFlowSourceRecipientTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(moneyFlowSourceRecipientType.MoneyFlowSourceRecipientTypeId, firstResult.Id);
Assert.AreEqual(moneyFlowSourceRecipientType.TypeName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <MoneyFlowSourceRecipientTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <MoneyFlowSourceRecipientTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var focus = new Focus
{
FocusId = 1,
FocusName = "f"
};
context.Foci.Add(focus);
Action <PagedQueryResults <FocusDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(focus.FocusId, firstResult.Id);
Assert.AreEqual(focus.FocusName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <FocusDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <FocusDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetGoals_CheckProperties()
{
var goal = new Goal
{
GoalId = 1,
GoalName = "goal"
};
context.Goals.Add(goal);
Action <PagedQueryResults <GoalDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(goal.GoalId, firstResult.Id);
Assert.AreEqual(goal.GoalName, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <GoalDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <GoalDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public void TestExtensions_Apply_HasSorter()
{
var list = new List <QueryableOperatorTestClass>();
list.Add(new QueryableOperatorTestClass
{
Id = 2
});
list.Add(new QueryableOperatorTestClass
{
Id = 1
});
list = list.OrderBy(x => x.Id).ToList();
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var actualSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Descending);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, null, new List <ISorter> {
actualSorter
});
var query = list.AsQueryable().Apply(queryOperator);
var testList = query.ToList();
var expectedList = list.OrderByDescending(x => x.Id).ToList();
CollectionAssert.AreEqual(expectedList, testList);
}
public async Task <PagedQueryResults <EvaluationNoteDTO> > GetAsync(QueryableOperator <EvaluationNoteDTO> queryOperator)
{
var results = await GetEvaluationNoteDTOQuery(queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);
logger.Trace("Loaded evaluation notes with query operator = [{0}].", queryOperator);
return(results);
}
private IQueryable <EvaluationNoteDTO> GetEvaluationNoteDTOQuery(QueryableOperator <EvaluationNoteDTO> queryOperator)
{
var query = GetSelectDTOQuery();
query = query.Apply(queryOperator);
return(query);
}
public async Task TestGet_CheckProperties()
{
var participantStatus = new ParticipantStatus
{
Status = ParticipantStatus.Active.Value,
ParticipantStatusId = ParticipantStatus.Active.Id,
};
context.ParticipantStatuses.Add(participantStatus);
Action <PagedQueryResults <ParticipantStatusDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(participantStatus.ParticipantStatusId, firstResult.Id);
Assert.AreEqual(participantStatus.Status, firstResult.Name);
};
var defaultSorter = new ExpressionSorter <ParticipantStatusDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <ParticipantStatusDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGet_CheckProperties()
{
var dependentType = new DependentType
{
Name = "name",
DependentTypeId = 1,
SevisDependentTypeCode = "code"
};
context.DependentTypes.Add(dependentType);
Action <PagedQueryResults <DependentTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(dependentType.DependentTypeId, firstResult.Id);
Assert.AreEqual(dependentType.Name, firstResult.Name);
Assert.AreEqual(dependentType.SevisDependentTypeCode, firstResult.SevisDependentTypeCode);
};
var defaultSorter = new ExpressionSorter <DependentTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <DependentTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetEvaluations_Filter()
{
var evaluation1 = new PersonEvaluationNote
{
EvaluationNoteId = 1
};
var evaluation2 = new PersonEvaluationNote
{
EvaluationNoteId = 2
};
context.PersonEvaluationNotes.Add(evaluation1);
context.PersonEvaluationNotes.Add(evaluation2);
Action <PagedQueryResults <EvaluationNoteDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(evaluation1.EvaluationNoteId, firstResult.EvaluationNoteId);
};
var defaultSorter = new ExpressionSorter <EvaluationNoteDTO>(x => x.EvaluationNoteId, SortDirection.Descending);
var queryOperator = new QueryableOperator <EvaluationNoteDTO>(0, 1, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <EvaluationNoteDTO>(x => x.EvaluationNoteId, ComparisonType.Equal, evaluation1.EvaluationNoteId));
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetEvaluations_CheckProperties()
{
var evaluation = new PersonEvaluationNote
{
EvaluationNoteId = 1,
EvaluationNote = "Test evaluation note"
};
context.PersonEvaluationNotes.Add(evaluation);
Action <PagedQueryResults <EvaluationNoteDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(evaluation.EvaluationNoteId, firstResult.EvaluationNoteId);
Assert.AreEqual(evaluation.EvaluationNote, firstResult.EvaluationNote);
};
var defaultSorter = new ExpressionSorter <EvaluationNoteDTO>(x => x.EvaluationNoteId, SortDirection.Ascending);
var queryOperator = new QueryableOperator <EvaluationNoteDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestGetFocusCategoriesByProgramId_Filter()
{
var program = new Program
{
ProgramId = 1
};
var focus1 = new Focus
{
FocusId = 1,
FocusName = "focus1",
};
var category1 = new Category
{
CategoryId = 1,
CategoryName = "cat1",
Focus = focus1,
FocusId = focus1.FocusId,
};
var focus2 = new Focus
{
FocusId = 2,
FocusName = "focus2",
};
var category2 = new Category
{
CategoryId = 2,
CategoryName = "cat2",
Focus = focus2,
FocusId = focus2.FocusId,
};
program.Categories.Add(category1);
program.Categories.Add(category2);
context.Programs.Add(program);
context.Foci.Add(focus1);
context.Categories.Add(category1);
context.Foci.Add(focus2);
context.Categories.Add(category2);
Action <PagedQueryResults <FocusCategoryDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(category2.FocusId, firstResult.Id);
};
var defaultSorter = new ExpressionSorter <FocusCategoryDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <FocusCategoryDTO>(0, 10, defaultSorter);
queryOperator.Filters.Add(new ExpressionFilter <FocusCategoryDTO>(x => x.Name, ComparisonType.Equal, category2.CategoryName));
var serviceResults = service.GetFocusCategoriesByProgramId(program.ProgramId, queryOperator);
var serviceResultsAsync = await service.GetFocusCategoriesByProgramIdAsync(program.ProgramId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
/// <summary>
/// Returns list of organizations
/// </summary>
/// <param name="queryOperator">The query operator to apply</param>
/// <returns>List of organizations</returns>
public PagedQueryResults <SimpleOrganizationDTO> GetOrganizations(QueryableOperator <SimpleOrganizationDTO> queryOperator)
{
var organizations = OrganizationQueries.CreateGetSimpleOrganizationsDTOQuery(this.Context, queryOperator).ToPagedQueryResults(queryOperator.Start, queryOperator.Limit);
this.logger.Trace("Retrieved organizations with query operator [{0}].", queryOperator);
return(organizations);
}
/// <summary>
/// Returns a paged, filtered, and sorted instance of dtos.
/// </summary>
/// <param name="queryOperator">The query operator.</param>
/// <returns>The paged, filtered, and sorted dtos.</returns>
public async Task <PagedQueryResults <LanguageProficiencyDTO> > GetAsync(QueryableOperator <LanguageProficiencyDTO> queryOperator)
{
var results = await GetLanguageProficiencyDTOQuery(queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);
logger.Trace("Loaded languageProficiency with query operator = [{0}].", queryOperator);
return(results);
}
public async Task TestGetJustificationObjectivesByOfficeId_Sort()
{
var office = new Organization
{
OrganizationId = 1
};
var justification1 = new Justification
{
JustificationId = 1,
JustificationName = "just1",
Office = office,
OfficeId = office.OrganizationId
};
var justification2 = new Justification
{
JustificationId = 2,
JustificationName = "just2",
Office = office,
OfficeId = office.OrganizationId
};
var objective1 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 1,
ObjectiveName = "obj1",
};
var objective2 = new Objective
{
Justification = justification1,
JustificationId = justification1.JustificationId,
ObjectiveId = 2,
ObjectiveName = "obj2",
};
context.Organizations.Add(office);
context.Objectives.Add(objective1);
context.Objectives.Add(objective2);
context.Justifications.Add(justification1);
context.Justifications.Add(justification2);
Action <PagedQueryResults <JustificationObjectiveDTO> > tester = (results) =>
{
Assert.AreEqual(2, results.Total);
Assert.AreEqual(2, results.Results.Count);
Assert.AreEqual(objective1.ObjectiveId, results.Results.First().Id);
Assert.AreEqual(objective2.ObjectiveId, results.Results.Last().Id);
};
var defaultSorter = new ExpressionSorter <JustificationObjectiveDTO>(x => x.Name, SortDirection.Descending);
var queryOperator = new QueryableOperator <JustificationObjectiveDTO>(0, 10, defaultSorter);
queryOperator.Sorters.Add(new ExpressionSorter <JustificationObjectiveDTO>(x => x.JustificationName, SortDirection.Descending));
var serviceResults = service.GetJustificationObjectivesByOfficeId(office.OrganizationId, queryOperator);
var serviceResultsAsync = await service.GetJustificationObjectivesByOfficeIdAsync(office.OrganizationId, queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
private IQueryable <LanguageProficiencyDTO> GetLanguageProficiencyDTOQuery(QueryableOperator <LanguageProficiencyDTO> queryOperator)
{
var query = GetSelectDTOQuery();
query = query.Apply(queryOperator);
return(query);
}
public void TestToString_DefaultSorterOnly()
{
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, null, null);
Assert.IsNotNull(queryOperator.ToString());
}
/// <summary>
/// Returns a paged, filtered, and sorted instance of dtos.
/// </summary>
/// <param name="queryOperator">The query operator.</param>
/// <returns>The paged, filtered, and sorted dtos.</returns>
public async Task <PagedQueryResults <DTOType> > GetAsync(QueryableOperator <DTOType> queryOperator)
{
var results = await GetDTOQuery(queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);
logger.Trace("Loaded lookups of type [{0}] with query operator = [{1}].", typeof(DTOType).FullName, queryOperator);
return(results);
}
public void TestExtensions_Apply_HasFilter()
{
var list = new List <QueryableOperatorTestClass>();
list.Add(new QueryableOperatorTestClass
{
Id = 2
});
list.Add(new QueryableOperatorTestClass
{
Id = 1
});
list = list.OrderBy(x => x.Id).ToList();
var filterValue = 1;
var defaultSorter = new ExpressionSorter <QueryableOperatorTestClass>(x => x.Id, SortDirection.Ascending);
var filter = new ExpressionFilter <QueryableOperatorTestClass>(x => x.Id, ComparisonType.Equal, filterValue);
var queryOperator = new QueryableOperator <QueryableOperatorTestClass>(0, 10, defaultSorter, new List <IFilter> {
filter
}, null);
var query = list.AsQueryable().Apply(queryOperator);
var testList = query.ToList();
Assert.AreEqual(1, testList.Count);
Assert.AreEqual(filterValue, testList.First().Id);
}
private IQueryable <DTOType> GetDTOQuery(QueryableOperator <DTOType> queryOperator)
{
var query = GetSelectDTOQuery();
query = query.Apply(queryOperator);
return(query);
}
/// <summary>
/// Returns the participants in the system.
/// </summary>
/// <param name="queryOperator">The query operator.</param>
/// <returns>The participants.</returns>
public Task <PagedQueryResults <SimpleParticipantDTO> > GetParticipantsAsync(QueryableOperator <SimpleParticipantDTO> queryOperator)
{
var participants = ParticipantQueries.CreateGetSimpleParticipantsDTOQuery(this.Context, queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);
this.logger.Trace("Retrieved participants with query operator [{0}].", queryOperator);
return(participants);
}
/// <summary>
/// Returns resource authorizations given the query operator.
/// </summary>
/// <param name="queryOperator">The query operator.</param>
/// <returns>The paged filtered and sorted resource authorizations.</returns>
public PagedQueryResults <ResourceAuthorization> GetResourceAuthorizations(QueryableOperator <ResourceAuthorization> queryOperator)
{
var results = ResourceQueries.CreateGetResourceAuthorizationsQuery(this.Context, queryOperator).ToPagedQueryResults(queryOperator.Start, queryOperator.Limit);
logger.Trace("Retrieved resource authorizations using query operator [{0}].", queryOperator);
return(results);
}
public async Task TestGet_CheckProperties()
{
var locationType = new LocationType
{
LocationTypeName = LocationType.City.Value,
LocationTypeId = LocationType.City.Id
};
context.LocationTypes.Add(locationType);
Action <PagedQueryResults <SimpleLookupDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(locationType.LocationTypeId, firstResult.Id);
Assert.AreEqual(locationType.LocationTypeName, firstResult.Value);
};
var defaultSorter = new ExpressionSorter <SimpleLookupDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SimpleLookupDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
/// <summary>
/// Returns the users in the CAM system.
/// </summary>
/// <param name="queryOperator">The query operator.</param>
/// <returns>The users.</returns>
public async Task <PagedQueryResults <UserDTO> > GetUsersAsync(QueryableOperator <UserDTO> queryOperator)
{
var users = await UserQueries.CreateGetUsersQuery(this.Context, queryOperator).ToPagedQueryResultsAsync(queryOperator.Start, queryOperator.Limit);
logger.Trace("Retrieved users from CAM with query operator [{0}].", queryOperator);
return(users);
}
