Пример #1
0
        /// <summary>
        /// createdUserIdが作成したRefListを返します。
        /// </summary>
        public async Task <PagedRefLists> GetRefListsAsync(GetRefListsRequest req)
        {
            var query = _refsContext.RefLists.Include("Author").Include("TagUses.Tag").Include("Statistics").AsNoTracking();

            query = AppendQueryForAuthorId(query, req.AuthorId);
            query = AppendQueryForAuthorUserName(query, req.AuthorUserName);
            query = AppendQueryForTagUseId(query, req.TagUseId);
            query = AppendQueryForTagName(query, req.TagName, req.TagUseId);
            query = AppendQueryForFromDate(query, req.FromDate);
            query = AppendQueryForSearchText(query, req.TitleSearch);
            query = AppendQueryForPublishingStatus(query, req.PublishingStatusCondition);

            var storedRefListCount = await query.CountAsync();

            query = QueryUtil.AppendQueryForRefListSort(query, req.Sort);

            query = query.Skip(req.PageIndex * req.PageSize);
            query = query.Take(req.PageSize);

            var storedLists = await query.ToArrayAsync();

            var ret = new PagedRefLists()
            {
                PageIndex       = req.PageIndex,
                PageCount       = IndexUtil.GetPageCount(storedRefListCount, req.PageSize),
                AllRefListCount = storedRefListCount,
                RefLists        = storedLists,
            };

            return(ret);
        }
Пример #2
0
        public async Task <PagedRefLists> GetAllFavoriteRefListsAsync(long ownerId, PageCondition pageCondition, RefListSortKind sort)
        {
            var refListIdsQuery = _refsContext.Favorites.
                                  Where(f => f.OwnerId == ownerId && f.Kind == FavoriteKind.RefList).
                                  Select(f => f.RefListId.Value);
            var refListIds = await refListIdsQuery.ToArrayAsync();

            var tagIdsQuery = _refsContext.Favorites.
                              Where(f => f.OwnerId == ownerId && f.Kind == FavoriteKind.Tag).
                              Select(f => f.TagId.Value);
            var tagIds = await tagIdsQuery.ToArrayAsync();

            var userIdsQuery = _refsContext.Favorites.
                               Where(f => f.OwnerId == ownerId && f.Kind == FavoriteKind.User).
                               Select(f => f.UserId.Value);
            var userIds = await userIdsQuery.ToArrayAsync();

            var query = _refsContext.RefLists.AsNoTracking().
                        Where(l =>
                              l.PublishingStatus == PublishingStatusKind.Publish &&
                              (
                                  refListIds.Contains(l.Id) ||
                                  tagIds.Intersect(l.TagUses.Select(u => u.TagId)).Any() ||
                                  userIds.Contains(l.AuthorId)
                              )
                              );

            var refListCount = await query.CountAsync();

            query = QueryUtil.AppendQueryForRefListSort(query, sort);

            query = query.Skip(pageCondition.PageIndex * pageCondition.PageSize);
            query = query.Take(pageCondition.PageSize);

            var storedRefList = await query.ToArrayAsync();

            return(new PagedRefLists()
            {
                PageIndex = pageCondition.PageIndex,
                PageCount = IndexUtil.GetPageCount(refListCount, pageCondition.PageSize),
                RefLists = storedRefList,
                AllRefListCount = refListCount,
            });
        }