Пример #1
0
        /// <summary>
        /// Search for responsibilities using specific conditions.
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        protected virtual IQueryable <Responsibility> GetResponsibilities(SearchResponsibilityViewModel condition)
        {
            var responsibilities = _unitOfWork.Responsibilities.Search();

            if (condition.Ids != null)
            {
                var ids = condition.Ids.Where(x => x > 0).ToList();

                if (ids.Count > 0)
                {
                    responsibilities = responsibilities.Where(x => ids.Contains(x.Id));
                }
            }

            if (condition.Names != null)
            {
                var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();

                if (names.Count > 0)
                {
                    responsibilities = responsibilities.Where(c => names.Contains(c.Name));
                }
            }

            if (condition.CreatedTime != null)
            {
                var createdTime = condition.CreatedTime;
                var from        = createdTime.From;
                var to          = createdTime.To;

                if (from != null)
                {
                    responsibilities = responsibilities.Where(x => x.CreatedTime >= from);
                }

                if (to != null)
                {
                    responsibilities = responsibilities.Where(x => x.CreatedTime <= to);
                }
            }

            if (condition.LastModifiedTime != null)
            {
                var lastModifiedTime = condition.LastModifiedTime;
                var from             = lastModifiedTime.From;
                var to = lastModifiedTime.To;

                if (from != null)
                {
                    responsibilities = responsibilities.Where(x => x.LastModifiedTime >= from);
                }

                if (to != null)
                {
                    responsibilities = responsibilities.Where(x => x.LastModifiedTime <= to);
                }
            }

            return(responsibilities);
        }
        public async Task <IHttpActionResult> SearchResponsibilities([FromBody] SearchResponsibilityViewModel model)
        {
            model = model ?? new SearchResponsibilityViewModel();
            Validate(model);

            var responsibilities = await _responsibilityDomain.SearchResponsibilitiesAsync(model);

            return(Ok(responsibilities));
        }
        public async Task <IHttpActionResult> Search([FromBody] SearchResponsibilityViewModel condition)
        {
            if (condition == null)
            {
                condition = new SearchResponsibilityViewModel();
                Validate(condition);
            }

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

            var loadResponsibilitiesResult =
                await _responsibilityService.SearchResponsibilitiesAsync(condition, CancellationToken.None);

            return(Ok(loadResponsibilitiesResult));
        }
Пример #4
0
        public async Task <SearchResultViewModel <IList <Responsibility> > > SearchResponsibilitiesAsync(SearchResponsibilityViewModel model,
                                                                                                         CancellationToken cancellationToken = default(CancellationToken))
        {
            var responsibilities = _dbContext.Responsibilities.AsQueryable();

            if (model.Ids != null)
            {
                var ids = model.Ids.Where(x => x > 0).ToList();

                if (ids.Count > 0)
                {
                    responsibilities = responsibilities.Where(x => ids.Contains(x.Id));
                }
            }

            if (model.Names != null)
            {
                var names = model.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();

                if (names.Count > 0)
                {
                    responsibilities = responsibilities.Where(c => names.Contains(c.Name));
                }
            }

            if (model.CreatedTime != null)
            {
                responsibilities = responsibilities.Where(c => c.CreatedTime >= model.CreatedTime.From &&
                                                          c.CreatedTime <= model.CreatedTime.To);
            }

            if (model.LastModifiedTime != null)
            {
                responsibilities = responsibilities.Where(c => c.LastModifiedTime >= model.LastModifiedTime.From &&
                                                          c.LastModifiedTime <= model.LastModifiedTime.To);
            }

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

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

            // Sort
            responsibilities =
                _dbService.Sort(responsibilities, SortDirection.Ascending, ResponsibilitySortProperty.Id);

            // Paging
            responsibilities = _dbService.Paginate(responsibilities, model.Pagination);

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

            return(result);
        }
Пример #5
0
 /// <summary>
 /// <inheritdoc />
 /// </summary>
 /// <param name="condition"></param>
 /// <param name="cancellationToken"></param>
 /// <returns></returns>
 public async Task <Responsibility> SearchResponsibilityAsync(SearchResponsibilityViewModel condition,
                                                              CancellationToken cancellationToken = default(CancellationToken))
 {
     return(await GetResponsibilities(condition).FirstOrDefaultAsync(cancellationToken));
 }
Пример #6
0
        /// <summary>
        /// <inheritdoc />
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <SearchResultViewModel <IList <Responsibility> > > SearchResponsibilitiesAsync(SearchResponsibilityViewModel condition,
                                                                                                         CancellationToken cancellationToken = default(CancellationToken))
        {
            var responsibilities = GetResponsibilities(condition);
            var result           = new SearchResultViewModel <IList <Responsibility> >();

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

            // Sort
            responsibilities =
                _dbService.Sort(responsibilities, SortDirection.Ascending, ResponsibilitySortProperty.Id);

            // Paging
            responsibilities = _dbService.Paginate(responsibilities, condition.Pagination);

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

            return(result);
        }
Пример #7
0
        public async Task <IHttpActionResult> Search([FromBody] SearchResponsibilityViewModel condition)
        {
            if (condition == null)
            {
                condition = new SearchResponsibilityViewModel();
                Validate(condition);
            }

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

            var responsibilities = _unitOfWork.Responsibilities.Search();

            if (condition.Ids != null)
            {
                var ids = condition.Ids.Where(x => x > 0).ToList();

                if (ids.Count > 0)
                {
                    responsibilities = responsibilities.Where(x => ids.Contains(x.Id));
                }
            }

            if (condition.Names != null)
            {
                var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();

                if (names.Count > 0)
                {
                    responsibilities = responsibilities.Where(c => names.Contains(c.Name));
                }
            }

            if (condition.CreatedTime != null)
            {
                responsibilities = responsibilities.Where(c => c.CreatedTime >= condition.CreatedTime.From &&
                                                          c.CreatedTime <= condition.CreatedTime.To);
            }

            if (condition.LastModifiedTime != null)
            {
                responsibilities = responsibilities.Where(c => c.LastModifiedTime >= condition.LastModifiedTime.From &&
                                                          c.LastModifiedTime <= condition.LastModifiedTime.To);
            }

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

            result.Total = await responsibilities.CountAsync();

            // Sort
            responsibilities =
                _dbService.Sort(responsibilities, SortDirection.Ascending, ResponsibilitySortProperty.Id);

            // Paging
            responsibilities = _dbService.Paginate(responsibilities, condition.Pagination);

            result.Records = await responsibilities.ToListAsync();

            return(Ok(result));
        }