/// <summary> /// Pass current chat messages count instead of page size. /// </summary> public override async Task <IList <ChatMessageModel> > GetOlderMessagesAsync(MessagesQuery query) { await Task.Yield(); //await Task.Delay(1000); int messagesCount = 100; var testMessages = new List <ChatMessageModel>(); var l = new List <int>(); for (int i = query.Count.Value; i < query.Count.Value + messagesCount; i++) { l.Add(i); } for (int i = query.Count.Value; i < query.Count.Value + messagesCount; i++) { var hoursOffset = l[i - query.Count.Value]; var time = DateTimeOffset.Now.AddHours(-hoursOffset); testMessages.Add(new ChatMessageModel { Id = i.ToString(), Body = i.ToString(), DateTime = time }); } return(testMessages); }
public Task <List <ChatMessageModel> > GetOlderMessagesAsync(MessagesQuery query) { var messagesCollection = GetMessagesCollectionForChat(query.ChannelId); return(Task.FromResult(ModifyCollection(messagesCollection, collection => { // find older message than var indexFrom = collection.FindIndex(x => x.Id == query.FromId); if (indexFrom < 0) { indexFrom = collection.FindLastIndex(x => x.DateTime.DateTime.IsEarlierOrEqualThan(query.FromDateTime.Value.DateTime)); } var count = query.Count.Value; if (indexFrom > count) { return collection.Skip(indexFrom - count).Take(count).ToList(); } if (indexFrom > 0) { return collection.Take(indexFrom).ToList(); } return new List <ChatMessageModel>(); }))); }
// TODO YP: check frequency of call this method private async Task LoadOlderMessagesAsync() { if (_areOlderMessagesLoaded) { return; } var oldestMessage = Messages.FirstOrDefaultValue(); if (oldestMessage == null) { await LoadInitialMessagesAsync(); return; } var query = new MessagesQuery { ChannelId = _chatId, FromId = oldestMessage.Id, FromDateTime = oldestMessage.DateTime, Count = OlderMessagesBatchCount }; var olderMessages = await _chatManager.LoadOlderMessagesAsync(query); if (olderMessages.Any()) { AddMessages(olderMessages); } else { // empty list = no old messages _areOlderMessagesLoaded = true; } }
public void CompareLinesInDatabaseTest() { var options = new DbContextOptionsBuilder <SqlApplicationDbContext>() .UseInMemoryDatabase(databaseName: "CompareLinesInDatabaseTest") .Options; using (SqlApplicationDbContext context = new SqlApplicationDbContext(options)) { //Arrange var hashtag = new HashTagWord("microsoft"); var handler = new EfMessagesGetQueryHandler(context); var query = new MessagesQuery { HashTag = hashtag }; var mapper = new EntityToMessagesResultMapper(); var data = GetData(hashtag); InsertData(data, context); context.SaveChanges(); //Act var result = handler.Handle(query); MessagesQueryResult mappedResult = mapper.MapBunch(data, hashtag); //Assert Assert.Equal(mappedResult.Messages, result.Result.Messages); } }
public async Task <IEnumerable <MessageViewModel> > Get(string hashtag) { var query = new MessagesQuery { HashTag = new HashTagWord(hashtag) }; var result = await mediator.Send(query); return(Mapper.Map <IEnumerable <MessageViewModel> >(result.Messages)); }
public async Task <List <Message> > GetChannelMessagesAsync(int channelId) { var messages = await Task.Run(async() => { var messageQuery = new MessagesQuery(_connection); var result = await messageQuery.ExecuteAsync(channelId); return(result); }); return(messages); }
public async Task <MessagesQueryResult> Handle(MessagesQuery query) { var mapper = new EntityToMessagesResultMapper(); var messages = await Context.Messages .Where( message => message.MessageHashTagRelations.Any( rel => rel.HashTagEntity.HashTag == query.HashTag.TagWithHash) ) .ToListAsync(); return(mapper.MapBunch(messages, query.HashTag)); }
public Task <IList <ChatMessageModel> > GetMessagesFromAsync(MessagesQuery query) { var messagesQuery = new GetMessagesQuery { ChannelId = query.ChannelId, FromId = query.FromId, FromDateTime = query.FromDateTime, Count = query.Count }; var request = new GetMessagesRequest(_chatConfig.ApiUrl, messagesQuery); return(LoadMessagesAsync(request)); }
public async Task <IActionResult> Index(MessagesQuery query, CancellationToken cancellationToken) { var senders = await MailAppDbContext.Accounts .ToArrayAsync(cancellationToken); var owner = await AccountProvider.GetAccountForCurrentUser(cancellationToken); var messages = await MailAppDbContext.Messages .Include(x => x.MessagePersons) .ThenInclude(x => x.Account) .ToArrayAsync(cancellationToken); messages = messages .Where(x => query.SenderId == null || x.Sender.Id == query.SenderId) .Where(x => x.MessagePersons.Any(y => y.Type != MessagePersonType.Sender && y.Account == owner)) .ToArray(); if (!String.IsNullOrEmpty(query.Search)) { foreach (var part in query.Search.Split(" ")) { messages = messages.Where(x => (x.Subject + x.Text).Contains(part)).ToArray(); } } messages = query.Sort switch { MessagesQuery.SortingOptions.Subject => messages.OrderBy(x => x.Subject).ToArray(), MessagesQuery.SortingOptions.Date => messages.OrderBy(x => x.SentDate).ToArray(), MessagesQuery.SortingOptions.Nick => messages.OrderBy(x => x.Sender.Nick).ToArray(), _ => messages.OrderBy(x => x.SentDate).ToArray() }; var viewModel = new MessagesListViewModel { SenderId = query.SenderId, Senders = senders .Select(x => new AccountViewModel(x)) .ToArray(), MessageList = new MessageListViewModel { Messages = messages .Select(x => new MessageViewModel(x, owner)) .ToArray(), } }; return(View(viewModel)); }
public void QueryMessages() { WebmasterToolsService service = new WebmasterToolsService(this.ApplicationName); service.Credentials = new GDataCredentials(this.userName, this.passWord); MessagesQuery feedQuery = new MessagesQuery(); MessagesFeed feed = service.Query(feedQuery); Assert.GreaterOrEqual(feed.Entries.Count, 0); foreach (MessagesEntry entry in feed.Entries) { Assert.IsNotNull(entry.Id); } }
public async Task <IList <ChatMessageViewModel> > LoadOlderMessagesAsync(MessagesQuery query) { var models = await _messagesCache.GetOlderMessagesAsync(query).ConfigureAwait(false); if (models.Count > 0) { return(CreateMessagesViewModels(models)); } var olderMessagesModels = await _chatService.GetOlderMessagesAsync(query).ConfigureAwait(false); if (olderMessagesModels != null && olderMessagesModels.Any()) { await _messagesCache.SaveMessagesAsync(query.ChannelId, olderMessagesModels).ConfigureAwait(false); // TODO YP: check recursion return(await LoadOlderMessagesAsync(query).ConfigureAwait(false)); } return(new List <ChatMessageViewModel>()); }
private async Task <IList <ChatMessageModel> > TryLoadLatestMessagesAsync( string chatId, string oldestMessageId, DateTimeOffset oldestMessageDate) { var messages = default(IList <ChatMessageModel>); try { var query = new MessagesQuery { ChannelId = chatId, FromId = oldestMessageId, FromDateTime = oldestMessageDate }; messages = await _getMessagesAsync.RunAsync(query).ConfigureAwait(false); } catch (Exception ex) { _logger.Error(ex); } return(messages); }
public async Task <ActionResult <PaginatedList <ConversationMessageDto> > > GetMessages( [FromQuery] MessagesQuery query) { return(await Mediator.Send(query)); }
public Task <IList <ChatMessageModel> > GetMessagesFromAsync(MessagesQuery query) { throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <returns>a feed of Messages objects</returns> public Feed <Messages> GetMessages() { MessagesQuery q = PrepareQuery <MessagesQuery>(MessagesQuery.HttpsFeedUrl); return(PrepareFeed <Messages>(q)); }