public async Task <List <ChatConversation> > GetChatConversationsAsync(ChatHistoryFilterModel filter)
        {
            try {
                /* TO DO
                 *  optimize the query with aggregation framework*/
                var chat = await _chats.Find(c => c.Id == filter.ChatId).FirstOrDefaultAsync();

                if (filter.DirectionType == KeysetFilterModelType.Next)
                {
                    chat.ChatConversations = chat.ChatConversations
                                             .Where(conversation => conversation.Date.CompareTo(filter.EdgeDateTime) > 0)
                                             .OrderBy(o => o.Date).Take(filter.Limit).ToList();
                }
                else
                {
                    chat.ChatConversations = chat.ChatConversations
                                             .Where(conversation => conversation.Date.CompareTo(filter.EdgeDateTime) < 0)
                                             .OrderByDescending(o => o.Date).Take(filter.Limit).Reverse().ToList();
                }
                var query = from conversation in chat.ChatConversations.AsQueryable()
                            join user in _users.AsQueryable() on
                            conversation.UserId equals user.Id into ConversationUser
                            select new ChatConversation()
                {
                    Id     = conversation.Id,
                    UserId = conversation.UserId,
                    Text   = conversation.Text,
                    FileId = conversation.FileId,
                    Date   = conversation.Date,
                    ParentConversationId    = conversation.ParentConversationId,
                    ChatConversationReaders = conversation.ChatConversationReaders,
                    User = ConversationUser.Select(conversationUser => new User()
                    {
                        Id = conversationUser.Id, FullName = conversationUser.FullName
                    }).FirstOrDefault()
                };
                return(await Task.FromResult(query.ToList()));

                //return await Task.FromResult(query.Skip(pageIndex * pageSize).Take(pageSize).ToList());
            } catch (Exception ex) {
                _logger.LogError(ex, "GetChatConversationsAsync ChatRepository Exception");
                return(null);
            }
        }
        public async Task <ConversationFilteredResultVM> GetChatConversations(ChatHistoryFilterModel filter)
        {
            var chatConversations = await _chatRepository.GetChatConversationsAsync(filter);

            ConversationFilteredResultVM result = new ConversationFilteredResultVM()
            {
                Result = chatConversations
            };

            filter.EdgeDateTime  = chatConversations.FirstOrDefault()?.Date ?? DateTime.Now;
            filter.DirectionType = KeysetFilterModelType.Previous;
            var previousUrl = _linkGenerator.GetUriByAction(HttpContext, null, null, filter, HttpContext.Request.Scheme);

            result.PreviousUri = new Uri(previousUrl);

            filter.EdgeDateTime  = chatConversations.LastOrDefault()?.Date ?? DateTime.Now;
            filter.DirectionType = KeysetFilterModelType.Next;
            var nextUrl = _linkGenerator.GetUriByAction(HttpContext, null, null, filter, HttpContext.Request.Scheme);

            result.NextUri = new Uri(nextUrl);

            return(result);
        }
示例#3
0
        public async Task <ActionResult <ConversationFilteredResultVM> > GetChatConversations(string chatId, [FromQuery] ChatHistoryFilterModel model)
        {
            try {
                model.ChatId = chatId;
                var chatConversations = await _chatService.GetChatConversations(model);

                return(chatConversations);
            } catch {
            }
            return(NotFound());
        }