Beispiel #1
0
        /// <summary>
        ///     Search for project responsibilities using specific conditions.
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        protected virtual IQueryable <ProjectResponsibility> GetProjectResponsibilities(
            SearchProjectResponsibilityViewModel condition)
        {
            //Get list projet responsibility
            var projectResponsibilities = _unitOfWork.ProjectResponsibilities.Search();

            if (condition.ProjectIds != null && condition.ProjectIds.Count > 0)
            {
                var projectIds = condition.ProjectIds.Where(x => x > 0).ToList();
                if (projectIds.Count > 0)
                {
                    projectResponsibilities = projectResponsibilities.Where(x => projectIds.Contains(x.ProjectId));
                }
            }

            if (condition.ResponsibilityIds != null && condition.ResponsibilityIds.Count > 0)
            {
                var responsibilityIds = condition.ResponsibilityIds.Where(x => x > 0).ToList();
                if (responsibilityIds.Count > 0)
                {
                    projectResponsibilities =
                        projectResponsibilities.Where(x => responsibilityIds.Contains(x.ResponsibilityId));
                }
            }

            return(projectResponsibilities);
        }
Beispiel #2
0
        public async Task <IHttpActionResult> SearchProjectResponsibilities(
            [FromBody] SearchProjectResponsibilityViewModel model)
        {
            model = model ?? new SearchProjectResponsibilityViewModel();
            Validate(model);

            var projectResponsibilities = await _projectResponsibilityDomain.SearchProjectResponsibilityAsync(model);

            return(Ok(projectResponsibilities));
        }
        public async Task <IHttpActionResult> Search([FromBody] SearchProjectResponsibilityViewModel condition)
        {
            //Check null for model
            if (condition == null)
            {
                condition = new SearchProjectResponsibilityViewModel();
                Validate(condition);
            }

            //Validate model
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            //Get list projet responsibility
            var projectResponsibilities = _unitOfWork.ProjectResponsibilities.Search();

            if (condition.ProjectIds != null && condition.ProjectIds.Count > 0)
            {
                var projectIds = condition.ProjectIds.Where(x => x > 0).ToList();
                if (projectIds.Count > 0)
                {
                    projectResponsibilities = projectResponsibilities.Where(x => projectIds.Contains(x.ProjectId));
                }
            }

            if (condition.ResponsibilityIds != null && condition.ResponsibilityIds.Count > 0)
            {
                var responsibilityIds = condition.ResponsibilityIds.Where(x => x > 0).ToList();
                if (responsibilityIds.Count > 0)
                {
                    projectResponsibilities =
                        projectResponsibilities.Where(x => responsibilityIds.Contains(x.ResponsibilityId));
                }
            }

            var result = new SearchResultViewModel <IList <ProjectResponsibility> >();

            result.Total = await projectResponsibilities.CountAsync();

            //Do sort
            projectResponsibilities =
                _dbService.Sort(projectResponsibilities, SortDirection.Ascending,
                                ProjectResponsibilitySortProperty.ProjectId);

            //Do paginatin
            projectResponsibilities = _dbService.Paginate(projectResponsibilities, condition.Pagination);

            result.Records = await projectResponsibilities.ToListAsync();

            return(Ok(result));
        }
Beispiel #4
0
        SearchProjectResponsibilitiesAsync(SearchProjectResponsibilityViewModel condition,
                                           CancellationToken cancellationToken = default(CancellationToken))
        {
            var projectResponsibilities = GetProjectResponsibilities(condition);
            var result = new SearchResultViewModel <IList <ProjectResponsibility> >();

            result.Total = await projectResponsibilities.CountAsync(cancellationToken);

            //Do sort
            projectResponsibilities =
                _dbService.Sort(projectResponsibilities, SortDirection.Ascending,
                                ProjectResponsibilitySortProperty.ProjectId);

            //Do paginatin
            projectResponsibilities = _dbService.Paginate(projectResponsibilities, condition.Pagination);

            result.Records = await projectResponsibilities.ToListAsync(cancellationToken);

            return(result);
        }
Beispiel #5
0
        public async Task <IHttpActionResult> Search([FromBody] SearchProjectResponsibilityViewModel condition)
        {
            //Check null for model
            if (condition == null)
            {
                condition = new SearchProjectResponsibilityViewModel();
                Validate(condition);
            }

            //Validate model
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var loadProjectResponsibilitiesResult =
                await _projectResponsibilityService.SearchProjectResponsibilitiesAsync(condition);

            return(Ok(loadProjectResponsibilitiesResult));
        }
Beispiel #6
0
        public async Task <SearchResultViewModel <IList <ProjectResponsibility> > > SearchProjectResponsibilityAsync(SearchProjectResponsibilityViewModel model,
                                                                                                                     CancellationToken cancellationToken = default(CancellationToken))
        {
            //Get list projet responsibility
            var projectResponsibilities = _dbContext.ProjectResponsibilities.AsQueryable();

            if (model.ProjectIds != null)
            {
                var projectIds = model.ProjectIds.Where(x => x > 0).ToList();
                if (projectIds.Count > 0)
                {
                    projectResponsibilities = projectResponsibilities.Where(x => projectIds.Contains(x.ProjectId));
                }
            }
            if (model.ResponsibilityIds != null)
            {
                var responsibilityIds = model.ResponsibilityIds.Where(x => x > 0).ToList();
                if (responsibilityIds.Count > 0)
                {
                    projectResponsibilities =
                        projectResponsibilities.Where(x => responsibilityIds.Contains(x.ResponsibilityId));
                }
            }

            var result = new SearchResultViewModel <IList <ProjectResponsibility> >();

            result.Total = await projectResponsibilities.CountAsync(cancellationToken);

            //Do sort
            projectResponsibilities =
                _dbService.Sort(projectResponsibilities, SortDirection.Ascending, ProjectSortProperty.Id);

            //Do paginatin
            projectResponsibilities = _dbService.Paginate(projectResponsibilities, model.Pagination);

            result.Records = await projectResponsibilities.ToListAsync(cancellationToken);

            return(result);
        }