public async Task <IActionResult> GetIdeaList(ProfileFilterViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var result = await _profileService.GetListAsync(model);

            if (!result.Succeeded)
            {
                return(BadRequest(result.Errors));
            }

            return(Ok(result.Value));
        }
        public async Task <ProcessResult <List <IdeaViewModel> > > GetListAsync(ProfileFilterViewModel model)
        {
            Func <Task <List <IdeaViewModel> > > action = async() =>
            {
                var user = await this.userManager.FindByNameAsync(model.UserName);

                IQueryable <Idea> result = context.Ideas.Where(x => x.CreatorId == user.Id && (!x.IsDeleted || x.CreatorId == CurrentUser.Id));
                var takeSize             = model.TakeSize ?? 10;
                var currentUserId        = CurrentUser?.Id ?? 0;

                switch (model.Kind)
                {
                case Kind.Shared:
                    result = result.OrderByDescending(x => x.Id);
                    if (model.LastIdeaId != null)
                    {
                        result = result.Where(x => x.Id < model.LastIdeaId);
                    }
                    break;

                case Kind.Favorited:
                    IQueryable <relIdeaFavorite> favorited = context.relIdeaFavorites.Where(x => x.CreatorId == user.Id && !x.IsDeleted)
                                                             .OrderByDescending(x => x.CreateDate);

                    if (model.LastIdeaId != null)
                    {
                        var lastFavoritedCreateDate = await favorited.Where(x => x.IdeaId == model.LastIdeaId)
                                                      .Select(x => x.CreateDate)
                                                      .SingleAsync();

                        favorited = favorited.Where(x => x.CreateDate < lastFavoritedCreateDate);
                    }

                    result = favorited.Select(x => x.Idea);
                    break;

                default:
                    throw new ArgumentOutOfRangeException("filter value is not valid");
                }

                var ideaList = await result.Include(x => x.Tags)
                               .Include(x => x.Likes)
                               .Include(x => x.Comments)
                               .Include(x => x.Favorites)
                               .Take(takeSize)
                               .Select(x => new IdeaViewModel
                {
                    Id      = x.Id,
                    Title   = x.Title,
                    Article = x.Article,
                    Tags    = x.Tags.Where(t => !t.IsDeleted).Select(t => new TagViewModel
                    {
                        Id   = t.TagId,
                        Name = t.Tag.Name
                    }).ToList(),
                    Creator = new CreatorViewModel()
                    {
                        Id        = x.CreatorId,
                        Name      = x.CreatorUser.UserName,
                        AvatarURL = String.IsNullOrEmpty(x.CreatorUser.AvatarURL) ? "person.png" : x.CreatorUser.AvatarURL
                    },
                    CreatedDate     = x.CreateDate,
                    CurrentUserLike = x.Likes.Where(l => l.CreatorId == currentUserId)
                                      .Select(l => l.Vote).SingleOrDefault(),
                    CurrentUserIsFavorited = x.Favorites.Where(f => f.CreatorId == CurrentUser.Id)
                                             .Select(f => f.Value).SingleOrDefault(),
                    LikeCount    = x.LikeCount,
                    ViewCount    = x.ViewCount,
                    CommentCount = x.Comments.Where(c => !c.IsDeleted || c.CreatorId == CurrentUser.Id).Count(),
                    IsDeleted    = x.IsDeleted
                }).ToListAsync();

                return(ideaList);
            };

            return(await Process.RunAsync(action));
        }