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