public GetMessagesResponse GetMessages(DateTime fromDate, DateTime toDate) { TwilioClient.Init(accountSid, authToken); var messages = MessageResource.Read( dateSentAfter: fromDate, dateSentBefore: toDate ); // from: new Twilio.Types.PhoneNumber("+15017122661"), // to: new Twilio.Types.PhoneNumber("+15558675310") GetMessagesResponse response = new GetMessagesResponse { SmsMessages = new List <SmsMessage>() }; foreach (var message in messages) { response.SmsMessages.Add(new SmsMessage { DateSent = message.DateSent.Value, MessageBody = message.Body }); } return(response); }
public async Task PostGetMessageListContinuationTokenTest() { var conversation = CreateRandomPostConversationRequest(); var fetchedConversation = await _chatServiceClient.AddConversation(conversation); PostMessageResponse[] sentMessageList = new PostMessageResponse[6]; for (int messageCount = 0; messageCount < 6; messageCount++) { sentMessageList[messageCount] = await _chatServiceClient.AddMessage(fetchedConversation.Id, CreateRandomPostMessageRequest()); } GetMessagesResponse fetchedMessageList1 = await _chatServiceClient.GetMessageList(fetchedConversation.Id, 3, sentMessageList[0].UnixTime); Assert.Equal(3, fetchedMessageList1.Messages.Count()); Assert.Equal(fetchedMessageList1.Messages.ElementAt(0).Text, sentMessageList[5].Text); Assert.Equal(fetchedMessageList1.Messages.ElementAt(1).Text, sentMessageList[4].Text); Assert.Equal(fetchedMessageList1.Messages.ElementAt(2).Text, sentMessageList[3].Text); Assert.NotEmpty(fetchedMessageList1.NextUri); GetMessagesResponse fetchedMessageList2 = await _chatServiceClient.GetMessageList(fetchedMessageList1.NextUri); Assert.Equal(2, fetchedMessageList2.Messages.Count()); Assert.Equal(fetchedMessageList2.Messages.ElementAt(0).Text, sentMessageList[2].Text); Assert.Equal(fetchedMessageList2.Messages.ElementAt(1).Text, sentMessageList[1].Text); Assert.Empty(fetchedMessageList2.NextUri); }
public static GetMessagesResponse Unmarshall(UnmarshallerContext context) { GetMessagesResponse getMessagesResponse = new GetMessagesResponse(); getMessagesResponse.HttpResponse = context.HttpResponse; getMessagesResponse.ErrorCode = context.StringValue("GetMessages.ErrorCode"); getMessagesResponse.Msg = context.StringValue("GetMessages.Msg"); getMessagesResponse.SubCode = context.StringValue("GetMessages.SubCode"); getMessagesResponse.SubMsg = context.StringValue("GetMessages.SubMsg"); getMessagesResponse.LogsId = context.StringValue("GetMessages.LogsId"); getMessagesResponse.RequestId = context.StringValue("GetMessages.RequestId"); List <GetMessagesResponse.GetMessages_BizMessagesItem> getMessagesResponse_bizMessages = new List <GetMessagesResponse.GetMessages_BizMessagesItem>(); for (int i = 0; i < context.Length("GetMessages.BizMessages.Length"); i++) { GetMessagesResponse.GetMessages_BizMessagesItem bizMessagesItem = new GetMessagesResponse.GetMessages_BizMessagesItem(); bizMessagesItem.PubTime = context.StringValue("GetMessages.BizMessages[" + i + "].PubTime"); bizMessagesItem.Topic = context.StringValue("GetMessages.BizMessages[" + i + "].Topic"); bizMessagesItem.DataId = context.LongValue("GetMessages.BizMessages[" + i + "].DataId"); bizMessagesItem.ContentMapJson = context.StringValue("GetMessages.BizMessages[" + i + "].ContentMapJson"); getMessagesResponse_bizMessages.Add(bizMessagesItem); } getMessagesResponse.BizMessages = getMessagesResponse_bizMessages; return(getMessagesResponse); }
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; } }
private IEnumerable <ChatEntry> GetMessages(GetMessagesResponse source, ResolutionContext context) { foreach (var product in source.Messages) { yield return(context.Mapper.Map <ChatEntry>(product)); } }
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 async Task MessagesController_Get_Returns_OKObjectResult_When_MessageBoardService_Is_Valid() { // Arrange var response = new GetMessagesResponse(new List <Message> { new Message { User = "******", Content = "Hello Tom.", Created = DateTime.Now.AddMinutes(5) }, new Message { User = "******", Content = "It works.", Created = DateTime.Now } }); var service = new Mock <IMessageBoardService>(); service.Setup(s => s.GetAsync()).ReturnsAsync(response); var logger = new Mock <ILogger <MessagesController> >(); var controller = new MessagesController(service.Object, logger.Object); // Act var result = await controller.Get(); // Assert Assert.IsType <OkObjectResult>(result); Assert.Equal(2, ((result as OkObjectResult).Value as GetMessagesResponse).Messages.Count); }
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 Task <GetMessagesResponse> GetMessagesAsync(IAgentContext context, MessageContext messageContext, GetMessages getMessages) { var response = new GetMessagesResponse { Messages = _storage[messageContext.Connection.Id].Select(x => x.Message).ToArray() }; return(Task.FromResult(response)); }
/// <summary> /// Gets the messages. /// </summary> /// <returns>The messages.</returns> /// <param name="msg">Message.</param> /// <param name="context">Context.</param> protected Task <Msg> GetMessages(Msg msg, IdentityContext context) { var result = new GetMessagesResponse(); result.Messages.AddRange(storageService.Get(x => x.Aud == msg.Origin)); return(Task.FromResult(new Msg { Id = msg.Id, Type = StreetcredMessages.GET_MESSAGES_RESPONSE, Content = result.ToByteString() })); }
public async Task <ActionResult <GetMessagesResponse> > GetMessages() { var messages = await messageService.GetLatestLobbyMessagesAsync().ConfigureAwait(false); var response = new GetMessagesResponse { Success = true }; response.Messages.AddRange(messages.Select(m => m.ToApiLobbyMessage()).ToList()); return(response); }
public GetMessagesResponse GetMessages(GetMessagesRequest request) { var response = new GetMessagesResponse(); using (var context = new TypeFineContext()) { var requestDate = request.Date; response.Messages = context.DeveloperMessages.Where(x => x.Date >= requestDate).Select(y => new Message { Header = y.Header, Content = y.Content, Date = y.Date }).ToList(); } return(response); }
public async Task <APIGatewayProxyResponse> GetMessagesHandler(APIGatewayProxyRequest request, ILambdaContext context) { try { var connectionId = request.RequestContext.ConnectionId; var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true, }; GetMessagesRequest getMessagesRequest = JsonSerializer.Deserialize <GetMessagesRequest>(request.Body, options); var queryResponse = await DDBUtils.GetMessages(getMessagesRequest.RoomID, getMessagesRequest.TimeStamp, MessageLoadingLimit); GetMessagesResponse getMessagesResponse = new GetMessagesResponse() { Messages = queryResponse.Messages, Dates = queryResponse.Dates, Users = queryResponse.UserNames, Success = true }; return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.OK, Body = JsonSerializer.Serialize(getMessagesResponse) }); } catch (Exception e) { context.Logger.LogLine("Error getting messages: " + e.Message); context.Logger.LogLine(e.StackTrace); GetMessagesResponse responseMsg = new GetMessagesResponse() { Success = false }; return(new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.InternalServerError, Body = JsonSerializer.Serialize(responseMsg) }); } }
public async Task PostGetMessageListLastSeenMessageTimeTest(int indexOfLastSeenMessage) { var conversation = CreateRandomPostConversationRequest(); var fetchedConversation = await _chatServiceClient.AddConversation(conversation); PostMessageResponse[] sentMessageList = new PostMessageResponse[11]; for (int messageCount = 0; messageCount < 11; messageCount++) { sentMessageList[messageCount] = await _chatServiceClient.AddMessage(fetchedConversation.Id, CreateRandomPostMessageRequest()); } GetMessagesResponse fetchedMessageList = await _chatServiceClient.GetMessageList(fetchedConversation.Id, 30, sentMessageList[indexOfLastSeenMessage].UnixTime); int numberOfMessagesfetched = 10 - indexOfLastSeenMessage; Assert.Equal(numberOfMessagesfetched, fetchedMessageList.Messages.Count()); Assert.Empty(fetchedMessageList.NextUri); }
public IActionResult Get(string fromDate, string toDate) { DateTime fromDateParsed; DateTime toDateParsed; GetMessagesResponse response = new GetMessagesResponse(); if (!DateTime.TryParse(fromDate, out fromDateParsed)) { response.ErrorMessages.Add(new ErrorMessage { Message = $"From date {fromDate} is invalid" }); } if (!DateTime.TryParse(toDate, out toDateParsed)) { response.ErrorMessages.Add(new ErrorMessage { Message = $"To date {toDate} is invalid" }); } if (response.IsSuccess && toDateParsed < fromDateParsed) { response.ErrorMessages.Add(new ErrorMessage { Message = "To Date can't be before From Date" }); } if (!response.IsSuccess) { return(BadRequest(response)); } // get messages response = _twilioService.GetMessages(fromDateParsed, toDateParsed); if (!response.IsSuccess) { return(BadRequest(response)); } return(Ok(response)); }
public async Task <IActionResult> GetMessages(string conversationId, string continuationToken, int limit, long lastSeenMessageTime) { var messagesResult = await _messageService.GetMessages(conversationId, continuationToken, limit, lastSeenMessageTime); string nextUri = null; if (!string.IsNullOrWhiteSpace(messagesResult.ContinuationToken)) { nextUri = $"api/conversations/{conversationId}/messages?continuationToken={WebUtility.UrlEncode(messagesResult.ContinuationToken)}&limit={limit}&lastSeenMessageTime={lastSeenMessageTime}"; } var messagesResponse = new GetMessagesResponse { NextUri = nextUri, Messages = messagesResult.Messages }; return(Ok(messagesResponse)); }
public async Task <List <MessageDTO> > GetFriendChatAsync(long friendId, CancellationToken cancellationToken) => await Task.Run(async() => { if (!CrossConnectivity.Current.IsConnected) { throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION); } List <MessageDTO> messages = new List <MessageDTO>(); GetMessagesRequest getMessagesRequest = new GetMessagesRequest { AccessToken = GlobalSettings.Instance.UserProfile.AccesToken, Url = string.Format(GlobalSettings.Instance.Endpoints.ChatEndPoints.GetMessagesEndPoint, string.Empty, friendId, GlobalSettings.Instance.UserProfile.Id, GlobalSettings.Instance.UserProfile.ProfileType.ToString()) }; GetMessagesResponse getAllFriendsResponse = null; try { getAllFriendsResponse = await _requestProvider.GetAsync <GetMessagesRequest, GetMessagesResponse>(getMessagesRequest); if (getAllFriendsResponse != null) { messages = getAllFriendsResponse?.Messages.ToList(); } } catch (ServiceAuthenticationException exc) { _identityUtilService.RefreshToken(); throw exc; } catch (Exception ex) { Crashes.TrackError(ex); throw; } return(messages); }, cancellationToken);
public async Task PostGetMessageListAssertLimitTest(int paginationLimit) { PostMessageRequest[] messageArray = new PostMessageRequest[10]; var conversation = CreateRandomPostConversationRequest(); var fetchedConversation = await _chatServiceClient.AddConversation(conversation); for (int index = 0; index < 10; index++) { messageArray[index] = CreateRandomPostMessageRequest(); } for (int index = 0; index < 10; index++) { await _chatServiceClient.AddMessage(fetchedConversation.Id, messageArray[index]); } GetMessagesResponse fetchedMessageList = await _chatServiceClient.GetMessageList(fetchedConversation.Id, paginationLimit, 0); int countMessagesInFetchedList = fetchedMessageList.Messages.Length; Assert.Equal(paginationLimit, countMessagesInFetchedList); }
async Task CheckCloudMessages() { // Check my cloud for new messages var messages = await SendToCloudAgent(StreetcredMessages.GET_MESSAGES, new GetMessages()); var getMessages = new GetMessagesResponse(); getMessages.MergeFrom(messages.Content); foreach (var message in getMessages.Messages) { switch (message.Type) { case SovrinMessages.CONNECTION_RESPONSE: { var decrypted = await Crypto.AnonDecryptAsync(wallet, myVk, message.Content.ToByteArray()); var theirKey = await Did.KeyForDidAsync(pool, wallet, message.Origin); await Did.StoreTheirDidAsync(wallet, JsonConvert.SerializeObject(new { did = message.Origin, verkey = theirKey })); await Pairwise.CreateAsync(wallet, message.Origin, myDid, null); var ack = new ConnectionAcknowledgement(); ack.Message = "Success"; var encrypted = await Crypto.AuthCryptAsync(wallet, myVk, theirKey, ack.ToByteArray()); Console.WriteLine($"Sending connection acknowledgement to {agentDid} for {message.Origin} connection"); await SendToOrganizationAgent(SovrinMessages.CONNECTION_ACKONOWLEDGEMENT, message.Origin, agentDid, encrypted); break; } } } }
public async Task <GetMessagesResponse> GetMessageList(string conversationId, string continuationToken, int limit, long lastSeenMessageTime) { using (_logger.BeginScope("{ConversationId}", conversationId)) { var stopWatch = Stopwatch.StartNew(); MessageList messages = await _messageStore.GetMessages(conversationId, continuationToken, limit, lastSeenMessageTime); _telemetryClient.TrackMetric("MessageStore.GetMessages.Time", stopWatch.ElapsedMilliseconds); GetMessagesResponse messageList; String nextUri = ""; if (!string.IsNullOrWhiteSpace(messages.ContinuationToken)) { nextUri = $"api/conversations/{conversationId}/messages?continuationToken={WebUtility.UrlEncode(messages.ContinuationToken)}&limit={limit}&lastSeenMessageTime={lastSeenMessageTime}"; } messageList = new GetMessagesResponse { Messages = messages.Messages, NextUri = nextUri }; return(messageList); } }
/// <summary> /// Implementation for the GetPermissions method. /// </summary> /// <param name="visibilityTimeout">The visibility timeout interval.</param> /// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param> /// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns> private RESTCommand<CloudQueueMessage> GetMessageImpl(TimeSpan? visibilityTimeout, QueueRequestOptions options) { RESTCommand<CloudQueueMessage> getCmd = new RESTCommand<CloudQueueMessage>(this.ServiceClient.Credentials, this.GetMessageRequestAddress()); options.ApplyToStorageCommand(getCmd); getCmd.Handler = this.ServiceClient.AuthenticationHandler; getCmd.BuildClient = HttpClientFactory.BuildHttpClient; getCmd.RetrieveResponseStream = true; getCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.GetMessages(getCmd.Uri, getCmd.ServerTimeoutInSeconds, 1, visibilityTimeout, cnt, ctx); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx); getCmd.PostProcessResponse = (cmd, resp, ex, ctx) => { return Task.Factory.StartNew(() => { using (IEnumerator<QueueMessage> enumerator = new GetMessagesResponse(cmd.ResponseStream).Messages.GetEnumerator()) { if (enumerator.MoveNext()) { return SelectGetMessageResponse(enumerator.Current); } } return null; }); }; return getCmd; }
/// <summary> /// Implementation for the PeekMessages method. /// </summary> /// <param name="messageCount">The message count.</param> /// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param> /// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns> private RESTCommand<IEnumerable<CloudQueueMessage>> PeekMessagesImpl(int messageCount, QueueRequestOptions options) { RESTCommand<IEnumerable<CloudQueueMessage>> getCmd = new RESTCommand<IEnumerable<CloudQueueMessage>>(this.ServiceClient.Credentials, this.GetMessageRequestAddress()); options.ApplyToStorageCommand(getCmd); getCmd.Handler = this.ServiceClient.AuthenticationHandler; getCmd.BuildClient = HttpClientFactory.BuildHttpClient; getCmd.RetrieveResponseStream = true; getCmd.BuildRequest = (cmd, cnt, ctx) => QueueHttpRequestMessageFactory.PeekMessages(getCmd.Uri, getCmd.ServerTimeoutInSeconds, messageCount, cnt, ctx); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null, cmd, ex, ctx); getCmd.PostProcessResponse = (cmd, resp, ex, ctx) => { return Task.Factory.StartNew(() => { GetMessagesResponse getMessagesResponse = new GetMessagesResponse(cmd.ResponseStream); IEnumerable<CloudQueueMessage> messagesList = new List<CloudQueueMessage>( getMessagesResponse.Messages.Select(item => SelectPeekMessageResponse(item))); return messagesList; }); }; return getCmd; }
/// <summary> /// Implementation for the PeekMessages method. /// </summary> /// <param name="messageCount">The number of messages to retrieve.</param> /// <param name="options">An <see cref="QueueRequestOptions"/> object that specifies any additional options for the request.</param> /// <returns>A <see cref="RESTCommand{T}"/> that gets the permissions.</returns> private RESTCommand<IEnumerable<CloudQueueMessage>> PeekMessagesImpl(int messageCount, QueueRequestOptions options) { RESTCommand<IEnumerable<CloudQueueMessage>> getCmd = new RESTCommand<IEnumerable<CloudQueueMessage>>(this.ServiceClient.Credentials, this.GetMessageRequestAddress()); options.ApplyToStorageCommand(getCmd); getCmd.RetrieveResponseStream = true; getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, ctx) => QueueHttpWebRequestFactory.PeekMessages(getCmd.Uri, serverTimeout, messageCount, ctx); getCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest; getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex, ctx); getCmd.PostProcessResponse = (cmd, resp, ex, ctx) => { GetMessagesResponse getMessagesResponse = new GetMessagesResponse(cmd.ResponseStream); List<CloudQueueMessage> messagesList = new List<CloudQueueMessage>( getMessagesResponse.Messages.Select(item => SelectPeekMessageResponse(item))); return messagesList; }; return getCmd; }
public IEnumerable <ChatEntry> Convert(GetMessagesResponse source, IEnumerable <ChatEntry> destination, ResolutionContext context) { return(GetMessages(source, context)); }
public ActionResult GetMessagesCompleted( string error, DateTime? since, IEnumerable<string> messages) { if (!string.IsNullOrWhiteSpace(error)) return Json(new GetMessagesResponse() { error = error }); var data = new GetMessagesResponse(); data.since = since.Value.ToString("o"); data.messages = messages; return Json(data); }
/// <summary> /// Implementation for the PeekMessage method. /// </summary> /// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param> /// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns> private RESTCommand<CloudQueueMessage> PeekMessageImpl(QueueRequestOptions options) { RESTCommand<CloudQueueMessage> getCmd = new RESTCommand<CloudQueueMessage>(this.ServiceClient.Credentials, this.GetMessageRequestAddress()); options.ApplyToStorageCommand(getCmd); getCmd.RetrieveResponseStream = true; getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.PeekMessages(uri, serverTimeout, 1, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex); getCmd.PostProcessResponse = (cmd, resp, ctx) => { return Task.Factory.StartNew(() => { using (IEnumerator<QueueMessage> enumerator = new GetMessagesResponse(cmd.ResponseStream).Messages.GetEnumerator()) { if (enumerator.MoveNext()) { return SelectPeekMessageResponse(enumerator.Current); } } return null; }); }; return getCmd; }
/// <summary> /// Implementation for the PeekMessages method. /// </summary> /// <param name="messageCount">The message count.</param> /// <param name="options">A <see cref="QueueRequestOptions"/> object that specifies additional options for the request.</param> /// <returns>A <see cref="RESTCommand"/> that gets the permissions.</returns> private RESTCommand<IEnumerable<CloudQueueMessage>> PeekMessagesImpl(int messageCount, QueueRequestOptions options) { RESTCommand<IEnumerable<CloudQueueMessage>> getCmd = new RESTCommand<IEnumerable<CloudQueueMessage>>(this.ServiceClient.Credentials, this.GetMessageRequestAddress()); options.ApplyToStorageCommand(getCmd); getCmd.CommandLocationMode = CommandLocationMode.PrimaryOrSecondary; getCmd.RetrieveResponseStream = true; getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => QueueHttpRequestMessageFactory.PeekMessages(uri, serverTimeout, messageCount, cnt, ctx, this.ServiceClient.GetCanonicalizer(), this.ServiceClient.Credentials); getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null, cmd, ex); getCmd.PostProcessResponse = (cmd, resp, ctx) => { return Task.Factory.StartNew(() => { GetMessagesResponse getMessagesResponse = new GetMessagesResponse(cmd.ResponseStream); IEnumerable<CloudQueueMessage> messagesList = getMessagesResponse.Messages.Select(item => SelectPeekMessageResponse(item)).ToList(); return messagesList; }); }; return getCmd; }