/// <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));
}
