private ObservableCollection <BlobViewModel> ToBlobs(IPagedResult <IEnumerable <IEntry> > currentPage)
        {
            var pageOffset = (currentPage.PageNumber - 1) * currentPage.PageSize;

            return(new ObservableCollection <BlobViewModel>(currentPage.Result.Select((b, i) =>
                                                                                      new BlobViewModel(this, b, i + pageOffset + 1))));
        }
Example #2
0
 public void PagedResult_ValidParameters_Succeeds()
 {
     _pagedUsers = new PagedResult <User>(_users, 1, 5, _users.Count);
     Assert.AreEqual(_pagedUsers.PageSize, 5);
     Assert.IsTrue(_pagedUsers.HasNext);
     Assert.IsFalse(_pagedUsers.HasPrevious);
 }
Example #3
0
        public void SearchPost_WithValidData_ShouldReturnValidItems()
        {
            IList <Post> posts = PostHelper.GetPosts(6);

            posts[0].Title         = "Manage cookies using Web API";
            posts[0].SearchContent = "In my last project, I’ve deeply used WebApi, both for the client side and server side. In fact my application must call several REST endpoints developed with java and, after a code elaboration, I have to expose the data to other clients (javascript into an html page in this case).One of the pillars request by the Java services (really is not a technology request but just from the implementation made by the external company) is to read all cookies from the response and then send them back to the next requests (like a proxy).To make more clear where my app is, I realized the following chart:";

            posts[1].Title         = "Different keys with RavenDb";
            posts[1].SearchContent = "In last period, I am spending so times to learn document databases, in my case RavenDB and MongoDB. To be honest I am working only on Raven right now because it is friendlier for .NET developers but I promised myself to compare some features from these two awesome database engines. One of the big difficult I found, is to create the right model. I said big because I’m used to design the model for relation database and here is really different. For example we do not have the join and we also need to denormalize the references (http://ravendb.net/docs/faq/denormalized-references).";

            posts[2].Title         = "An amazing experience";
            posts[2].SearchContent = "Yesterday something special is happened and I still cannot believe that the Web.Net European Conference is over. For me was the first conference as a promoter and it was an AMAZING experience. More than 160 people from 11 different countries in the same building speaking about the future of the web (how F*ing cool is that?).";

            posts[3].Title         = "Use Less, Sass and Compass with ASP.NET MVC";
            posts[3].SearchContent = "In my last project, with my team, we chose to use Compass with SASS as CSS Authoring Framework.  Initially we was unsecure about that, the choice was very hard, the classic CSS allows you to find several guys who know it and it doesn’t require compilation unlike with Sass and Less. I’m not a front end developer so my part in this adventure is to manage the project and to make easy the integration of Less/Sass with an ASP.NET MVC application.";

            posts[4].Title         = "The best extensions for Visual Studio 2012";
            posts[4].SearchContent = "Visual Studio 2012 is absolutely the best IDE in the world and, with the latest version, it has sorted most of the big problems (from my point of view the previous version was a bit slow). I’m not a big fan of extensions because they often make Visual Studio unstable and/or slow, but I’ll make an exception because it this case it’s incredibly cool!";

            posts[5].Title         = "How integrate Facebook, Twitter, LinkedIn, Yahoo, Google and Microsoft Account with your ASP.NET MVC application";
            posts[5].SearchContent = "In the past week, 15 august, Microsoft released an incredible number of cool stuff, starting from Windows 8 and ending to Visual Studio 2012 including the new ASP.NET Stack. The version 4 of ASP.NET MVC introduces several cool features; most of them was available with the Beta and RC versions (Web API, Bundling, Mobile Projects Templates, etc.), but the RTM is not a “fixed version” of the RC, it has other interesting things.";

            foreach (Post post in posts)
            {
                this.SetupData(x => x.Store(post));
            }

            this.WaitStaleIndexes();

            IPagedResult <PostDto> result = this.sut.Search("Facebook", 1, 10, null);

            result.Result.Count().Should().Be.GreaterThan(0);
        }
        public static IPagedResult <TDest> MapToPagedResult <TSource, TDest>(this IPagedResult <TSource> pagedResult, IObjectMapper mapper)
            where TDest : class
        {
            var mapped = (IList <TDest>)mapper.Map(pagedResult.Data.AsEnumerable(), pagedResult.Data.GetType(), typeof(IEnumerable <TDest>));

            return(new PagedResult <TDest>(mapped, pagedResult.PageInfo));
        }
        public IPagedResult <PostDto> Search(string term, int pageIndex, int pageSize, ItemQueryFilter filters)
        {
            if (pageIndex < 1)
            {
                throw new ArgumentException("The page index must be greater than 0", "pageIndex");
            }

            if (pageSize < 1)
            {
                throw new ArgumentException("The page size must be greater than 0", "pageSize");
            }

            if (filters == null)
            {
                filters = new ItemQueryFilter();
                filters.MaxPublishAt = DateTime.Now;
                filters.Status       = ItemStatus.Published;
            }

            CancelEventArgsWithOneParameter <Tuple <string, int, int, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <string, int, int, ItemQueryFilter>, IPagedResult <PostDto> >(new Tuple <string, int, int, ItemQueryFilter>(term, pageIndex, pageSize, filters), null);

            this.PostsSearchingWithFilters.Raise(this, e);

            if (e.Cancel)
            {
                this.logger.DebugAsync("The result of the method 'Search' is overridden by the event 'PostsSearchingWithFilters'.");
                return(e.Result);
            }

            IPagedResult <PostDto> result = this.postDataService.Search(term, pageIndex, pageSize, filters);

            this.PostsSearchedWithFilters.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));

            return(result);
        }
Example #6
0
        public static void AddPaginationHeader <T>(this Controller controller,
                                                   IResourceParameter parameters, IPagedResult <T> result, IUrlHelper urlHelper)
        {
            var actionName = controller.ControllerContext.ActionDescriptor.AttributeRouteInfo.Name;
            var attributes = new[]
            {
                nameof(parameters.PageNumber).PascalToCamelCase(),
                nameof(parameters.PageSize).PascalToCamelCase()
            };

            var prevPage = result.HasPrevious ? urlHelper.Link(actionName, new Dictionary <string, string>
            {
                { attributes[0], (result.PageNumber - 1).ToString() },
                { attributes[1], result.PageSize.ToString() }
            }.AddRange(parameters.GetPageHeader())) : null;

            var nextPage = result.HasNext ? urlHelper.Link(actionName, new Dictionary <string, string>
            {
                { attributes[0], (result.PageNumber + 1).ToString() },
                { attributes[1], result.PageSize.ToString() }
            }.AddRange(parameters.GetPageHeader())) : null;

            var metaData = new
            {
                currentPage      = result.PageNumber,
                pageSize         = result.PageSize,
                totalPages       = result.TotalPages,
                totalCount       = result.TotalCount,
                previousPageLink = PercentEncodeReplace.Replace(prevPage),
                nextPageLink     = PercentEncodeReplace.Replace(nextPage)
            };

            controller.Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(metaData));
        }
        public PagedExceptionListViewModel(IPagedResult<ExceptionList> pagedResult, IMostRecentResult<ExceptionList> mostRecentResult)
        {
            PagedResult = pagedResult;
            MostRecentResult = mostRecentResult;

            if (mostRecentResult == null)
                MostRecentResult = new MostRecentResult<ExceptionList>(new List<ExceptionList>(), pagedResult.OriginalRequestDateTime, pagedResult.OriginalRequestDateTime);
        }
Example #8
0
 public PagedResult(IPagedResult paged, T[] data)
 {
     this.Data       = data;
     this.PageIndex  = paged.PageIndex;
     this.PageSize   = paged.PageSize;
     this.TotalCount = paged.TotalCount;
     this.TotalPages = paged.TotalPages;
 }
        public PagedUserListUserViewModel(IPagedResult<AuthenticationUserListUser> pagedResult, IMostRecentResult<AuthenticationUserListUser> mostRecentResult)
        {
            PagedResult = pagedResult;
            MostRecentResult = mostRecentResult;

            if (mostRecentResult == null)
                MostRecentResult = new MostRecentResult<AuthenticationUserListUser>(new List<AuthenticationUserListUser>(), pagedResult.OriginalRequestDateTime, pagedResult.OriginalRequestDateTime);
        }
        public PagedEmailDispatchListEmailMessageViewModel(IPagedResult<EmailDispatchListEmailMessage> pagedResult, IMostRecentResult<EmailDispatchListEmailMessage> mostRecentResult)
        {
            PagedResult = pagedResult;
            MostRecentResult = mostRecentResult;

            if (mostRecentResult == null)
                MostRecentResult = new MostRecentResult<EmailDispatchListEmailMessage>(new List<EmailDispatchListEmailMessage>(), pagedResult.OriginalRequestDateTime, pagedResult.OriginalRequestDateTime);
        }
        public PagedRoleListRoleViewModel(IPagedResult<RoleListRole> pagedResult, IMostRecentResult<RoleListRole> mostRecentResult)
        {
            PagedResult = pagedResult;
            MostRecentResult = mostRecentResult;

            if (mostRecentResult == null)
                MostRecentResult = new MostRecentResult<RoleListRole>(new List<RoleListRole>(), pagedResult.OriginalRequestDateTime, pagedResult.OriginalRequestDateTime);
        }
        public PagedEmailTemplateEmailViewModel(IPagedResult<EmailTemplateListTemplate> pagedResult, IMostRecentResult<EmailTemplateListTemplate> mostRecentResult)
        {
            PagedResult = pagedResult;
            MostRecentResult = mostRecentResult;

            if (mostRecentResult == null)
                MostRecentResult = new MostRecentResult<EmailTemplateListTemplate>(new List<EmailTemplateListTemplate>(), pagedResult.OriginalRequestDateTime, pagedResult.OriginalRequestDateTime);
        }
Example #13
0
 private int InitPagedResult(IPagedResult pagedResult, int count, int page)
 {
     pagedResult.Count       = count;
     pagedResult.Pagesize    = PageSize;
     pagedResult.Numpages    = CalculateNumPages(count);
     pagedResult.CurrentPage = pagedResult.Numpages >= page ? page : pagedResult.Numpages;
     return(pagedResult.CurrentPage * PageSize);
 }
Example #14
0
        public HttpResponseMessage MainFeed()
        {
            IPagedResult <PostDto> posts = this.postService.GetPosts(1, this.BlogConfiguration.ReadingConfiguration.NumberOfPostPerFeed);

            return(this.Request.CreateResponse(
                       HttpStatusCode.OK,
                       posts.Result,
                       new SyndicationFeedFormatter()));
        }
        /// <summary>
        /// 分页集合Dto
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="pageResult"></param>
        /// <returns></returns>
        public static PageList <T> ToPageList <T>(this IPagedResult <T> pageResult)
        {
            var result = pageResult;

            return(new PageList <T>()
            {
                ItemList = result.ItemList, Message = result.Message, Total = result.Total, Success = result.Success, Type = result.Type
            });
        }
Example #16
0
        protected ActionResult <IPagedResult <T> > Collection <T>(IPagedResult <T> pagedResult)
        {
            if (pagedResult == null)
            {
                return(NotFound());
            }

            return(Ok(pagedResult));
        }
        public void LoadAllEnabledPlugins()
        {
            IPagedResult <PluginDto> plugins = this.GetInstalledPlugin(1, 100);

            foreach (var plugin in plugins.Result)
            {
                this.EnablePlugin(plugin.Id, plugin.Version);
            }
        }
 protected IActionResult BuildDataTableJson <T>(IPagedResult <T> result)
 {
     return(Json(new
     {
         recordsTotal = result.TotalCount,
         recordsFiltered = result.FilteredCount,
         data = result
     }));
 }
        public void UnloadAllEnabledPlugins()
        {
            IPagedResult <PluginDto> plugins = this.GetInstalledPlugin(1, 100);

            foreach (var plugin in plugins.Result)
            {
                this.DisablePlugin(plugin.Id, plugin.Version);
            }

            throw new DexterRestartRequiredException(this.GetType());
        }
        public void Execute(IJobExecutionContext context)
        {
            IPagedResult <PluginDto> plugins = this.pluginService.GetInstalledPlugin(1, 1000);

            foreach (PluginDto plugin in plugins.Result)
            {
                PackageDto package = this.packageInstaller.Get(plugin.PackageId, plugin.Version);

                PluginDto p = package.MapPropertiesToInstance(plugin);

                this.pluginService.UpdatePlugin(p);
            }
        }
        protected override IActionResult RenderIndex(IPagedResult <RoleReadModel> model)
        {
            var indexModel = new RoleIndexViewModel
            {
                ItemList    = model.ItemList,
                TotalCount  = model.TotalCount,
                Permissions = ReadPermissionList()
            };

            return(Request.IsAjaxRequest()
                ? (IActionResult)PartialView(indexModel)
                : View(indexModel));
        }
        public IPagedResult <PostDto> GetPostsByDate(int pageIndex, int pageSize, int year, int?month, int?day, ItemQueryFilter filters = null)
        {
            if (pageIndex < 1)
            {
                throw new ArgumentException("The page index must be greater than 0", "pageIndex");
            }

            if (pageSize < 1)
            {
                throw new ArgumentException("The page size must be greater than 0", "pageSize");
            }

            if (year < 1700)
            {
                throw new ArgumentException("The year value must be greater than 1700. Internet did not exist in 1700!", "year");
            }

            if (month.HasValue && (month.Value < 1 || month.Value > 12))
            {
                throw new ArgumentException("The month value must be greater than 0 and lesser than 12", "month");
            }

            if (day.HasValue && (day.Value < 1 || day.Value > 31))
            {
                throw new ArgumentException("The day value must be greater than 0 and lesser than 31", "month");
            }

            if (filters == null)
            {
                filters = new ItemQueryFilter();
                filters.MaxPublishAt = DateTimeOffset.Now.AsMinutes();
                filters.Status       = ItemStatus.Published;
            }

            Tuple <int, int, int, int?, int?, ItemQueryFilter> p = new Tuple <int, int, int, int?, int?, ItemQueryFilter>(pageIndex, pageSize, year, month, day, filters);

            CancelEventArgsWithOneParameter <Tuple <int, int, int, int?, int?, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <int, int, int, int?, int?, ItemQueryFilter>, IPagedResult <PostDto> >(p, null);

            this.PostsRetrievingByDates.Raise(this, e);

            if (e.Cancel)
            {
                return(e.Result);
            }

            IPagedResult <PostDto> result = this.postDataService.GetPostsByDate(pageIndex, pageSize, year, month, day, filters);

            this.PostsRetrievedByDates.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));

            return(result);
        }
Example #23
0
        public HttpResponseMessage ByTag(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                this.RaiseNotFoundException("Invalid tag name");
            }

            IPagedResult <PostDto> posts = this.postService.GetPostsByTag(1, this.BlogConfiguration.ReadingConfiguration.NumberOfPostPerFeed, id);

            return(this.Request.CreateResponse(
                       HttpStatusCode.OK,
                       posts.Result,
                       new SyndicationFeedFormatter()));
        }
Example #24
0
        public void Execute(IJobExecutionContext context)
        {
            IPagedResult <PostDto> posts = postService.GetPosts(1, 50, new ItemQueryFilter
            {
                Status       = ItemStatus.Scheduled,
                MinPublishAt = DateTimeOffset.Now.AddMinutes(-5).AsMinutes(),
                MaxPublishAt = DateTimeOffset.Now
            });

            foreach (var post in posts.Result)
            {
                post.Status = ItemStatus.Published;
                postService.SaveOrUpdate(post);
            }
        }
Example #25
0
        protected BrowseHandlerTestBase()
        {
            Query          = new TQuery();
            ExpectedResult = new Mock <IPagedResult <TDto> >(MockBehavior.Strict).Object;

            _repoMock   = new Mock <TRepository>(MockBehavior.Strict);
            _mapperMock = new Mock <IMapper>(MockBehavior.Strict);

            _queryResult = new Mock <IPagedResult <TDomain> >(MockBehavior.Strict).Object;
            _repoMock.Setup(r => r.BrowseAsync(Query)).ReturnsAsync(_queryResult).Verifiable();
            _mapperMock.Setup(m => m.Map <IPagedResult <TDto> >(_queryResult)).Returns(ExpectedResult).Verifiable();

            Repository = _repoMock.Object;
            Mapper     = _mapperMock.Object;
        }
Example #26
0
 public PagedResult(
     int pageSize,
     int pageNumber,
     T result,
     Func <Task <IPagedResult <T> > > resultFactory,
     IPagedResult <T> previous = null,
     Func <IPagedResult <T>, Task <IPagedResult <T> > > next = null)
 {
     PageSize       = pageSize;
     PageNumber     = pageNumber;
     Result         = result;
     _resultFactory = resultFactory;
     Previous       = previous;
     _next          = next;
 }
        public ActionResult PostList(int pageIndex, int pageSize, ItemQueryFilter filter)
        {
            if (filter == null)
            {
                filter = new ItemQueryFilter
                {
                    MaxPublishAt = DateTimeOffset.Now.AddMonths(1).AsMinutes(),
                    MinPublishAt = DateTimeOffset.Now.AsMinutes(),
                    Status       = ItemStatus.Scheduled
                };
            }
            IPagedResult <PostDto> model = this.postService.GetPosts(1, 5, filter);

            return(this.View(model));
        }
Example #28
0
        public ActionResult FuturePosts(int maxItemsNumber)
        {
            IPagedResult <PostDto> items = this.postService.GetPosts(1, maxItemsNumber, new ItemQueryFilter
            {
                MinPublishAt = DateTimeOffset.Now.AsMinutes(),
                MaxPublishAt = DateTimeOffset.Now.AddYears(5).AsMinutes(),
                Status       = ItemStatus.Scheduled
            });

            FuturePostsViewModel model = new FuturePostsViewModel
            {
                Posts = items
            };

            return(this.View(model));
        }
        public IPagedResult <PostDto> GetPostsByTag(int pageIndex, int pageSize, string tag, ItemQueryFilter filters = null)
        {
            if (pageIndex < 1)
            {
                throw new ArgumentException("The page index must be greater than 0", "pageIndex");
            }

            if (pageSize < 1)
            {
                throw new ArgumentException("The page size must be greater than 0", "pageSize");
            }

            if (tag == null)
            {
                throw new ArgumentNullException("tag", "The string tag must contains a value");
            }

            if (tag == string.Empty)
            {
                throw new ArgumentException("The string tag must not be empty", "tag");
            }

            if (filters == null)
            {
                filters = new ItemQueryFilter();
                filters.MaxPublishAt = DateTimeOffset.Now.AsMinutes();
                filters.Status       = ItemStatus.Published;
            }

            CancelEventArgsWithOneParameter <Tuple <int, int, string, ItemQueryFilter>, IPagedResult <PostDto> > e = new CancelEventArgsWithOneParameter <Tuple <int, int, string, ItemQueryFilter>, IPagedResult <PostDto> >(new Tuple <int, int, string, ItemQueryFilter>(pageIndex, pageSize, tag, filters), null);

            this.PostsRetrievingByTag.Raise(this, e);

            if (e.Cancel)
            {
                this.logger.DebugAsync("The result of the method 'GetPostsByTag' is overridden by the event 'PostsRetrievingByTag'.");
                return(e.Result);
            }

            IPagedResult <PostDto> result = this.postDataService.GetPostsByTag(pageIndex, pageSize, tag, filters);

            this.PostsRetrievedByTag.Raise(this, new GenericEventArgs <IPagedResult <PostDto> >(result));

            return(result);
        }
Example #30
0
        public void SetList <T>(IPagedResult <T> pagedResult)
        {
            GridModelList.Clear();

            foreach (var item in mapper.Map <List <T> >(pagedResult.Items))
            {
                GridModelList.Add(item);
            }

            if (pagedResult.TotalCount == 0)
            {
                PageCount = 1;
            }
            else
            {
                PageCount = (int)Math.Ceiling(pagedResult.TotalCount / (double)PageSize);
            }
        }
        private string GetLinkHeader(IPagedResult result)
        {
            var first = GetPageLink(result.CurrentPage, 1);
            var last  = GetPageLink(result.CurrentPage, result.TotalPages);
            var prev  = string.Empty;
            var next  = string.Empty;

            if (result.CurrentPage > 1 && result.CurrentPage <= result.TotalPages)
            {
                prev = GetPageLink(result.CurrentPage, result.CurrentPage - 1);
            }
            if (result.CurrentPage < result.TotalPages)
            {
                next = GetPageLink(result.CurrentPage, result.CurrentPage + 1);
            }

            return($"{FormatLink(next, "next")}{FormatLink(last, "last")}" +
                   $"{FormatLink(first, "first")}{FormatLink(prev, "prev")}");
        }
        public static MvcHtmlString PagedSummary <T>(this IPagedResult <T> result)
        {
            long total = result.TotalCount;
            int  min   = (result.PageIndex - 1) * result.PageSize;

            if (min == 0)
            {
                min = 1;
            }

            long max = ((result.PageIndex - 1) * result.PageSize) + result.PageSize;

            if (result.TotalCount < max)
            {
                max = result.TotalCount;
            }

            return(new MvcHtmlString(string.Format("Results {0} - {1} out of {2}", min, max, total)));
        }
        public static MvcHtmlString Pager <T>(this HtmlHelper helper, IPagedResult <T> result)
        {
            if (result.TotalPages == 1)
            {
                return(new MvcHtmlString(string.Empty));
            }

            StringBuilder sb = new StringBuilder();

            sb.Append("<ul class=\"controls-buttons\">");

            if (result.HasPreviousPage)
            {
                string previousImageUrl = helper.ViewContext.HttpContext.Server.MapPath("~/images/icons/fugue/navigation-180.png");
                sb.Append("<li>");
                sb.AppendFormat("<a href=\"{0}\" title=\"Previous\">", "#");
                sb.AppendFormat("<img src=\"{0}\" width=\"16\" height=\"16\">", previousImageUrl);
                sb.Append("Prev");
                sb.Append("</a>");
                sb.Append("</li>");
            }

            for (int i = 0; i < result.TotalPages; i++)
            {
                sb.AppendFormat("<li><a href=\"{0}\" title=\"Page {1}\"><b>{1}</b></a></li>", "#", i + 1);
            }

            if (result.HasNextPage)
            {
                string nextImageUrl = helper.ViewContext.HttpContext.Server.MapPath("~/images/icons/fugue/navigation.png");
                sb.Append("<li>");
                sb.AppendFormat("<a href=\"{0}\" title=\"Next\">", "#");
                sb.AppendFormat("<img src=\"{0}\" width=\"16\" height=\"16\">", nextImageUrl);
                sb.Append("Next");
                sb.Append("</a>");
                sb.Append("</li>");
            }

            sb.Append("<ul>");

            return(new MvcHtmlString(sb.ToString()));
        }
Example #34
0
        public async Task <IPagedResult <GetUserNormOutput> > Query(QueryUserInput query)
        {
            IPagedResult <GetUserNormOutput> queryResultOutput = null;

            if (!query.OrgId.HasValue || query.OrgId == 0)
            {
                var queryPageResult = await _userRepository.GetPageAsync(p => p.UserName.Contains(query.SearchKey) ||
                                                                         p.ChineseName.Contains(query.SearchKey) ||
                                                                         p.Email.Contains(query.SearchKey) ||
                                                                         p.Phone.Contains(query.SearchKey), query.PageIndex, query.PageCount);

                queryResultOutput = queryPageResult.Item1.WhereIf(query.Status.HasValue, p => p.Status == query.Status.Value).MapTo <IEnumerable <GetUserNormOutput> >().GetPagedResult(queryPageResult.Item2);
            }
            else
            {
                var subOrgIds = await GetService <IOrganizationAppService>().GetSubOrgIds(query.OrgId.Value);

                // :todo 优化
                var queryResult = await _userRepository.GetAllAsync(p => p.UserName.Contains(query.SearchKey) ||
                                                                    p.ChineseName.Contains(query.SearchKey) ||
                                                                    p.Email.Contains(query.SearchKey) ||
                                                                    p.Phone.Contains(query.SearchKey));

                queryResult       = queryResult.Where(p => subOrgIds.Any(q => q == p.OrgId)).WhereIf(query.Status.HasValue, p => p.Status == query.Status.Value);
                queryResultOutput = queryResult.MapTo <IEnumerable <GetUserNormOutput> >().PageBy(query);
            }
            foreach (var userOutput in queryResultOutput.Items)
            {
                if (userOutput.OrgId.HasValue)
                {
                    userOutput.DeptName = (await GetService <IDepartmentAppService>().GetByOrgId(userOutput.OrgId.Value)).Name;
                }
                if (userOutput.PositionId.HasValue)
                {
                    userOutput.PositionName = (await GetService <IPositionAppService>().Get(userOutput.PositionId.Value)).Name;
                }
                userOutput.Roles = (await _userDomainService.GetUserRoles(userOutput.Id)).MapTo <IEnumerable <GetDisplayRoleOutput> >();
            }

            return(queryResultOutput);
        }
        protected IActionResult Collection <T>(IPagedResult <T> pagedResult, Func <IPagedResult <T>, bool> criteria = null)
        {
            if (pagedResult == null)
            {
                return(NotFound());
            }
            var isValid = criteria == null || criteria(pagedResult);

            if (!isValid)
            {
                return(NotFound());
            }
            if (pagedResult.IsEmpty)
            {
                return(Ok(Enumerable.Empty <T>()));
            }
            Response.Headers.Add("link", GetLinkHeader(pagedResult));
            Response.Headers.Add("x-total-count", pagedResult.TotalResults.ToString());

            return(Ok(pagedResult.Items));
        }
 public PagedExceptionListViewModel(IPagedResult<ExceptionList> pagedResult)
     : this(pagedResult, null)
 {}
 public PagedRoleListRoleViewModel(IPagedResult<RoleListRole> pagedResult)
     : this(pagedResult, null)
 {}
 public PagedEmailTemplateEmailViewModel(IPagedResult<EmailTemplateListTemplate> pagedResult)
     : this(pagedResult, null)
 {}
 public PagedEmailDispatchListEmailMessageViewModel(IPagedResult<EmailDispatchListEmailMessage> pagedResult)
     : this(pagedResult, null)
 {}
 public PagedUserListUserViewModel(IPagedResult<AuthenticationUserListUser> pagedResult)
     : this(pagedResult, null)
 {}
 public PagedNewsListNewsArticleViewModel(IPagedResult<NewsListNewsArticle> pagedResult)
     : this(pagedResult, null)
 {}