public PublishTweetParameters(IPublishTweetParameters source) : base(source)
{
if (source == null)
{
return;
}
Text = source.Text;
InReplyToTweet = source.InReplyToTweet;
QuotedTweet = source.QuotedTweet;
if (InReplyToTweet == null)
{
InReplyToTweetId = source.InReplyToTweetId;
}
MediaIds = source.MediaIds?.ToList();
Medias = source.Medias?.ToList();
PlaceId = source.PlaceId;
Coordinates = source.Coordinates;
DisplayExactCoordinates = source.DisplayExactCoordinates;
PossiblySensitive = source.PossiblySensitive;
TrimUser = source.TrimUser;
AutoPopulateReplyMetadata = source.AutoPopulateReplyMetadata;
ExcludeReplyUserIds = source.ExcludeReplyUserIds;
TweetMode = source.TweetMode;
}
// Publish Tweet
public string GetPublishTweetQuery(IPublishTweetParameters queryParameters)
{
_tweetQueryValidator.ThrowIfTweetCannotBePublished(queryParameters);
var text = queryParameters.Text;
var useExtendedMode = _tweetinviSettingsAccessor.CurrentThreadSettings.TweetMode == TweetMode.Extended;
var quotedTweetUrl = GetQuotedTweetUrl(queryParameters);
if (!useExtendedMode && quotedTweetUrl != null)
{
text = text.TrimEnd() + " " + quotedTweetUrl;
}
var query = new StringBuilder(string.Format(Resources.Tweet_Publish, CleanupString(text)));
if (queryParameters.Parameters != null)
{
if (queryParameters.InReplyToTweet != null)
{
query.AddParameterToQuery("in_reply_to_status_id", queryParameters.InReplyToTweet.Id);
// Extended Tweet prefix auto-population
query.AddParameterToQuery("auto_populate_reply_metadata", queryParameters.AutoPopulateReplyMetadata);
if (queryParameters.ExcludeReplyUserIds != null)
{
query.AddParameterToQuery("exclude_reply_user_ids", String.Join(",", queryParameters.ExcludeReplyUserIds));
}
}
query.AddParameterToQuery("possibly_sensitive", queryParameters.PossiblySensitive);
if (queryParameters.Coordinates != null)
{
query.AddParameterToQuery("lat", queryParameters.Coordinates.Latitude.ToString(CultureInfo.InvariantCulture));
query.AddParameterToQuery("long", queryParameters.Coordinates.Longitude.ToString(CultureInfo.InvariantCulture));
}
query.AddParameterToQuery("place_id", queryParameters.PlaceId);
query.AddParameterToQuery("display_coordinates", queryParameters.DisplayExactCoordinates);
query.AddParameterToQuery("trim_user", queryParameters.TrimUser);
query.AddParameterToQuery("tweet_mode", _tweetinviSettingsAccessor.CurrentThreadSettings.TweetMode.ToString().ToLowerInvariant());
if (useExtendedMode && quotedTweetUrl != null)
{
query.AddParameterToQuery("attachment_url", quotedTweetUrl);
}
if (queryParameters.MediaIds.Count > 0)
{
var mediaIdsParameter = string.Join(",", queryParameters.MediaIds.Select(x => x.ToString(CultureInfo.InvariantCulture)));
query.AddParameterToQuery("media_ids", mediaIdsParameter);
}
query.Append(_queryParameterGenerator.GenerateAdditionalRequestParameters(queryParameters.FormattedCustomQueryParameters));
}
return(query.ToString());
}
public Task <ITwitterResult <ITweetDTO> > PublishTweetAsync(IPublishTweetParameters parameters, ITwitterRequest request)
{
var query = _tweetQueryGenerator.GetPublishTweetQuery(parameters, request.ExecutionContext.TweetMode);
request.Query.Url = query;
request.Query.HttpMethod = HttpMethod.POST;
return(_twitterAccessor.ExecuteRequestAsync <ITweetDTO>(request));
}
// Publish Tweet
public string GetPublishTweetQuery(IPublishTweetParameters parameters, TweetMode?requestTweetMode)
{
var text = parameters.Text;
var useExtendedTweetMode = requestTweetMode == null || requestTweetMode == TweetMode.Extended;
var quotedTweetUrl = GetQuotedTweetUrl(parameters);
var attachmentUrl = parameters.QuotedTweetUrl;
if (quotedTweetUrl != null)
{
// if there is a quoted tweet we need to pass the url in the text or attachment url
// attachment_url is only available under tweetMode
if (useExtendedTweetMode && attachmentUrl == null)
{
attachmentUrl = quotedTweetUrl;
}
else
{
text = text.TrimEnd() + " " + quotedTweetUrl;
}
}
var query = new StringBuilder(Resources.Tweet_Publish);
query.AddParameterToQuery("status", text);
query.AddParameterToQuery("auto_populate_reply_metadata", parameters.AutoPopulateReplyMetadata);
query.AddParameterToQuery("attachment_url", attachmentUrl);
query.AddParameterToQuery("card_uri", parameters.CardUri);
query.AddParameterToQuery("display_coordinates", parameters.DisplayExactCoordinates);
if (parameters.ExcludeReplyUserIds != null)
{
query.AddParameterToQuery("exclude_reply_user_ids", string.Join(",", parameters.ExcludeReplyUserIds));
}
query.AddParameterToQuery("in_reply_to_status_id", GetTweetId(parameters.InReplyToTweet));
query.AddParameterToQuery("lat", parameters.Coordinates?.Latitude.ToString(CultureInfo.InvariantCulture));
query.AddParameterToQuery("long", parameters.Coordinates?.Longitude.ToString(CultureInfo.InvariantCulture));
if (parameters.MediaIds.Count > 0)
{
var mediaIdsParameter = string.Join(",", parameters.MediaIds.Select(x => x.ToString(CultureInfo.InvariantCulture)));
query.AddParameterToQuery("media_ids", mediaIdsParameter);
}
query.AddParameterToQuery("place_id", parameters.PlaceId);
query.AddParameterToQuery("possibly_sensitive", parameters.PossiblySensitive);
query.AddParameterToQuery("trim_user", parameters.TrimUser);
_queryParameterGenerator.AppendTweetModeParameter(query, parameters.TweetMode ?? requestTweetMode);
query.AddFormattedParameterToQuery(parameters.FormattedCustomQueryParameters);
return(query.ToString());
}
public static Task <bool> PublishTweetAsync(IPublishTweetParameters optionalParameters = null)
=> Task.Factory.StartNew(() => {
Auth.SetCredentials(Auth.ApplicationCredentials);
if (Tweet.PublishTweet(optionalParameters) != null)
{
return(true);
}
return(false);
});
private string GetQuotedTweetUrl(IPublishTweetParameters parameters)
{
if (parameters.QuotedTweet?.CreatedBy?.ScreenName == null)
{
return(null);
}
var quotedTweetId = GetTweetId(parameters.QuotedTweet);
return($"https://twitter.com/{parameters.QuotedTweet.CreatedBy.ScreenName}/status/{quotedTweetId}");
}
private string GetQuotedTweetUrl(IPublishTweetParameters parameters)
{
if (parameters.QuotedTweet?.CreatedBy?.ScreenName == null)
{
return(null);
}
return(string.Format("https://twitter.com/{0}/status/{1}",
parameters.QuotedTweet.CreatedBy.ScreenName,
parameters.QuotedTweet.Id.ToString(CultureInfo.InvariantCulture)));
}
// Publish Tweet
public string GetPublishTweetQuery(IPublishTweetParameters queryParameters)
{
_tweetQueryValidator.ThrowIfTweetCannotBePublished(queryParameters);
var text = queryParameters.Text;
if (queryParameters.QuotedTweet != null)
{
var quotedTweet = queryParameters.QuotedTweet;
if (quotedTweet.CreatedBy != null)
{
text = text.TrimEnd();
text += string.Format(" https://twitter.com/{0}/status/{1}",
quotedTweet.CreatedBy.ScreenName,
quotedTweet.Id.ToString(CultureInfo.InvariantCulture));
}
}
var query = new StringBuilder(string.Format(Resources.Tweet_Publish, CleanupString(text)));
if (queryParameters.Parameters != null)
{
if (queryParameters.InReplyToTweet != null)
{
query.AddParameterToQuery("in_reply_to_status_id", queryParameters.InReplyToTweet.Id);
}
query.AddParameterToQuery("possibly_sensitive", queryParameters.PossiblySensitive);
if (queryParameters.Coordinates != null)
{
query.AddParameterToQuery("lat", queryParameters.Coordinates.Latitude.ToString(CultureInfo.InvariantCulture));
query.AddParameterToQuery("long", queryParameters.Coordinates.Longitude.ToString(CultureInfo.InvariantCulture));
}
query.AddParameterToQuery("place_id", queryParameters.PlaceId);
query.AddParameterToQuery("display_coordinates", queryParameters.DisplayExactCoordinates);
query.AddParameterToQuery("trim_user", queryParameters.TrimUser);
query.AddParameterToQuery("auto_populate_reply_metadata", queryParameters.AutoPopulateReplyMetadata);
query.AddParameterToQuery("tweet_mode", _tweetinviSettingsAccessor.CurrentThreadSettings.TweetMode?.ToString().ToLowerInvariant());
if (queryParameters.MediaIds.Count > 0)
{
var mediaIdsParameter = string.Join("%2C", queryParameters.MediaIds.Select(x => x.ToString(CultureInfo.InvariantCulture)));
query.AddParameterToQuery("media_ids", mediaIdsParameter);
}
query.Append(_queryParameterGenerator.GenerateAdditionalRequestParameters(queryParameters.FormattedCustomQueryParameters));
}
return(query.ToString());
}
private ITweetDTO InternalPublishTweet(IPublishTweetParameters parameters)
{
// The exceptions have to be raised before the QueryGenerator as
// We do not want to wait for the media to be uploaded to throw the
// Exception. And The logic of uploading the media should live in
// the TweetController
_tweetQueryValidator.ThrowIfTweetCannotBePublished(parameters);
UploadMedias(parameters);
return(_tweetQueryExecutor.PublishTweet(parameters));
}
// Publish Tweet
public string GetPublishTweetQuery(IPublishTweetParameters queryParameters)
{
_tweetQueryValidator.ThrowIfTweetCannotBePublished(queryParameters);
var text = queryParameters.Text;
if (queryParameters.QuotedTweet != null)
{
var quotedTweet = queryParameters.QuotedTweet;
if (quotedTweet.CreatedBy != null)
{
text += string.Format("https://twitter.com/{0}/status/{1}",
quotedTweet.CreatedBy.ScreenName,
quotedTweet.Id.ToString(CultureInfo.InvariantCulture));
}
}
var query = new StringBuilder(string.Format(Resources.Tweet_Publish, CleanupString(text)));
if (queryParameters.Parameters != null)
{
if (queryParameters.InReplyToTweet != null)
{
query.AddParameterToQuery("in_reply_to_status_id", queryParameters.InReplyToTweet.Id);
}
query.AddParameterToQuery("possibly_sensitive", queryParameters.PossiblySensitive);
if (queryParameters.Coordinates != null)
{
query.AddParameterToQuery("lat", queryParameters.Coordinates.Latitude.ToString(CultureInfo.InvariantCulture));
query.AddParameterToQuery("long", queryParameters.Coordinates.Longitude.ToString(CultureInfo.InvariantCulture));
}
query.AddParameterToQuery("place_id", queryParameters.PlaceId);
query.AddParameterToQuery("display_coordinates", queryParameters.DisplayExactCoordinates);
query.AddParameterToQuery("trim_user", queryParameters.TrimUser);
if (queryParameters.MediaIds.Count > 0)
{
var mediaIdsParameter = string.Join("%2C", queryParameters.MediaIds.Select(x => x.ToString(CultureInfo.InvariantCulture)));
query.AddParameterToQuery("media_ids", mediaIdsParameter);
}
query.Append(_queryParameterGenerator.GenerateAdditionalRequestParameters(queryParameters.FormattedCustomQueryParameters));
}
return query.ToString();
}
public void UploadMedias(IPublishTweetParameters parameters)
{
if (parameters.Medias.Any(x => !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the medias could not be published!");
}
parameters.MediaIds.AddRange(parameters.Medias.Select(x => x.UploadedMediaInfo.MediaId));
var uploadedMedias = parameters.MediaBinaries
.Select(binary => { return(_uploadQueryExecutor.UploadBinary(binary)); }).ToArray();
if (uploadedMedias.Any(x => x == null || !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the binaries could not be published!");
}
parameters.MediaIds.AddRange(uploadedMedias.Select(x => x.UploadedMediaInfo.MediaId));
}
public void ThrowIfTweetCannotBePublished(IPublishTweetParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("Publish parameters cannot be null.");
}
if (string.IsNullOrEmpty(parameters.Text))
{
throw new ArgumentException("The text message of a tweet cannot be null or empty.");
}
var mediaObjectIds = parameters.Medias.Where(x => x.MediaId != null).Select(x => x.MediaId.Value);
var mediaIds = parameters.MediaIds.Concat(mediaObjectIds).Distinct();
if (mediaIds.Count() > 4)
{
throw new ArgumentException("Cannot publish a tweet with more than 4 medias.");
}
}
public void ThrowIfTweetCannotBePublished(IPublishTweetParameters parameters)
{
if (parameters == null)
{
throw new ArgumentException("Publish parameters cannot be null.");
}
if (string.IsNullOrEmpty(parameters.Text))
{
throw new ArgumentException("The text message of a tweet cannot be null or empty.");
}
var mediaObjectIds = parameters.Medias.Where(x => x.MediaId != null).Select(x => x.MediaId.Value);
var mediaIds = parameters.MediaIds.Concat(mediaObjectIds).Distinct();
if (mediaIds.Count() > 4)
{
throw new ArgumentException("Cannot publish a tweet with more than 4 medias.");
}
}
private void Publish(IPublishTweetParameters tweet)
{
var message = Tweet.PublishTweet(tweet);
if (message != null)
{
return;
}
var exception = ExceptionHandler.GetLastException();
if (exception == null)
{
return;
}
foreach (var exceptionTwitterExceptionInfo in exception.TwitterExceptionInfos)
{
log.LogError(exceptionTwitterExceptionInfo.Message);
}
}
private static int EstimateTweetLength(IPublishTweetParameters publishTweetParameters)
{
var text = publishTweetParameters.Text ?? "";
#pragma warning disable 618
var textLength = StringExtension.EstimateTweetLength(text);
if (publishTweetParameters.QuotedTweet != null)
{
textLength = StringExtension.EstimateTweetLength(text.TrimEnd()) +
1 + // for the space that needs to be added before the link to quoted tweet.
TweetinviConsts.MEDIA_CONTENT_SIZE;
#pragma warning restore 618
}
if (publishTweetParameters.HasMedia)
{
textLength += TweetinviConsts.MEDIA_CONTENT_SIZE;
}
return(textLength);
}
public void Validate(IPublishTweetParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.InReplyToTweet != null)
{
ThrowIfTweetCannotBeUsed(parameters.InReplyToTweet);
}
if (parameters.QuotedTweet != null)
{
ThrowIfTweetCannotBeUsed(parameters.QuotedTweet);
}
if (parameters.Medias.Any(x => !x.HasBeenUploaded))
{
throw new ArgumentException("Some media were not uploaded", $"{nameof(parameters)}.{nameof(parameters.Medias)}");
}
}
public void UploadMedias(IPublishTweetParameters parameters)
{
_uploadQueryExecutor.UploadMedias(parameters.Medias, false);
if (parameters.Medias.Any(x => !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the medias could not be published!");
}
else
{
parameters.MediaIds.AddRange(parameters.Medias.Select(x => x.UploadedMediaInfo.MediaId));
}
var binariesMedia = _uploadQueryExecutor.UploadBinaries(parameters.MediaBinaries);
if (binariesMedia.Any(x => !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the binaries could not be published!");
}
else
{
parameters.MediaIds.AddRange(binariesMedia.Select(x => x.UploadedMediaInfo.MediaId));
}
}
// Publish Tweet
public static ITweet PublishTweet(IPublishTweetParameters publishTweetParameters)
{
return TweetController.PublishTweet(publishTweetParameters);
}
public async Task <ITweet> PublishTweetAsync(IPublishTweetParameters parameters)
{
var requestResult = await _tweetsRequester.PublishTweetAsync(parameters).ConfigureAwait(false);
return(_client.Factories.CreateTweet(requestResult?.Model));
}
public int Length(IPublishTweetParameters publishTweetParameters)
{
return(Length(publishTweetParameters.Text, publishTweetParameters.Parameters));
}
public bool CanBePublished(IPublishTweetParameters publishTweetParameters)
{
return(TweetinviConsts.MAX_TWEET_SIZE >= Length(publishTweetParameters));
}
// Tweets - Publish
public Task <ITwitterResult <ITweetDTO> > PublishTweetAsync(IPublishTweetParameters parameters)
{
_tweetsClientRequiredParametersValidator.Validate(parameters);
return(ExecuteRequestAsync(request => _tweetController.PublishTweetAsync(parameters, request)));
}
// Publish Tweet
public ITweetDTO PublishTweet(IPublishTweetParameters publishParameters)
{
string query = _tweetQueryGenerator.GetPublishTweetQuery(publishParameters);
return(_twitterAccessor.ExecutePOSTQuery <ITweetDTO>(query));
}
// Publish Tweet
public ITweetDTO PublishTweet(IPublishTweetParameters publishParameters)
{
string query = _tweetQueryGenerator.GetPublishTweetQuery(publishParameters);
return _twitterAccessor.ExecutePOSTQuery<ITweetDTO>(query);
}
public void UploadMedias(IPublishTweetParameters parameters)
{
_uploadQueryExecutor.UploadMedias(parameters.Medias, false);
if (parameters.Medias.Any(x => !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the medias could not be published!");
}
else
{
parameters.MediaIds.AddRange(parameters.Medias.Select(x => x.UploadedMediaInfo.MediaId));
}
var binariesMedia = _uploadQueryExecutor.UploadBinaries(parameters.MediaBinaries);
if (binariesMedia.Any(x => !x.HasBeenUploaded))
{
throw new OperationCanceledException("The tweet cannot be published as some of the binaries could not be published!");
}
else
{
parameters.MediaIds.AddRange(binariesMedia.Select(x => x.UploadedMediaInfo.MediaId));
}
}
private ITweetDTO InternalPublishTweet(IPublishTweetParameters parameters)
{
// The exceptions have to be raised before the QueryGenerator as
// We do not want to wait for the media to be uploaded to throw the
// Exception. And The logic of uploading the media should live in
// the TweetController
_tweetQueryValidator.ThrowIfTweetCannotBePublished(parameters);
UploadMedias(parameters);
return _tweetQueryExecutor.PublishTweet(parameters);
}
// Length
/// <summary>
/// Get the length of a tweet as calculated by Twitter
/// </summary>
public static int Length(IPublishTweetParameters publishTweetParameters)
{
return(TweetController.Length(publishTweetParameters));
}
// Can be published
/// <summary>
/// Verify that a tweet can be published
/// </summary>
public static bool CanBePublished(IPublishTweetParameters publishTweetParameters)
{
return(TweetController.CanBePublished(publishTweetParameters));
}
public async Task <ITwitterResult <ITweetDTO> > PublishTweet(IPublishTweetParameters parameters, ITwitterRequest request)
{
parameters.MediaIds.AddRange(parameters.Medias.Select(x => x.UploadedMediaInfo.MediaId));
return(await _tweetQueryExecutor.PublishTweet(parameters, request).ConfigureAwait(false));
}
// Length
public static int Length(IPublishTweetParameters publishTweetParameters)
{
return TweetController.Length(publishTweetParameters);
}
// Can be published
public static bool CanBePublished(IPublishTweetParameters publishTweetParameters)
{
return TweetController.CanBePublished(publishTweetParameters);
}
// Publish Tweet
public ITweet PublishTweet(IPublishTweetParameters parameters)
{
return _tweetFactory.GenerateTweetFromDTO(InternalPublishTweet(parameters));
}
public bool CanBePublished(IPublishTweetParameters publishTweetParameters)
{
return(true);
//return TweetinviConsts.MAX_TWEET_SIZE >= EstimateTweetLength(publishTweetParameters);
}
// Publish Tweet
public ITweet PublishTweet(IPublishTweetParameters parameters)
{
return(_tweetFactory.GenerateTweetFromDTO(InternalPublishTweet(parameters)));
}
// Tweet
public Task <ITweet> PublishTweet(IPublishTweetParameters parameters)
{
return(Client.Tweets.PublishTweet(parameters));
}
public static int EstimateTweetLength(IPublishTweetParameters publishTweetParameters)
{
return(EstimateTweetLength(publishTweetParameters.Text, publishTweetParameters.Parameters));
}
// Publish Tweet
/// <summary>
/// Publish a tweet
/// </summary>
public static ITweet PublishTweet(IPublishTweetParameters publishTweetParameters)
{
return(TweetController.PublishTweet(publishTweetParameters));
}
public int Length(IPublishTweetParameters publishTweetParameters)
{
return Length(publishTweetParameters.Text, publishTweetParameters.Parameters);
}
public void Validate(IPublishTweetParameters parameters)
{
_tweetsClientParametersValidator.Validate(parameters);
}
public bool CanBePublished(IPublishTweetParameters publishTweetParameters)
{
return TweetinviConsts.MAX_TWEET_SIZE <= Length(publishTweetParameters);
}
