public async Task <int> GetScenariosCount(ScenarioParameters scenarioParameters)
        {
            var             scenarios     = context.Ls.Where(x => x.LstypeId != (int)LsTypeEnum.Private).AsQueryable();
            IQueryable <Ls> searchResults = Enumerable.Empty <Ls>().AsQueryable();

            if (!string.IsNullOrWhiteSpace(scenarioParameters.Keyword))
            {
                searchResults = SearchScenariosByKeyword(scenarioParameters);
            }
            if (!string.IsNullOrWhiteSpace(scenarioParameters.Lsname))
            {
                searchResults = SearchScenariosByName(ref scenarios, scenarioParameters);
            }

            if (searchResults.Count() == 0)
            {
                scenarios = FilterScenarios(ref scenarios, scenarioParameters);
                var result = await scenarios.ToListAsync();

                return(result.Count());
            }
            else
            {
                searchResults = FilterScenarios(ref searchResults, scenarioParameters);
                var result = await searchResults.ToListAsync();

                return(result.Count());
            }
        }
        public async Task <PagedList <LsListDTO> > GetScenarios(ScenarioParameters scenarioParameters)
        {
            var             scenarios     = context.Ls.Where(x => x.LstypeId != (int)LsTypeEnum.Private && x.IsDeleted == false).AsQueryable();
            IQueryable <Ls> searchResults = Enumerable.Empty <Ls>().AsQueryable();

            if (!string.IsNullOrWhiteSpace(scenarioParameters.Keyword))
            {
                searchResults = SearchScenariosByKeyword(scenarioParameters);
            }
            if (!string.IsNullOrWhiteSpace(scenarioParameters.Lsname))
            {
                searchResults = SearchScenariosByName(ref scenarios, scenarioParameters);
            }

            if (searchResults.Count() == 0)
            {
                scenarios = FilterScenarios(ref scenarios, scenarioParameters);

                scenarios = sortService.ApplySort(scenarios, scenarioParameters.OrderBy);
                return(await PagedList <LsListDTO> .ToPagedList(scenarios.Select(x => mapper.Map <LsListDTO>(x)),
                                                                scenarioParameters.PageNumber,
                                                                scenarioParameters.PageSize));
            }
            else
            {
                searchResults = FilterScenarios(ref searchResults, scenarioParameters);

                searchResults = sortService.ApplySort(searchResults, scenarioParameters.OrderBy);
                return(await PagedList <LsListDTO> .ToPagedList(searchResults.Select(x => mapper.Map <LsListDTO>(x)),
                                                                scenarioParameters.PageNumber,
                                                                scenarioParameters.PageSize));
            }
        }
 private IQueryable <Ls> SearchScenariosByName(ref IQueryable <Ls> scenarios, ScenarioParameters scenarioParameters)
 {
     if (!string.IsNullOrWhiteSpace(scenarioParameters.Lsname))
     {
         scenarios = scenarios.Where(x => x.Lsname.ToLower().Trim().Contains(scenarioParameters.Lsname.ToLower().Trim()) && x.IsDeleted == false);
     }
     return(scenarios);
 }
        private IQueryable <Ls> FilterScenarios(ref IQueryable <Ls> scenarios, ScenarioParameters scenarioParameters)
        {
            if (scenarioParameters.Lsgrade >= 1 && scenarioParameters.Lsgrade <= 8)
            {
                scenarios = scenarios.Where(x => x.Lsgrade == scenarioParameters.Lsgrade && x.IsDeleted == false);
            }

            if (scenarioParameters.TeachingSubjectId != 0)
            {
                scenarios = scenarios.Where(x => x.TeachingSubjectId == scenarioParameters.TeachingSubjectId && x.IsDeleted == false);
            }

            return(scenarios);
        }
        public async Task <IActionResult> GetScenarios([FromQuery] ScenarioParameters scenarioParameters)
        {
            var result = await scenariosService.GetScenarios(scenarioParameters);

            var metadata = new
            {
                result.TotalCount,
                result.PageSize,
                result.CurrentPage,
                result.TotalPages,
                result.HasNext,
                result.HasPrevious
            };

            Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
            return(Ok(result));
        }
        private IQueryable <Ls> SearchScenariosByKeyword(ScenarioParameters scenarioParameters)
        {
            IQueryable <Ls> ls = Enumerable.Empty <Ls>().AsQueryable();

            if (!string.IsNullOrWhiteSpace(scenarioParameters.Keyword.Trim()))
            {
                var keyword = keywordRepository.GetKeyword(scenarioParameters.Keyword);
                if (keyword != null)
                {
                    ls = context.Lskeyword.Where(x => x.Keywordid == keyword.Idkeyword)
                         .Select(x => x.Lsid)
                         .Select(x => context.Ls.Find(x))
                         .Select(x => x);
                    ls = ls.Where(x => x.LstypeId != (int)LsTypeEnum.Private && x.IsDeleted == false);
                }
            }
            return(ls);
        }
Example #7
0
 public ScenarioDocument()
 {
     this.DesignItems        = new List <DesignItem>();
     this.Connectors         = new List <Connector>();
     this.ScenarioParameters = new ScenarioParameters();
 }
        public async Task <IActionResult> GetScenariosCount([FromQuery] ScenarioParameters scenarioParameters)
        {
            var result = await scenariosService.GetScenariosCount(scenarioParameters);

            return(Ok(new { scenariosCount = result }));
        }