public GetMessagesResponse GetMessages(string queueName, int numofMessages = 1, int visibilityTimeout = 30, int?messageTtl = null)
{
var request = new GetMessagesRequest(_account, queueName, numofMessages, visibilityTimeout, messageTtl);
var response = request.Execute();
return(response.Payload);
}
public void FetchNewMessages(APIAccess api)
{
if (fetchReq != null)
{
return;
}
fetchReq = new GetMessagesRequest(careChannels, lastMessageId);
fetchReq.Success += delegate(List <Message> messages)
{
var ids = messages.Select(m => m.ChannelId).Distinct();
//batch messages per channel.
foreach (var id in ids)
{
careChannels.Find(c => c.Id == id)?.AddNewMessages(messages.Where(m => m.ChannelId == id));
}
lastMessageId = messages.LastOrDefault()?.Id ?? lastMessageId;
Debug.Write("success!");
fetchReq = null;
};
fetchReq.Failure += delegate
{
Debug.Write("failure!");
fetchReq = null;
};
api.Queue(fetchReq);
}
public async Task <GetMessagesResponse> GetMessagesAsync(string queueName, int numofMessages = 1, int visibilityTimeout = 30, int?messageTtl = null)
{
var request = new GetMessagesRequest(_account, queueName, numofMessages, visibilityTimeout, messageTtl);
var response = await request.ExecuteAsync();
return(response.Payload);
}
public GetMessagesResponse Consume(GetMessagesRequest request)
{
return new GetMessagesResponse()
{
Messages = SavedMessages
};
}
public async Task <ActionResult <MainResponse> > GetMessages(GetMessagesRequest request)
{
User user = HttpContext.GetUser();
if (user.KeySession == null)
{
return(Unauthorized());
}
Chat chat = await _context.Chats.FirstOrDefaultAsync(p => p.Id == request.ChatId);
if (chat == null)
{
return(MainResponse.GetError(Enums.RequestError.ChatNotFound));
}
Message[] messages = chat.Messages.OrderByDescending(p => p.Date).Skip(_serverConfig.Chats.PartsSize.MessagesInPart * (request.Part - 1)).Take(_serverConfig.Chats.PartsSize.MessagesInPart).ToArray();
GetMessagesResponse getMessagesResponse = new GetMessagesResponse()
{
Messages = messages.GetExts()
};
return(MainResponse.GetSuccess(getMessagesResponse));
}
public IAsyncEnumerable <ChatMessage> GetMessages(GetMessagesRequest request)
{
VertifyTokenAsync().Wait();
return(_server.GetMessagesAsync(request)
.ToAsyncEnumerable()
.SelectMany(list => list.ToAsyncEnumerable()));
}
/// <summary>
/// Returns messages from the specified stream using the specified cursor as the starting point for consumption. By default, the number of messages returned is undefined, but the service returns as many as possible.
/// To get messages, you must first obtain a cursor using the {@link #createCursor(CreateCursorRequest) createCursor} operation.
/// In the response, retrieve the value of the 'opc-next-cursor' header to pass as a parameter to get the next batch of messages in the stream.
///
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/streaming/GetMessages.cs.html">here</a> to see an example of how to use GetMessages API.</example>
public async Task <GetMessagesResponse> GetMessages(GetMessagesRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called getMessages");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/streams/{streamId}/messages".Trim('/')));
HttpMethod method = new HttpMethod("GET");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <GetMessagesResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"GetMessages failed with error: {e.Message}");
throw;
}
}
public async Task <IActionResult> GetMessagesAsync(Guid channelId, [FromQuery] Guid messageId, [FromQuery] DateTimeOffset messageCreated, [FromQuery] int?pageSize)
{
var request = new GetMessagesRequest(GetCurrentSaasUserId(), channelId, messageId, messageCreated, pageSize);
var result = await _messageService.GetMessagesAsync(request);
return(Ok(result));
}
private async void ScrollViewer_ViewChanged(object sender, ScrollViewerViewChangedEventArgs e)
{
var scrollViewer = (ScrollViewer)sender;
if (scrollViewer.VerticalOffset < 0.001)
{
LoadingRing.IsActive = true;
LoadingRing.Visibility = Visibility.Visible;
var skip = viewModel.Messages.Count;
var item = viewModel.Messages.FirstOrDefault();
try
{
var request = new GetMessagesRequest
{
ChannelId = viewModel.SelectedChannel.Id
};
var result = await HttpApi.Channel.GetMessagesAsync(request, skip, 50, HttpApi.AuthToken);
for (var i = result.Count - 1; i >= 0; i--)
{
viewModel.Messages.Insert(0, result[i]);
}
MessageView.ScrollIntoView(item);
}
catch (ApiException ex)
{
await ex.ShowErrorDialog();
}
finally
{
LoadingRing.IsActive = false;
LoadingRing.Visibility = Visibility.Collapsed;
}
}
}
public GetMessagesResponse GetMessages(string receiverName, string senderName)
{
var sender = this.Users.First(u => u.Name == senderName);
var receiver = this.Users.First(u => u.Name == receiverName);
var request = new GetMessagesRequest
{
ChatAddress = receiver.Contacts.First(c => c.Name == sender.Name).ChatAddress,
ChatKeyPair = receiver.Contacts.First(c => c.Name == sender.Name).ChatKeyPair,
ChatKeyAddress = receiver.Contacts.First(c => c.Name == sender.Name).ChatKeyAddress,
UserKeyPair = receiver.NtruKeyPair
};
this.LastRequest = request;
var response = InstanceBag.GetMessagesInteractor.ExecuteAsync(request).Result;
// ReSharper disable once InvertIf
if (response.Code == ResponseCode.Success)
{
receiver.Contacts.First(c => c.Name == sender.Name).ChatKeyPair = response.ChatKeyPair;
receiver.Contacts.First(c => c.Name == sender.Name).ChatAddress = response.CurrentChatAddress;
sender.Contacts.First(c => c.Name == receiver.Name).ChatKeyPair = response.ChatKeyPair;
sender.Contacts.First(c => c.Name == receiver.Name).ChatAddress = response.CurrentChatAddress;
}
this.LastResponse = response;
return(response);
}
public void GetMessages()
{
var expectedJson = GetJsonPayload("/inbox/inboxApi/getMessages.json");
var restRequest = MockRestResponse(expectedJson);
var request = new GetMessagesRequest
{
Search = "msg",
FolderId = 20,
Type = MessageType.Sms,
SortType = SortType.Desc,
SortBy = SortProperty.ReceivedOn,
ItemsPerPage = 10,
Page = 1
};
var response = Client.InboxApi.GetMessages(request);
EzTextingResponse <InboxMessage> ezResponse = new EzTextingResponse <InboxMessage>("Success", 200, response);
Assert.That(Serializer.Serialize(ezResponse), Is.EqualTo(expectedJson));
Assert.AreEqual(Method.GET, restRequest.Value.Method);
Assert.That(restRequest.Value.Resource, Is.StringContaining("User=login"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("Password=password"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("Search=msg"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("FolderID=20"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("Filter=SMS"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("sortBy=ReceivedOn"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("sortDir=desc"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("itemsPerPage=10"));
Assert.That(restRequest.Value.Resource, Is.StringContaining("page=1"));
}
public void FetchNewMessages(APIAccess api)
{
if (fetchReq != null)
{
return;
}
fetchReq = new GetMessagesRequest(careChannels, lastMessageId);
fetchReq.Success += delegate(List <Message> messages)
{
foreach (Message m in messages)
{
careChannels.Find(c => c.Id == m.ChannelId).AddNewMessages(m);
}
lastMessageId = messages.LastOrDefault()?.Id ?? lastMessageId;
Debug.Write("success!");
fetchReq = null;
};
fetchReq.Failure += delegate
{
Debug.Write("failure!");
fetchReq = null;
};
api.Queue(fetchReq);
}
public async Task CreateMessage_Should_CreateMessage()
{
//Arrange
var createMessageRequest = new CreateMessageRequest
{
MessageContents = "This is a test message"
};
const string username = "******";
var testMessage = new Message {
MessageId = 1, CreatedBy = "TestUser", Created = DateTime.Now.AddHours(-1), MessageContent = "Test Message"
};
var getMessageRequest = new GetMessagesRequest();
var fakeMessageBoardRepository = A.Fake <IMessageBoardRepository>();
A.CallTo(() => fakeMessageBoardRepository.CreateMessage(username, createMessageRequest)).Returns(testMessage);
var messageService = new MessageService(fakeMessageBoardRepository);
//Act
var createdMessage = messageService.CreateMessage(username, createMessageRequest);
//Assert
A.CallTo(() => fakeMessageBoardRepository.CreateMessage(username, createMessageRequest)).MustHaveHappened(1, Times.Exactly);
createdMessage.Should().Be(testMessage);
}
private void fetchNewMessages()
{
if (fetchReq != null)
{
return;
}
fetchReq = new GetMessagesRequest(careChannels, lastMessageId);
fetchReq.Success += delegate(List <Message> messages)
{
foreach (var group in messages.Where(m => m.TargetType == TargetType.Channel).GroupBy(m => m.TargetId))
{
careChannels.Find(c => c.Id == group.Key)?.AddNewMessages(group.ToArray());
}
lastMessageId = messages.LastOrDefault()?.Id ?? lastMessageId;
Debug.Write("success!");
fetchReq = null;
};
fetchReq.Failure += delegate
{
Debug.Write("failure!");
fetchReq = null;
};
api.Queue(fetchReq);
}
public async Task <MessagesResult> GetMessagesAsync(GetMessagesRequest request)
{
var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId);
if (member == null)
{
throw new NetKitChatNotFoundException($"Unable to get messages. Member {nameof(request.SaasUserId)}:{request.SaasUserId} is not found.");
}
var lastMessage = await UnitOfWork.MessageRepository.GetMessageWithOwnerAndForwardMessageAsync(request.MessageId);
var lastMessageCreatedDate = lastMessage?.Created ?? request.MessageCreatedDate;
var lastReadMessage = await UnitOfWork.MessageRepository.GetLastReadMessageAsync(member.Id, request.ChannelId);
var messages = await UnitOfWork.MessageRepository.GetMessagesWithOwnersAsync(request.ChannelId, lastMessageCreatedDate, request.PageSize);
var results = messages.Select(message => DomainModelsMapper.MapToMessageResponse(message, lastReadMessage?.Created)).ToList();
return(new MessagesResult
{
PageSize = request.PageSize,
Results = results
});
}
public void FetchNewMessages(APIAccess api)
{
if (fetchReq != null) return;
fetchReq = new GetMessagesRequest(careChannels, lastMessageId);
fetchReq.Success += delegate (List<Message> messages)
{
foreach (Message m in messages)
{
careChannels.Find(c => c.Id == m.ChannelId).AddNewMessages(m);
}
lastMessageId = messages.LastOrDefault()?.Id ?? lastMessageId;
Debug.Write("success!");
fetchReq = null;
};
fetchReq.Failure += delegate
{
Debug.Write("failure!");
fetchReq = null;
};
api.Queue(fetchReq);
}
private static async Task SimpleMessageLoop(StreamClient streamClient, string streamId, string initialCursor)
{
string cursor = initialCursor;
for (int i = 0; i < 10; i++)
{
GetMessagesRequest getMessagesRequest = new GetMessagesRequest
{
StreamId = streamId,
Cursor = cursor,
Limit = 10
};
GetMessagesResponse getResponse = await streamClient.GetMessages(getMessagesRequest);
// process the messages
logger.Info($"Read {getResponse.Items.Count}");
foreach (Message message in getResponse.Items)
{
logger.Info($"{Encoding.UTF8.GetString(message.Key)} : {Encoding.UTF8.GetString(message.Value)}");
}
// getMessages is a throttled method; clients should retrieve sufficiently large message
// batches, as to avoid too many http requests.
await Task.Delay(1000);
// use the next-cursor for iteration
cursor = getResponse.OpcNextCursor;
}
}
public override async Task <GetMessagesResponse> GetHistory(GetMessagesRequest request, ServerCallContext context)
{
IEnumerable <ChatEntry> entries = await iChatEntryRepository.GetLastEntries(request.LastMessages);
context.Status = new Status(StatusCode.OK, $"Last {request.LastMessages} chat entries...");
return(iMapper.Map <GetMessagesResponse>(entries));
}
public async Task <IEnumerable <ChatEntry> > GetHistory(int lastMessages)
{
GetMessagesRequest request = iMapper.Map <GetMessagesRequest>(lastMessages);
GetMessagesResponse response = await chatClient.GetHistoryAsync(request);
return(iMapper.Map <IEnumerable <ChatEntry> >(response));
}
public async Task <Message[]> DownloadMessages(int limit = 100, ulong?relativeMessageId = null,
Relative relativeDir = Relative.Before, bool useCache = true)
{
if (limit < 0)
{
throw new ArgumentOutOfRangeException(nameof(limit));
}
if (limit == 0 || Type != ChannelType.Text)
{
return(new Message[0]);
}
try
{
string dir;
switch (relativeDir)
{
case Relative.Before:
default: dir = "before"; break;
case Relative.After: dir = "after"; break;
case Relative.Around: dir = "around"; break;
}
var request = new GetMessagesRequest(Id)
{
Limit = limit,
RelativeDir = relativeMessageId.HasValue ? dir : null,
RelativeId = relativeMessageId ?? 0
};
var msgs = await Client.ClientAPI.Send(request).ConfigureAwait(false);
return(msgs.Select(x =>
{
Message msg = null;
if (useCache)
{
msg = AddMessage(x.Id, GetUserFast(x.Author.Id), x.Timestamp.Value);
var user = msg.User;
if (user != null)
{
user.UpdateActivity(msg.EditedTimestamp ?? msg.Timestamp);
}
}
else
{
msg = new Message(x.Id, this, GetUserFast(x.Author.Id));
}
msg.Update(x);
return msg;
})
.ToArray());
}
catch (HttpException ex) when(ex.StatusCode == HttpStatusCode.Forbidden)
{
return(new Message[0]);
}
}
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 async Task <MessagesResponse> GetMessagesAsync(GetMessagesRequest request, CancellationToken cancellationToken)
{
var parameters = new Dictionary <string, string>
{
{ "maxRecords", request.MaxRecords.ToString() },
{ "view", request.View }
};
return(await QueryAsync <MessagesResponse>(HttpMethod.Get, $"/Messages", cancellationToken, parameters).ConfigureAwait(false));
}
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 ShouldReturnOlderMessages_WhenLastMessageByMessageIdNotFound_AndLastReadMessageNotFound()
{
// Arrange
var request = new GetMessagesRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), new Guid("01ADF1C2-0B38-4E4F-9E36-0C0BC7908062"), DateTimeOffset.Now, 10);
var member = new Member {
Id = new Guid("A1538EB3-4E4C-4E39-BDCB-F617003E4BBF")
};
_memberRepositoryMock.Setup(x => x.GetMemberBySaasUserIdAsync(It.Is <string>(saasUserId => saasUserId.Equals(request.SaasUserId))))
.ReturnsAsync(member)
.Verifiable();
_messageRepositoryMock.Setup(x => x.GetMessageWithOwnerAndForwardMessageAsync(It.Is <Guid>(messageId => messageId.Equals(request.MessageId))))
.ReturnsAsync((Message)null)
.Verifiable();
_messageRepositoryMock.Setup(x => x.GetLastReadMessageAsync(
It.Is <Guid>(memberId => memberId.Equals(member.Id)),
It.Is <Guid>(channelId => channelId.Equals(request.ChannelId))))
.ReturnsAsync((Message)null)
.Verifiable();
var olderMessage = new Message {
Id = new Guid("1E0DDFFA-3A21-44C8-97BB-E94B4F408680")
};
var olderMessages = new List <Message> {
olderMessage
};
_messageRepositoryMock.Setup(x => x.GetOlderMessagesWithOwnersAsync(
It.Is <Guid>(channelId => channelId.Equals(request.ChannelId)),
It.Is <DateTimeOffset>(lastReadMessageCreated => lastReadMessageCreated.Equals(request.MessageCreatedDate)),
It.Is <int?>(pageSize => pageSize.Equals(request.PageSize))))
.ReturnsAsync(olderMessages)
.Verifiable();
var messageResponse = new MessageResponse();
_domainModelsMapperMock.Setup(x => x.MapToMessageResponse(
It.Is <Message>(message => message.Equals(olderMessage)),
It.Is <DateTimeOffset?>(lastReadMessageCreated => lastReadMessageCreated.Equals(null))))
.Returns(messageResponse)
.Verifiable();
// Act
var result = await _messageService.GetOlderMessagesAsync(request);
// Assert
VerifyMocks();
result.PageSize.Should().Be(request.PageSize);
result.Results.Should().BeEquivalentTo(new List <MessageResponse> {
messageResponse
});
}
public override async Task GetMessages(GetMessagesRequest request, IServerStreamWriter <ChatMessage> responseStream, ServerCallContext context)
{
await VertifyTokenAsync(context);
var messages = await _server.GetMessagesAsync(request);
foreach (var message in messages)
{
await responseStream.WriteAsync(message);
}
}
public async Task <List <ChatMessage> > GetRecentMessagesAsync(int count)
{
var request = new GetMessagesRequest
{
SenderId = UserId,
ChatroomId = RoomId,
AfterTimeUnixMs = 0,
Count = count
};
return(await ServerService.GetMessages(request).ToList());
}
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 IList <MessageItem> GetMessages(string phone)
{
if (String.IsNullOrEmpty(phone))
{
throw new ArgumentException("Телефон не должен быть пустым", nameof(phone));
}
var client = new Messages.MessagesClient(Channel);
var request = new GetMessagesRequest();
request.Phone = phone;
return(client.GetMessages(request, Headers).Messages);
}
/// <summary>
/// Fetches inital messages of a channel
///
/// TODO: remove this when the API supports returning initial fetch messages for more than one channel by specifying the last message id per channel instead of one last message id globally.
/// right now it caps out at 50 messages and therefore only returns one channel's worth of content.
/// </summary>
/// <param name="channel">The channel </param>
private void fetchInitalMessages(Channel channel)
{
if (channel.Id <= 0 || channel.MessagesLoaded) return;
var fetchInitialMsgReq = new GetMessagesRequest(channel);
fetchInitialMsgReq.Success += messages =>
{
handleChannelMessages(messages);
channel.MessagesLoaded = true; // this will mark the channel as having received messages even if there were none.
};
api.Queue(fetchInitialMsgReq);
}
public async Task <IActionResult> Get([FromBody] GetMessagesRequest credentials)
{
try
{
var result = await messagesService.GetMessages(
credentials.ConversationID,
credentials.MessagesOffset,
credentials.Count,
credentials.MaxMessageId,
credentials.History,
credentials.SetLastMessage,
ClaimsExtractor.GetUserIdClaim(User.Claims));
return(Ok(new ResponseApiModel <List <Message> >
{
IsSuccessfull = true,
Response = result
}));
}
catch (InvalidDataException ex)
{
return(BadRequest(new ResponseApiModel <bool>
{
IsSuccessfull = false,
ErrorMessage = ex.Message
}));
}
catch (UnauthorizedAccessException ex)
{
return(StatusCode((int)HttpStatusCode.Forbidden, new ResponseApiModel <bool>
{
IsSuccessfull = false,
ErrorMessage = ex.Message
}));
}
catch (KeyNotFoundException ex)
{
return(NotFound(new ResponseApiModel <bool>
{
IsSuccessfull = false,
ErrorMessage = ex.Message
}));
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, new ResponseApiModel <bool>
{
IsSuccessfull = false
}));
}
}
public async Task GetMessages_Should_GetMessages()
{
//Arrange
var getMessageRequest = new GetMessagesRequest();
var fakeMessageBoardRepository = A.Fake <IMessageBoardRepository>();
var messageService = new MessageService(fakeMessageBoardRepository);
//Act
var returnedMessages = await messageService.GetMessages(getMessageRequest);
//Assert
A.CallTo(() => fakeMessageBoardRepository.GetMessages(getMessageRequest)).MustHaveHappened(1, Times.Exactly);
}
private void fetchInitialMessages(Channel channel)
{
var req = new GetMessagesRequest(channel);
req.Success += messages =>
{
channel.AddNewMessages(messages.ToArray());
if (channel == currentChannel)
{
loading.Hide();
}
};
api.Queue(req);
}
protected void SendMessage(object sender, EventArgs e)
{
//Make the RPC request
CalculateRequest request = new CalculateRequest() { Terms = Convert.ToInt32(MessageText.Text) };
CalculateResponse response = EasyNetQBus.Current().SynchronousResponse<CalculateRequest, CalculateResponse>(request);
string messageText = string.Format("Pi is not: {0}", response.Pi.ToString());
//Publish a broadcast message
BroadcastMessageRequest broadcast = new BroadcastMessageRequest() { MessageText = messageText };
EasyNetQBus.Current().Publish<BroadcastMessageRequest>(broadcast);
//Get the list of broadcast messages (RPC again)
GetMessagesRequest messagesRequest = new GetMessagesRequest();
GetMessagesResponse messagesResponse = EasyNetQBus.Current().SynchronousResponse<GetMessagesRequest, GetMessagesResponse>(messagesRequest);
//Print out the last result. Bear in mind we're async - this may not be your last request!
MessageList.DataSource = messagesResponse.Messages;
MessageList.DataBind();
}
public async Task<GetMessagesResponse> GetMessagesAsync(string queueName, int numofMessages = 1, int visibilityTimeout = 30, int? messageTtl = null)
{
var request = new GetMessagesRequest(_account, queueName, numofMessages, visibilityTimeout, messageTtl);
var response = await request.ExecuteAsync(_optionalRetryPolicy);
return response.Payload;
}
public async Task<Message[]> DownloadMessages(int limit = 100, ulong? relativeMessageId = null,
RelativeDirection relativeDir = RelativeDirection.Before, bool useCache = true)
{
if (limit < 0) throw new ArgumentOutOfRangeException(nameof(limit));
if (limit == 0 || Type != ChannelType.Text) return new Message[0];
try
{
var request = new GetMessagesRequest(Id)
{
Limit = limit,
RelativeDir = relativeMessageId.HasValue ? relativeDir == RelativeDirection.Before ? "before" : "after" : null,
RelativeId = relativeMessageId ?? 0
};
var msgs = await Client.ClientAPI.Send(request).ConfigureAwait(false);
return msgs.Select(x =>
{
Message msg = null;
if (useCache)
{
msg = AddMessage(x.Id, GetUser(x.Author.Id), x.Timestamp.Value);
var user = msg.User;
if (user != null)
user.UpdateActivity(msg.EditedTimestamp ?? msg.Timestamp);
}
else
msg = new Message(x.Id, this, GetUser(x.Author.Id));
msg.Update(x);
return msg;
})
.ToArray();
}
catch (HttpException ex) when (ex.StatusCode == HttpStatusCode.Forbidden)
{
return new Message[0];
}
}
