internal async Task GetProjectsPreview_ValidAsync(string sql, Paging paging, ProjectSearch projectSearch, ProjectPreview[] expectedProjects)
{
using (var context = Storage.CreateContext())
{
try
{
Storage.RunSql(sql);
var api = Storage.CreatePublicController(context);
var response =
(
await api.GetProjectsPreviewAsync(paging, projectSearch) as JsonResult
).Value as ExecutionResult <ProjectPreview[]>;
GenericChecks.CheckSucceed(response);
Assert.Equal(expectedProjects.Length, response.Data.Length);
foreach (var item in expectedProjects)
{
var actual = response.Data.SingleOrDefault(x => x.Code == item.Code);
Compare(item, actual);
}
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
public void AddSearchViewData()
{
var marketperson = this.AccountService.GetUserList(1).Select(c => new { Id = c.ID, Name = c.Name });
ViewData.Add("MarketPerson", new SelectList(marketperson, "Name", "Name"));
var users = this.AccountService.GetUserList(7).Select(c => new { Id = c.ID, Name = c.Name });
ViewData.Add("Person", new SelectList(users, "Name", "Name"));
var users1 = this.AccountService.GetUserList(6).Select(c => new { Id = c.ID, Name = c.Name });
ViewData.Add("Leader", new SelectList(users1, "Name", "Name"));
List <string> list = new List <string>();
list.Add("检测评价组长");
list.Add("检测评价普通员工");
ViewData.Add("Select", new SelectList(list));
List <string> list2 = new List <string>();
list2.Add("全部项目");
list2.Add("检测项目");
list2.Add("评价项目");
ViewData.Add("Type", new SelectList(list2));
List <string> list3 = new List <string>();
int year = DateTime.Now.Year - 10;
for (int i = 10; i > 0; i--)
{
list3.Add((year + i).ToString());
}
ViewData.Add("Year", new SelectList(list3));
ProjectSearch = new ProjectSearch();
}
internal async Task GetProjectsPreview_InValidEmptyAsync(Paging paging, ProjectSearch projectSearch)
{
using (var context = Storage.CreateContext())
{
try
{
var api = Storage.CreatePublicController(context);
var response =
(
await api.GetProjectsPreviewAsync(paging, projectSearch) as JsonResult
).Value as ExecutionResult <ProjectPreview[]>;
GenericChecks.CheckEmpty(response);
}
catch (Exception)
{
throw;
}
finally
{
context.FlushData();
}
}
}
public ActionResult Search(FormCollection collection)
{
AddSearchViewData();
ProjectSearch search = new ProjectSearch();
search.JobType = collection["Select"];
if (search.JobType == "")
{
return(View("Index2"));
}
if (search.JobType == "检测评价组长")
{
search.People = collection["Leader"];
}
else
{
search.People = collection["Person"];
}
search.Year = collection["Year"];
search.ProjectType = collection["Type"];
var model = this.IDKLManagerService.GetProjectSearch(search.JobType, search.People, search.ProjectType, search.Year);
search.projectList = model;
ProjectSearch.projectList = search.projectList;
ProjectSearch.People = search.People;
return(View("Index2", search));
}
public void Test_Find_By_Description()
{
#region Arrange
//Add code to create required resources
#endregion Arrange
IProjectConnector connector = new ProjectConnector();
var existingEntries = connector.Find(null).Entities.Count;
var description = TestUtils.RandomString();
var newProject = new Project()
{
Description = description,
Status = Status.Ongoing,
StartDate = new DateTime(2019, 10, 10),
EndDate = new DateTime(2021, 10, 10),
ProjectLeader = "TestProjectLeader",
ContactPerson = "TestContactPerson",
Comments = "TestComments"
};
//Add entries
for (var i = 0; i < 5; i++)
{
connector.Create(newProject);
}
var otherDescription = TestUtils.RandomString();
newProject.Description = otherDescription;
for (var i = 0; i < 5; i++)
{
connector.Create(newProject);
}
var fullCollection = connector.Find(null);
Assert.AreEqual(existingEntries + 5 + 5, fullCollection.Entities.Count);
Assert.AreEqual(5, fullCollection.Entities.Count(e => e.Description == description));
Assert.AreEqual(5, fullCollection.Entities.Count(e => e.Description == otherDescription));
//Apply filter
var searchSettings = new ProjectSearch();
searchSettings.Description = otherDescription;
var filteredCollection = connector.Find(searchSettings);
Assert.AreEqual(5, filteredCollection.TotalResources);
Assert.AreEqual(5, filteredCollection.Entities.Count);
//Delete entries
foreach (var entry in fullCollection.Entities)
{
connector.Delete(entry.ProjectNumber);
}
#region Delete arranged resources
//Add code to delete temporary resources
#endregion Delete arranged resources
}
public void setUp()
{
try
{
ps = new ProjectSearch();
}
catch
{
throw new Exception();
}
}
public void tearDown()
{
try
{
ps = null;
}
catch
{
throw new Exception();
}
}
public async Task <IActionResult> Projects()
{
var model = new ProjectSearch
{
Name = string.Empty,
Status = Series.SeriesStatus.Ongoing
};
ViewData["Series"] = await _naniWebContext.Series.OrderBy(srs => srs.Status).ThenBy(srs => srs.Name).ToArrayAsync();
return(View(model));
}
public static void tearDownAfterClass()
{
try
{
ps = null;
art = null;
}
catch
{
throw new Exception();
}
}
public void Delete(ProjectSearch request)
{
var matches = Get(request) as List <Project>;
if (true != matches?.Any())
{
throw new HttpError(HttpStatusCode.NotFound, "No matches for request");
}
matches.ForEach(match =>
{
Delete(match);
});
}
public async Task Test_Find()
{
#region Arrange
//Add code to create required resources
#endregion Arrange
var connector = FortnoxClient.ProjectConnector;
var existingEntries = (await connector.FindAsync(null)).Entities.Count;
var testKeyMark = TestUtils.RandomString();
var newProject = new Project()
{
Description = testKeyMark,
Status = Status.Ongoing,
StartDate = new DateTime(2019, 10, 10),
EndDate = new DateTime(2021, 10, 10),
ProjectLeader = "TestProjectLeader",
ContactPerson = "TestContactPerson",
Comments = "TestComments"
};
//Add entries
for (var i = 0; i < 5; i++)
{
await connector.CreateAsync(newProject);
}
//No filter supported
var fullCollection = await connector.FindAsync(null);
Assert.AreEqual(existingEntries + 5, fullCollection.Entities.Count);
Assert.AreEqual(5, fullCollection.Entities.Count(e => e.Description == testKeyMark));
//Apply Limit
var searchSettings = new ProjectSearch();
searchSettings.Limit = 2;
var limitedCollection = await connector.FindAsync(searchSettings);
Assert.AreEqual(existingEntries + 5, limitedCollection.TotalResources);
Assert.AreEqual(2, limitedCollection.Entities.Count);
//Delete entries
foreach (var entry in fullCollection.Entities)
{
await connector.DeleteAsync(entry.ProjectNumber);
}
#region Delete arranged resources
//Add code to delete temporary resources
#endregion Delete arranged resources
}
public PagedResponse <ProjectDto> Execute(ProjectSearch search)
{
IQueryable <Project> query;
query = _tableCli.table.CreateQuery <Project>();
if (!String.IsNullOrWhiteSpace(search.Name))
{
query = query.Where(x => x.Name == search.Name);
}
query = query.Where(x => !x.Deleted);
var result = query.ToList();
List <ProjectDto> mapped = _mapper.Map <List <Project>, List <ProjectDto> >(result);
return(mapped.ToPagedResponse());
}
public ActionResult AreaSearch(ProjectInfoRequest request)
{
var area = this.IDKLManagerService.GetAreasList().Select(c => new { area = c.Area }).Distinct();
ViewData.Add("Area", new SelectList(area, "area", "area"));
AddSearchViewData();
List <string> Month = new List <string>();
for (int i = 1; i <= 12; i++)
{
Month.Add(i.ToString());
}
ViewData.Add("BeginMonth", new SelectList(Month));
ViewData.Add("EndMonth", new SelectList(Month));
ProjectSearchArea = new ProjectSearch();
return(View());
}
public async Task <IActionResult> Projects(ProjectSearch projectSearch)
{
if (ModelState.IsValid)
{
if (string.IsNullOrWhiteSpace(projectSearch.Name))
{
ViewData["Series"] = await _naniWebContext.Series.Where(srs => srs.Status == projectSearch.Status).OrderBy(srs => srs.Name).ToArrayAsync();
}
else
{
ViewData["Series"] = await _naniWebContext.Series.Where(srs => srs.Name.ToLowerInvariant().Contains(projectSearch.Name.ToLowerInvariant()) && srs.Status == projectSearch.Status)
.OrderBy(srs => srs.Name).ToArrayAsync();
}
}
else
{
ViewData["Series"] = await _naniWebContext.Series.OrderBy(srs => srs.Status).ThenBy(srs => srs.Name).ToArrayAsync();
}
return(View(projectSearch));
}
public IEnumerable <GetProjectDto> Execute(ProjectSearch request)
{
var query = context.Projects.AsQueryable();
if (request.Name != null)
{
query = query.Where(x => x.Name
.ToLower()
.Contains(request.Name.ToLower()));
}
if (request.OnlyActive.HasValue)
{
if (request.OnlyActive == true)
{
query = query.Where(x => x.DeletedAt == null);
}
}
query = query.SkipItems(request.Page, request.ItemsPerPage);
return(query.Select(x => _mapper.Map <Project, GetProjectDto>(x)).ToList());
}
public ActionResult SearchByArea(FormCollection collection)
{
var area = this.IDKLManagerService.GetAreasList().Select(c => new { area = c.Area }).Distinct();
ViewData.Add("Area", new SelectList(area, "area", "area"));
AddSearchViewData();
ProjectSearch search1 = new ProjectSearch();
List <string> Month = new List <string>();
for (int i = 1; i <= 12; i++)
{
Month.Add(i.ToString());
}
ViewData.Add("BeginMonth", new SelectList(Month));
ViewData.Add("EndMonth", new SelectList(Month));
string Area = collection["Area"];
string Year = collection["Year"];
string BeginMonth = collection["BeginMonth"];
string EndMonth = collection["EndMonth"];
var list = this.IDKLManagerService.GetProjectSearchByArea(Area, Year, BeginMonth, EndMonth);
ProjectSearchArea.projectList = list;
return(View("AreaSearch", ProjectSearchArea));
}
public object Post(ProjectSearch request) => Get(request);
public override async Task <IActionResult> GetProjectsPreviewAsync([FromQuery] Paging paging, [FromQuery] ProjectSearch searchQuery)
{
var result = await _supervisor.SafeExecuteAsync
(
() => _projectRepository.GetPreviewAsync(paging.Start, paging.Length, searchQuery.CategoryCode)
);
return(new JsonResult(result));
}
public abstract Task <IActionResult> GetProjectsPreviewAsync([FromQuery] Paging paging, [FromQuery] ProjectSearch searchQuery);
public ActionResult Index(ProjectSearch gridModel)
{
// gridModel.Search should be correctly bound here
return(RedirectToAction("Index"));
}
public IActionResult Get([FromQuery] ProjectSearch search, [FromServices] IGetProjectsQuery command)
{
IEnumerable <GetProjectDto> projects = _useCaseExecutor.ExecuteQuery(command, search);
return(Ok(projects));
}
public object Get(ProjectSearch request) => GetSearchResultWithCache <Project, DocEntityProject, ProjectSearch>(DocConstantModelName.PROJECT, request, _ExecSearch);
private IQueryable <DocEntityProject> _ExecSearch(ProjectSearch request, DocQuery query)
{
request = InitSearch <Project, ProjectSearch>(request);
IQueryable <DocEntityProject> entities = null;
query.Run(session =>
{
entities = query.SelectAll <DocEntityProject>();
if (!DocTools.IsNullOrEmpty(request.FullTextSearch))
{
var fts = new ProjectFullTextSearch(request);
entities = GetFullTextSearch <DocEntityProject, ProjectFullTextSearch>(fts, entities);
}
if (null != request.Ids && request.Ids.Any())
{
entities = entities.Where(en => en.Id.In(request.Ids));
}
if (!DocTools.IsNullOrEmpty(request.Updated))
{
entities = entities.Where(e => null != e.Updated && e.Updated.Value.Date == request.Updated.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.UpdatedBefore))
{
entities = entities.Where(e => null != e.Updated && e.Updated <= request.UpdatedBefore);
}
if (!DocTools.IsNullOrEmpty(request.UpdatedAfter))
{
entities = entities.Where(e => null != e.Updated && e.Updated >= request.UpdatedAfter);
}
if (!DocTools.IsNullOrEmpty(request.Created))
{
entities = entities.Where(e => null != e.Created && e.Created.Value.Date == request.Created.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.CreatedBefore))
{
entities = entities.Where(e => null != e.Created && e.Created <= request.CreatedBefore);
}
if (!DocTools.IsNullOrEmpty(request.CreatedAfter))
{
entities = entities.Where(e => null != e.Created && e.Created >= request.CreatedAfter);
}
if (true == request.Archived?.Any() && currentUser.HasProperty(DocConstantModelName.PROJECT, nameof(Reference.Archived), DocConstantPermission.VIEW))
{
entities = entities.Where(en => en.Archived.In(request.Archived));
}
else
{
entities = entities.Where(en => !en.Archived);
}
if (true == request.Locked?.Any())
{
entities = entities.Where(en => en.Locked.In(request.Locked));
}
if (true == request.ChildrenIds?.Any())
{
entities = entities.Where(en => en.Children.Any(r => r.Id.In(request.ChildrenIds)));
}
if (!DocTools.IsNullOrEmpty(request.Client) && !DocTools.IsNullOrEmpty(request.Client.Id))
{
entities = entities.Where(en => en.Client.Id == request.Client.Id);
}
if (true == request.ClientIds?.Any())
{
entities = entities.Where(en => en.Client.Id.In(request.ClientIds));
}
if (!DocTools.IsNullOrEmpty(request.DatabaseDeadline))
{
entities = entities.Where(en => null != en.DatabaseDeadline && request.DatabaseDeadline.Value.Date == en.DatabaseDeadline.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.DatabaseDeadlineBefore))
{
entities = entities.Where(en => en.DatabaseDeadline <= request.DatabaseDeadlineBefore);
}
if (!DocTools.IsNullOrEmpty(request.DatabaseDeadlineAfter))
{
entities = entities.Where(en => en.DatabaseDeadline >= request.DatabaseDeadlineAfter);
}
if (!DocTools.IsNullOrEmpty(request.DatabaseName))
{
entities = entities.Where(en => en.DatabaseName.Contains(request.DatabaseName));
}
if (!DocTools.IsNullOrEmpty(request.DatabaseNames))
{
entities = entities.Where(en => en.DatabaseName.In(request.DatabaseNames));
}
if (!DocTools.IsNullOrEmpty(request.Dataset) && !DocTools.IsNullOrEmpty(request.Dataset.Id))
{
entities = entities.Where(en => en.Dataset.Id == request.Dataset.Id);
}
if (true == request.DatasetIds?.Any())
{
entities = entities.Where(en => en.Dataset.Id.In(request.DatasetIds));
}
if (!DocTools.IsNullOrEmpty(request.DeliverableDeadline))
{
entities = entities.Where(en => null != en.DeliverableDeadline && request.DeliverableDeadline.Value.Date == en.DeliverableDeadline.Value.Date);
}
if (!DocTools.IsNullOrEmpty(request.DeliverableDeadlineBefore))
{
entities = entities.Where(en => en.DeliverableDeadline <= request.DeliverableDeadlineBefore);
}
if (!DocTools.IsNullOrEmpty(request.DeliverableDeadlineAfter))
{
entities = entities.Where(en => en.DeliverableDeadline >= request.DeliverableDeadlineAfter);
}
if (request.FqId.HasValue)
{
entities = entities.Where(en => request.FqId.Value == en.FqId);
}
if (!DocTools.IsNullOrEmpty(request.FqWorkflow) && !DocTools.IsNullOrEmpty(request.FqWorkflow.Id))
{
entities = entities.Where(en => en.FqWorkflow.Id == request.FqWorkflow.Id);
}
if (true == request.FqWorkflowIds?.Any())
{
entities = entities.Where(en => en.FqWorkflow.Id.In(request.FqWorkflowIds));
}
if (request.LegacyPackageId.HasValue)
{
entities = entities.Where(en => request.LegacyPackageId.Value == en.LegacyPackageId);
}
if (!DocTools.IsNullOrEmpty(request.Library) && !DocTools.IsNullOrEmpty(request.Library.Id))
{
entities = entities.Where(en => en.Library.Id == request.Library.Id);
}
if (true == request.LibraryIds?.Any())
{
entities = entities.Where(en => en.Library.Id.In(request.LibraryIds));
}
if (request.LibraryPackageId.HasValue)
{
entities = entities.Where(en => request.LibraryPackageId.Value == en.LibraryPackageId);
}
if (!DocTools.IsNullOrEmpty(request.LibraryPackageName))
{
entities = entities.Where(en => en.LibraryPackageName.Contains(request.LibraryPackageName));
}
if (!DocTools.IsNullOrEmpty(request.LibraryPackageNames))
{
entities = entities.Where(en => en.LibraryPackageName.In(request.LibraryPackageNames));
}
if (!DocTools.IsNullOrEmpty(request.Number))
{
entities = entities.Where(en => en.Number.Contains(request.Number));
}
if (!DocTools.IsNullOrEmpty(request.Numbers))
{
entities = entities.Where(en => en.Number.In(request.Numbers));
}
if (!DocTools.IsNullOrEmpty(request.OperationsDeliverable))
{
entities = entities.Where(en => en.OperationsDeliverable.Contains(request.OperationsDeliverable));
}
if (!DocTools.IsNullOrEmpty(request.OperationsDeliverables))
{
entities = entities.Where(en => en.OperationsDeliverable.In(request.OperationsDeliverables));
}
if (!DocTools.IsNullOrEmpty(request.OpportunityId))
{
entities = entities.Where(en => en.OpportunityId.Contains(request.OpportunityId));
}
if (!DocTools.IsNullOrEmpty(request.OpportunityIds))
{
entities = entities.Where(en => en.OpportunityId.In(request.OpportunityIds));
}
if (!DocTools.IsNullOrEmpty(request.OpportunityName))
{
entities = entities.Where(en => en.OpportunityName.Contains(request.OpportunityName));
}
if (!DocTools.IsNullOrEmpty(request.OpportunityNames))
{
entities = entities.Where(en => en.OpportunityName.In(request.OpportunityNames));
}
if (!DocTools.IsNullOrEmpty(request.Parent) && !DocTools.IsNullOrEmpty(request.Parent.Id))
{
entities = entities.Where(en => en.Parent.Id == request.Parent.Id);
}
if (true == request.ParentIds?.Any())
{
entities = entities.Where(en => en.Parent.Id.In(request.ParentIds));
}
if (!DocTools.IsNullOrEmpty(request.PICO))
{
entities = entities.Where(en => en.PICO.Contains(request.PICO));
}
if (!DocTools.IsNullOrEmpty(request.PICOs))
{
entities = entities.Where(en => en.PICO.In(request.PICOs));
}
if (!DocTools.IsNullOrEmpty(request.ProjectId))
{
entities = entities.Where(en => en.ProjectId.Contains(request.ProjectId));
}
if (!DocTools.IsNullOrEmpty(request.ProjectIds))
{
entities = entities.Where(en => en.ProjectId.In(request.ProjectIds));
}
if (!DocTools.IsNullOrEmpty(request.ProjectName))
{
entities = entities.Where(en => en.ProjectName.Contains(request.ProjectName));
}
if (!DocTools.IsNullOrEmpty(request.ProjectNames))
{
entities = entities.Where(en => en.ProjectName.In(request.ProjectNames));
}
if (request.Status.HasValue)
{
entities = entities.Where(en => request.Status.Value == en.Status);
}
if (!DocTools.IsNullOrEmpty(request.Statuss))
{
entities = entities.Where(en => en.Status.In(request.Statuss));
}
if (true == request.TimeCardsIds?.Any())
{
entities = entities.Where(en => en.TimeCards.Any(r => r.Id.In(request.TimeCardsIds)));
}
entities = ApplyFilters <DocEntityProject, ProjectSearch>(request, entities);
if (request.Skip > 0)
{
entities = entities.Skip(request.Skip.Value);
}
if (request.Take > 0)
{
entities = entities.Take(request.Take.Value);
}
if (true == request?.OrderBy?.Any())
{
entities = entities.OrderBy(request.OrderBy);
}
if (true == request?.OrderByDesc?.Any())
{
entities = entities.OrderByDescending(request.OrderByDesc);
}
});
return(entities);
}
public IActionResult Get([FromQuery] ProjectSearch search, [FromServices] IQueryProject query)
{
return(Ok(_executor.ExecuteQuery(query, search)));
}
