public async Task <IActionResult> GetAsync(Guid recieverId, [FromQuery] GetMessagesQuery query)
{
query.Reciever = recieverId;
var results = await DispatchQueryAsync <GetMessagesQuery, PaginationDto <MessageDto> >(query);
return(Ok(results));
}
public async Task GetStatisticsPerPeriod(DiscordRequest request, Contexts contexts)
{
var period = _reportsService.SelectPeriod(request.Arguments.FirstOrDefault()?.Value);
if (implementedBySplitter.Contains(period))
{
var query = new GetMessagesStatisticsQuery(period);
var result = await this._queryBus.ExecuteAsync(query);
var periodStats = result.PeriodStatistics.Where(x => x.Count > 0); // todo
return;
}
var getMessages = new GetMessagesQuery(contexts.Server.Id);
var messages = this._queryBus.Execute(getMessages).Messages.ToList();
var report = _reportsService.CreateReport(messages, period);
Log.Information("Generated statistics for time range {start} {end}", report.TimeRange.Start, report.TimeRange.End);
#if DEBUG
PrintDebugStats(report);
#endif
var path = _chartsService.GetImageStatisticsPerPeriod(report);
var messagesService = _messagesServiceFactory.Create(contexts);
await messagesService.SendFile(path);
}
public async Task GetStatisticsPerPeriod(StatsCommand statsCommand, Contexts contexts)
{
var period = this._reportsService.SelectPeriod(statsCommand);
if (this.implementedBySplitter.Contains(period))
{
var query = new GetMessagesStatisticsQuery(period);
var result = await this._queryBus.ExecuteAsync(query);
var periodStats = result.PeriodStatistics.Where(x => x.Count > 0);
return;
}
var getMessages = new GetMessagesQuery(contexts.Server.Id);
var messages = this._queryBus.Execute(getMessages).Messages.ToList();
var report = this._reportsService.CreateReport(messages, period);
Log.Information("Generated statistics for time range {start} {end}", report.TimeRange.Start, report.TimeRange.End);
#if DEBUG
PrintDebugStats(report);
#endif
var stream = await this._chartsService.GetImageStatisticsPerPeriod(report);
var messagesService = this._messagesServiceFactory.Create(contexts);
await messagesService.SendFile("Statistics.png", stream);
}
private async Task UpdateMessages()
{
var getAllMessagesQuery = new GetMessagesQuery(GetMessagesQuery.GET_ALL_SERVERS);
var messages = this._queryBus.Execute(getAllMessagesQuery).Messages;
await this.UpdateSafetyUsersStates(messages);
}
public IActionResult GetMessages(GetMessagesQuery query)
{
return(Ok(new GetMessagesResult {
Messages = new List <MessageRemoteDto>(),
UserCount = 10
}));
}
public ChatViewModel(INavigationService navigationService,
IRepository <Message> messageRepository,
ChatbotViewModel chatbotViewModel,
ICommandFactory commandFactory,
IDialogService dialogService,
IQueryFactory queryFactory,
ChatBoxViewModel message)
: base(navigationService)
{
Guard.Against.Null(navigationService, nameof(navigationService));
Guard.Against.Null(messageRepository, nameof(messageRepository));
Guard.Against.Null(chatbotViewModel, nameof(chatbotViewModel));
Guard.Against.Null(commandFactory, nameof(commandFactory));
Guard.Against.Null(dialogService, nameof(dialogService));
Guard.Against.Null(queryFactory, nameof(queryFactory));
Guard.Against.Null(message, nameof(message));
ChatbotViewModel = chatbotViewModel;
_dialogService = dialogService;
Messages = messageRepository;
ChatBoxViewModel = message;
Title = "Chat Page";
SendMessage = commandFactory
.MakeDelegateWithParameter <SendMessageCommand, IChatBoxModel>();
GotoOptions = new DelegateCommand(GotoOptionsCommand);
_getMessagesQuery = queryFactory.MakeQuery <GetMessagesQuery>();
}
private IReadOnlyList <Message> GetMessages(ulong serverId)
{
var query = new GetMessagesQuery(serverId);
var messages = this.queryBus.Execute(query).Messages.ToList();
return(messages);
}
public async Task GenerateStatsForDaysBefore(DiscordServerContext server, DateTime?lastInitDate)
{
var dayStatisticsQuery = new GetServerDayStatisticsQuery(server.Id);
var allServerDaysStatistics = (await this._queryBus.ExecuteAsync(dayStatisticsQuery)).ServerDayStatistics.ToList();
var startDate = lastInitDate ?? DateTime.UnixEpoch;
var messagesQuery = new GetMessagesQuery(server.Id)
{
SentDate = new TimeRange(startDate, DateTime.Today) // it will exclude today - it should generate today's stats tomorrow
};
var messages = this._queryBus.Execute(messagesQuery).Messages;
var messagesNotCachedForStats = messages
.Where(message => allServerDaysStatistics.All(s => message.SentAt.Date != s.Date));
var serverStatistics = messagesNotCachedForStats
.GroupBy(x => x.SentAt.Date)
.Select(x => new ServerDayStatistic(x.ToList(), server.Id, x.Key));
var commands = serverStatistics.Select(x => new AddServerDayStatisticCommand(x));
foreach (var command in commands)
{
await this._commandBus.ExecuteAsync(command);
}
}
private void ReloadCache()
{
var getAllMessagesQuery = new GetMessagesQuery(GetMessagesQuery.GET_ALL_SERVERS);
var messages = this._queryBus.Execute(getAllMessagesQuery).Messages;
var groupedServerMessages = this.GroupMessagesByServers(messages);
this.UpdateServerMessagesCounts(groupedServerMessages);
this._lastUpdated = DateTime.UtcNow;
}
public async Task <IEnumerable <MessageDto> > GetMessages([FromBody] GetMessagesRequest request)
{
var query = new GetMessagesQuery(request.GetGuildId, request.GetChannelId, request.GetUserId ?? 0);
var responseResult = await this._queryBus.ExecuteAsync(query);
var messagesDto = responseResult.Messages.Take(LIMIT_FOR_QUERY).Select(x => new MessageDto(x));
return(messagesDto);
}
public void GuardsAgainstNullUnitOfWork()
{
Action action = () =>
_ = new GetMessagesQuery(_chatbotService.Object, null);
action.Should()
.Throw <ArgumentNullException>()
.WithMessage("Value cannot be null. (Parameter 'unitOfWork')");
}
private void ReloadCache()
{
var getAllMessagesQuery = new GetMessagesQuery(0);
var messages = _queryBus.Execute(getAllMessagesQuery).Messages;
var groupedServerMessages = GroupMessagesByServers(messages);
UpdateServerMessagesCounts(groupedServerMessages);
_lastUpdated = DateTime.UtcNow;
}
public Task <IList <ChatMessageModel> > GetAllMessagesAsync(string chatId)
{
var query = new GetMessagesQuery
{
ChannelId = chatId,
};
var request = new GetMessagesRequest(_chatConfig.ApiUrl, query);
return(LoadMessagesAsync(request));
}
public async Task GetMessages_WhenCalled_FilterOutInvalidItems()
{
// Arrange
var airTableService = Substitute.For <IAirTableService>();
var mapperConfiguration = new MapperConfiguration(cfg =>
{
cfg.AddProfile <MessageMapper>();
});
IMapper mapper = mapperConfiguration.CreateMapper();
var command = new GetMessagesQuery();
var handler = new GetMessagesQuery.GetMessagesQueryHandler(airTableService, mapper);
var response = new AirTableGetResponseDTO()
{
records = new List <RecordsDTO>()
{
new RecordsDTO()
{
id = "recCR2LP7wZVioc5H", fields = new FieldsDTO()
{
id = null, Message = "Message", receivedAt = DateTime.Now.ToString()
}
},
new RecordsDTO()
{
id = "recCR2LP7wZVioc5H", fields = new FieldsDTO()
{
id = "2", Message = "Message", receivedAt = DateTime.Now.ToString()
}
},
new RecordsDTO()
{
id = "recCR2LP7wZVioc5H", fields = new FieldsDTO()
{
id = "3", Message = "Message", receivedAt = DateTime.Now.ToString()
}
}
}
};
airTableService.GetMessagesAsync().Returns(response);
// Act
var result = handler.Handle(command, new System.Threading.CancellationToken());
// Assert
await airTableService.Received(Quantity.AtLeastOne()).GetMessagesAsync();
result.Should().NotBeNull();
result.Result.Should().HaveCount(2);
}
public void Inizialize()
{
var chatbotService = new Mock <IChatbotService>();
var unitOfWork = new Mock <IUnitOfWork>();
var quey = new GetMessagesQuery(chatbotService.Object, unitOfWork.Object);
var container = new Mock <IContainer>();
container.Setup(m => m.Resolve(typeof(GetMessagesQuery), It.IsAny <IfUnresolved>()))
.Returns(() => quey);
_sut = new QueryFactory(container.Object);
}
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 <PaginationDto <MessageDto> > HandleAsync(GetMessagesQuery query)
{
var ids = (new[] { query.RequestBy, query.Reciever }).OrderBy(x => x).ToList();
var querable = _context.Messages.Where(x => ids.Any(s => s == x.ReceiverId) && ids.Any(s => s == x.SenderId));
var count = await querable.Where(query).CountAsync();
var data = await querable.FilterBy(query).ToListAsync();
var wrapper = new PaginationDto <Message> {
Data = data, TotalCount = count
};
return(_swizzerMapper.MapTo <PaginationDto <MessageDto> >(wrapper));
}
public List <MessageDto> GetMessages(Int32 startId, string connectionId)
{
var currentUserNick = string.Empty;
RealTimeChatUsersService.Users.TryGetValue(connectionId, out currentUserNick);
var query = new GetMessagesQuery(startId);
var messages = this.mediator.Send(query).Result;
var messagesDto = messages.Select((m) => new MessageDto(m.Id, m.Nick, m.Content, currentUserNick == m.Nick));
return(messagesDto.ToList());
}
public ChatClient(
GetPeopleQuery getPeopleQuery,
GetMessagesQuery getMessagesQuery,
SendMessageMutation sendMessageMutation,
ReadMessagesSubscription readMessagesSubscription)
{
_getPeopleQuery = getPeopleQuery
?? throw new global::System.ArgumentNullException(nameof(getPeopleQuery));
_getMessagesQuery = getMessagesQuery
?? throw new global::System.ArgumentNullException(nameof(getMessagesQuery));
_sendMessageMutation = sendMessageMutation
?? throw new global::System.ArgumentNullException(nameof(sendMessageMutation));
_readMessagesSubscription = readMessagesSubscription
?? throw new global::System.ArgumentNullException(nameof(readMessagesSubscription));
}
public async Task ReadUserMessages(MessagesCommand command, Contexts contexts)
{
if (!contexts.User.IsAdmin() && command.User != contexts.User.Id) //allow check own messages for everybody
{
throw new NotAdminPermissionsException();
}
var selectedUser = await this._usersService.GetUserByIdAsync(contexts.Server, command.User);
if (selectedUser == null)
{
throw new UserNotFoundException(command.User.GetUserMention());
}
var timeRange = TimeRange.ToNow(contexts.Message.SentAt - command.Time);
var query = new GetMessagesQuery(contexts.Server.Id, userId: selectedUser.Id)
{
SentDate = timeRange
};
var messages = this._queryBus.Execute(query).Messages
.OrderBy(x => x.SentAt)
.ToList();
var messagesService = this._messagesServiceFactory.Create(contexts);
var maxNumberOfMessages = this._configurationService.GetConfigurationItem <MaxNumberOfMessagesDisplayedByMessageCommandWithoutForce>(contexts.Server.Id).Value;
if (messages.Count > maxNumberOfMessages && !command.Force)
{
await messagesService.SendResponse(x => x.NumberOfMessagesIsHuge(messages.Count));
return;
}
if (!messages.Any())
{
await messagesService.SendResponse(x => x.UserDidntWriteAnyMessageInThisTime(selectedUser));
return;
}
var header = $"Messages from user {selectedUser} starting at {timeRange.Start.ToLocalTimeString()}";
var lines = messages.Select(x => $"{x.SentAt.ToLocalTimeString()} {x.Author.Name}: {x.Content.Replace("```", "")}");
var linesBuilder = new StringBuilder().PrintManyLines(lines.ToArray(), contentStyleBox: true);
await this._directMessagesService.TrySendMessage(contexts.User.Id, header);
await this._directMessagesService.TrySendMessage(contexts.User.Id, linesBuilder.ToString(), MessageType.NormalText);
await messagesService.SendResponse(x => x.SentByDmMessagesOfAskedUser(messages.Count, selectedUser));
}
public async Task ReadUserMessages(DiscordRequest request, Contexts contexts)
{
var mention = request.GetMention();
var selectedUser = await this._usersService.GetUserByMentionAsync(contexts.Server, mention);
if (selectedUser == null)
{
throw new UserNotFoundException(mention);
}
var timeRange = request.GetPastTimeRange(defaultTime: TimeSpan.FromHours(1));
var query = new GetMessagesQuery(contexts.Server.Id, selectedUser.Id)
{
SentDate = timeRange
};
var messages = this._queryBus.Execute(query).Messages
.OrderBy(x => x.SentAt)
.ToList();
var messagesService = this._messagesServiceFactory.Create(contexts);
var hasForceArgument = request.HasArgument("force") || request.HasArgument("f");
if (messages.Count > 200 && !hasForceArgument)
{
await messagesService.SendResponse(x => x.NumberOfMessagesIsHuge(messages.Count));
return;
}
if (!messages.Any())
{
await messagesService.SendResponse(x => x.UserDidntWriteAnyMessageInThisTime(selectedUser));
return;
}
var header = $"Messages from user {selectedUser} starting at {timeRange.Start}";
var lines = messages.Select(x => $"{x.SentAt:yyyy-MM-dd HH:mm:ss} {x.Author.Name}: {x.Content.Replace("```", "")}");
var linesBuilder = new StringBuilder().PrintManyLines(lines.ToArray(), contentStyleBox: true);
await this._directMessagesService.TrySendMessage(contexts.User.Id, header);
await this._directMessagesService.TrySendMessage(contexts.User.Id, linesBuilder.ToString(), MessageType.BlockFormatted);
await messagesService.SendResponse(x => x.SentByDmMessagesOfAskedUser(messages.Count, selectedUser));
}
public void Inizialize()
{
var messages = new List <Message> {
new TextMessage()
};
_chatbotService = new Mock <IChatbotService>();
_chatbotService.Setup(m => m.HasUnreadMessages()).Returns(() => true);
_chatbotService.Setup(m => m.GetMessages()).Returns(() => messages);
_persistance = new Mock <IPersistence <Message> >();
_persistance.Setup(m => m.Query(null)).Returns(() => messages);
_unitOfWork = new Mock <IUnitOfWork>();
_unitOfWork.Setup(m => m.GetPersistence <Message>(It.IsAny <Type>())).Returns(() => _persistance.Object);
_sut = new GetMessagesQuery(_chatbotService.Object, _unitOfWork.Object);
}
private async Task GenerateStatsForLastDay()
{
var servers = this._discordServersService.GetDiscordServersAsync();
var yesterdayDate = DateTime.Today.AddDays(-1);
var todayDate = DateTime.Today;
var yesterdayRange = new TimeRange(yesterdayDate, todayDate);
await foreach (var server in servers)
{
var query = new GetMessagesQuery(server.Id)
{
SentDate = yesterdayRange
};
var messages = this._queryBus.Execute(query).Messages.ToList();
var serverStatistic = new ServerDayStatistic(messages, server.Id, DateTime.Today);
var command = new AddServerDayStatisticCommand(serverStatistic);
await this._commandBus.ExecuteAsync(command);
}
}
public async Task <IEnumerable <MessageResult> > Handle(GetMessagesQuery request, CancellationToken cancellationToken)
{
SAMLAssertion assertion;
try
{
assertion = SAMLAssertion.Deserialize(request.AssertionToken);
}
catch
{
throw new BadAssertionTokenException(Global.BadAssertionToken);
}
var messagesResult = await _ehealthBoxService.GetMessagesList(new EHealthBoxGetMessagesListRequest
{
StartIndex = request.StartIndex,
EndIndex = request.EndIndex,
Source = request.Source
}, assertion);
return(messagesResult.Body.GetMessagesListResponse.MessageLst.Select(_ => _.ToResult()));
}
public async Task <Result <PagedResult <Message> > > Handle(GetMessagesQuery request, CancellationToken cancellationToken)
{
var auth = await _mediator.Send(new AuthorizeQuery { Username = request.Username, Password = request.Password });
if (auth.IsError)
{
return(new Result <PagedResult <Message> > {
IsError = true, Message = auth.Message
});
}
var messages = _store.GetMessages(request.SourceId);
var search = request.Search;
if (!string.IsNullOrWhiteSpace(search))
{
Func <string, string> ifNull = (string a) => a == null ? "" : a;
messages = messages.Where(u => ifNull(u.BodyPlain).ToLower().Contains(search.ToLower())).ToArray();
}
return(new Result <PagedResult <Message> >(messages.GetPagedResult <Message>(request.PageNumber, request.PageSize)));
}
public static GetMessagesQuery ToGetMessagesQuery(this JObject jObj)
{
var result = new GetMessagesQuery();
var values = jObj.ToObject <Dictionary <string, object> >();
if (values.TryGet(MedikitApiConstants.SearchNames.AssertionToken, out string assertionToken))
{
result.AssertionToken = assertionToken;
}
if (values.TryGet(MedikitApiConstants.SearchNames.StartIndex, out int startIndex))
{
result.StartIndex = startIndex;
}
if (values.TryGet(MedikitApiConstants.SearchNames.EndIndex, out int endIndex))
{
result.EndIndex = endIndex;
}
return(result);
}
public async Task GivenMessageRequest_WhenGet_ThenAGetReturnsSuccessIfAtLeastOneMessageExists()
{
var authQuery = new GetAuthenticationTokenQuery
{
UserName = "******",
Password = "******"
};
AuthenticationToken authenticationToken;
using (var postAuthResponse = await _client.PostAsJsonAsync($"/api/Auth", authQuery))
{
Assert.True(postAuthResponse.IsSuccessStatusCode);
authenticationToken = await postAuthResponse.Content.ReadAsAsync <AuthenticationToken>();
Assert.NotEmpty(authenticationToken.Token);
}
_client.DefaultRequestHeaders.Add("Authorization", $"Bearer {authenticationToken.Token}");
var query = new GetMessagesQuery
{
MaxRecords = 3,
View = "Grid view"
};
List <MessagesViewModel> messages;
using (var getMessagesResponse = await _client.GetAsync($"/api/Messages?maxRecords={query.MaxRecords}&view={query.View}"))
{
Assert.True(getMessagesResponse.IsSuccessStatusCode);
messages = await getMessagesResponse.Content.ReadAsAsync <List <MessagesViewModel> >();
Assert.True(messages.Any());
}
}
/// <summary>
/// Asynchronously run the search action. Display results when done.
/// </summary>
/// <param name="searchText">The text to search for.</param>
/// <returns>A task representing the asynchronous operation.</returns>
private async Task SearchAsync(string searchText)
{
this.uxResultsList.Items.Clear();
// Save the user from themselves; prevent empty searches.
if (String.IsNullOrEmpty(searchText))
return;
var query = new GetMessagesQuery() { Pattern = searchText };
var messages = await this.database.QueryAsync(query);
foreach (var message in messages)
{
var item = new ListViewItem();
item.Tag = message;
item.Text = message.Timestamp?.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
item.SubItems.Add(message.AuthorDisplayName);
item.SubItems.Add(FormatMessage(message.Text));
this.uxResultsList.Items.Add(item);
}
this.uxResultsList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
public GetOlderMessagesRequest(string apiUrl, GetMessagesQuery query) : base(query)
{
_apiUrl = apiUrl;
}
public Task <PaginationDto <MessageDto> > HandleAsync(GetMessagesQuery query)
{
return(_apiHttpWebService.SendAsync <PaginationDto <MessageDto> >(HttpMethod.Get, Routes.Messages.Main + query.Reciever));
}
public Task <IEnumerable <MessageResult> > SearchSentboxMessages(GetMessagesQuery query)
{
query.Source = EHealthBoxSources.SENTBOX;
return(_mediator.Send(query));
}
