public async Task <IList <ChatDbModel> > GetChatsAsync(BoxId boxId, GetChatsFilter getChatsFilter)
        {
            var builder = Builders <ChatDbModel> .Filter;
            var filter  = builder.Eq("To._id._id", boxId.Id) & builder.Eq("To._id.Type", boxId.Type);

            if (getChatsFilter.DateGt.HasValue)
            {
                filter = filter & builder.Gt(p => p.UpdateDate, getChatsFilter.DateGt.Value);
            }

            if (getChatsFilter.DateLt.HasValue)
            {
                filter = filter & builder.Lt(p => p.UpdateDate, getChatsFilter.DateLt.Value);
            }

            var sort = Builders <ChatDbModel> .Sort.Descending(x => x.UpdateDate);

            var cursor = _chats.Find(filter);

            cursor.Sort(sort);

            cursor.Limit(getChatsFilter.Limit);
            var chats = await cursor.ToListAsync();

            // TODO remove
            foreach (var chatDbModel in chats)
            {
                if (chatDbModel.LastReads == null)
                {
                    chatDbModel.LastReads = new List <Read>();
                    await _chats.ReplaceOneAsync(new BsonDocument("_id", new Guid(chatDbModel.Id)), chatDbModel);
                }
            }

            return(chats);
        }
示例#2
0
        protected override async Task ActionAsync()
        {
            var boxId = Input.Data.BoxId;

            if (boxId.Type == TypeBox.Site)
            {
                await UserSecurity.CheckAdministratorAsync(_userService, Input.UserId, boxId.Id);
            }
            else if (boxId.Type == TypeBox.User)
            {
                if (boxId.Id != Input.UserId)
                {
                    throw new NotAuthorizedException("You are not authorized to process this action.");
                }
            }

            var limit = 20;

            var getChatsFilter = new GetChatsFilter
            {
                Limit = limit
            };

            var filterDate = Input.Data.Filter.Date;

            if (filterDate.HasValue)
            {
                if (Input.Data.Filter.IsPrevious)
                {
                    getChatsFilter.DateGt = filterDate.Value.ToLocalTime();
                }
                else
                {
                    getChatsFilter.DateLt = filterDate.Value.ToLocalTime();
                }
            }
            else
            {
                getChatsFilter.DateLt = DateTime.Now;
            }

            var chats = await _messageService.GetChatsAsync(boxId, getChatsFilter);

            var chatsResult = new List <ChatItem>();

            foreach (var chat in chats)
            {
                try
                {
                    var chatItem = await MapChatItem(_logger, _sitemap, _userService, chat, Input.UserId);

                    chatsResult.Add(chatItem);
                }
                catch (Exception exception)
                {
                    _logger.LogError(exception, "Exception deserialize message ChatItem json");
                }
            }

            var lastItem  = chatsResult.OrderBy(c => c.LastMessageDate).FirstOrDefault();
            var firstItem = chatsResult.OrderByDescending(c => c.LastMessageDate).FirstOrDefault();

            var  datePrevious = firstItem?.LastMessageDate;
            var  dateNext     = lastItem?.LastMessageDate;
            long nbNext       = 0;
            long nbPrevious   = 0;

            if (datePrevious.HasValue)
            {
                nbPrevious =
                    await _messageService.CountChatAsync(boxId, new CountChatFilters { DateGt = datePrevious.Value });
            }
            if (dateNext.HasValue)
            {
                nbNext = await _messageService.CountChatAsync(boxId, new CountChatFilters { DateLt = dateNext.Value });
            }

            Result.Data                = new ListMessageResult();
            Result.Data.Chats          = chatsResult;
            Result.Data.NumberNext     = nbNext;
            Result.Data.DatePrevious   = datePrevious;
            Result.Data.NumberPrevious = nbPrevious;
            Result.Data.DateNext       = dateNext;
        }