public ITwitterIterator <IMessage> GetMessagesIterator(IGetMessagesParameters parameters)
{
var pageIterator = _messageRequester.GetMessagesIterator(parameters);
return(new TwitterIteratorProxy <ITwitterResult <IMessageCursorQueryResultDTO>, IMessage>(pageIterator,
twitterResult =>
{
var messageEventDtos = twitterResult.DataTransferObject.MessageEvents;
var messageDtos = messageEventDtos.Select(dto =>
{
var messageDto = new MessageEventWithAppDTO
{
MessageEvent = dto
};
var appId = dto.MessageCreate.SourceAppId;
if (appId != null && twitterResult.DataTransferObject.Apps != null && twitterResult.DataTransferObject.Apps.ContainsKey(appId.Value))
{
messageDto.App = twitterResult.DataTransferObject.Apps[appId.Value];
}
return messageDto as IMessageEventWithAppDTO;
});
return _client.Factories.CreateMessages(messageDtos);
}));
}
public void Validate(IGetMessagesParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
}
public GetMessagesParameters(IGetMessagesParameters parameters) : base(parameters)
{
if (parameters == null)
{
PageSize = TwitterLimits.DEFAULTS.MESSAGES_GET_MAX_PAGE_SIZE;
}
}
/// <summary>
/// Get the latest messages sent or received
/// </summary>
public static async Task <IResultsWithCursor <IMessage> > GetLatestMessages(IGetMessagesParameters queryParameters)
{
string cursor = null;
IEnumerable <IMessage> messages =
await Sync.ExecuteTaskAsync(() => Message.GetLatestMessages(queryParameters, out cursor));
return(generateResultsWithCursor(messages, cursor));
}
// Get collection of messages
public string GetLatestMessagesQuery(IGetMessagesParameters queryParameters)
{
var query = new StringBuilder(string.Format(Resources.Message_GetMessages, queryParameters.Count));
query.Append(_queryParameterGenerator.GenerateCursorParameter(queryParameters.Cursor));
return(query.ToString());
}
public string GetMessagesQuery(IGetMessagesParameters parameters)
{
var query = new StringBuilder(Resources.Message_GetMessages);
_queryParameterGenerator.AppendCursorParameters(query, parameters);
query.AddFormattedParameterToQuery(parameters.FormattedCustomQueryParameters);
return(query.ToString());
}
public void Validate(IGetMessagesParameters parameters)
{
_messagesClientRequiredParametersValidator.Validate(parameters);
var maxPageSize = Limits.MESSAGES_GET_MAX_PAGE_SIZE;
if (parameters.PageSize > maxPageSize)
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.PageSize)}", maxPageSize, nameof(Limits.MESSAGES_GET_MAX_PAGE_SIZE), "page size");
}
}
public IEnumerable <IMessage> GetLatestMessages(IGetMessagesParameters parameters, out string cursor)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
// If we've been asked to fetch more than the maximum number of results that Twitter will return from
// a single API request, we need to break this up into multiple requests
if (parameters.Count > TweetinviConsts.MESSAGE_GET_COUNT)
{
// Firstly, run a request for the maximum number of messages from the supplied cursor
// Note: copy the request rather than just updating the count in case the caller intends to
// reuse the parameters object for future requests
var thisReqParams = _getMessagesParametersFactory.Create();
thisReqParams.Count = TweetinviConsts.MESSAGE_GET_COUNT;
thisReqParams.Cursor = parameters.Cursor;
var result = _messageQueryExecutor.GetLatestMessages(thisReqParams);
cursor = result.NextCursor;
var messages = _messageFactory.GenerateMessageFromGetMessagesDTO(result);
// If there are more messages still available to be fetched from Twitter
if (!string.IsNullOrEmpty(cursor))
{
// Build & run the next request
var nextReqParams = _getMessagesParametersFactory.Create();
nextReqParams.Count = parameters.Count - thisReqParams.Count;
nextReqParams.Cursor = cursor;
IEnumerable <IMessage> nextReqResults = GetLatestMessages(nextReqParams, out cursor);
// Combine the results, latest first & return them
return(messages.Concat(nextReqResults));
}
// Otherwise, just return these results
return(messages);
}
else // Otherwise just run the request as-is against the Twitter API
{
var getMessagesDTO = _messageQueryExecutor.GetLatestMessages(parameters);
if (getMessagesDTO == null)
{
cursor = null;
return(null);
}
cursor = getMessagesDTO.NextCursor;
return(_messageFactory.GenerateMessageFromGetMessagesDTO(getMessagesDTO));
}
}
public ITwitterPageIterator <ITwitterResult <IMessageCursorQueryResultDTO> > GetMessagesIterator(IGetMessagesParameters parameters)
{
_messagesClientParametersValidator.Validate(parameters);
var request = TwitterClient.CreateRequest();
request.ExecutionContext.Converters = JsonQueryConverterRepository.Converters;
return(_messageController.GetMessagesIterator(parameters, request));
}
/// <summary>
/// Warning: Behaviour differs from MessageController.GetLatestMessages.
/// This method will not make multiple requests to the Twitter API and combine their results,
/// as that would require parsing the JSON, instead that is left up to the caller.
/// </summary>
public static string GetLatestMessages(IGetMessagesParameters parameters)
{
return(MessageJsonController.GetLatestMessages(parameters));
}
public Task <ITwitterResult <IMessageCursorQueryResultDTO> > GetMessagesAsync(IGetMessagesParameters parameters, TwitterRequest request)
{
request.Query.Url = _messageQueryGenerator.GetMessagesQuery(parameters);
request.Query.HttpMethod = HttpMethod.GET;
return(_twitterAccessor.ExecuteRequestAsync <IMessageCursorQueryResultDTO>(request));
}
/// <summary>
/// Get the latest messages sent or received
/// </summary>
public static IEnumerable <IMessage> GetLatestMessages(IGetMessagesParameters queryParameters, out string cursor)
{
return(MessageController.GetLatestMessages(queryParameters, out cursor));
}
/// <summary>
/// Get the latest messages sent or received
/// </summary>
public static IEnumerable <IMessage> GetLatestMessages(IGetMessagesParameters queryParameters)
{
return(MessageController.GetLatestMessages(queryParameters));
}
public IEnumerable <IMessage> GetLatestMessages(IGetMessagesParameters parameters)
{
return(GetLatestMessages(parameters, out _));
}
public async Task <IMessage[]> GetMessages(IGetMessagesParameters parameters)
{
var iterator = GetMessagesIterator(parameters);
return((await iterator.NextPage().ConfigureAwait(false)).ToArray());
}
public ITwitterPageIterator <ITwitterResult <IMessageCursorQueryResultDTO> > GetMessagesIterator(IGetMessagesParameters parameters, ITwitterRequest request)
{
return(new TwitterPageIterator <ITwitterResult <IMessageCursorQueryResultDTO> >(
parameters.Cursor,
cursor =>
{
var cursoredParameters = new GetMessagesParameters(parameters)
{
Cursor = cursor
};
return _messageQueryExecutor.GetMessagesAsync(cursoredParameters, new TwitterRequest(request));
},
page => page.Model.NextCursorStr,
page =>
{
return page.Model.NextCursorStr == "0" || string.IsNullOrEmpty(page.Model.NextCursorStr);
}));
}
public void Validate(IGetMessagesParameters parameters)
{
_messagesClientParametersValidator.Validate(parameters);
}
// Get Messages
public IGetMessagesDTO GetLatestMessages(IGetMessagesParameters queryParameters)
{
string query = _messageQueryGenerator.GetLatestMessagesQuery(queryParameters);
return(_twitterAccessor.ExecuteGETQuery <IGetMessagesDTO>(query));
}
