// Publish Message
public IMessageDTO PublishMessage(IPublishMessageParameters parameters)
{
_messageQueryValidator.ThrowIfMessageCannotBePublished(parameters);
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return _twitterAccessor.ExecutePOSTQuery<IMessageDTO>(query);
}
// Publish Message
public ICreateMessageDTO PublishMessage(IPublishMessageParameters parameters)
{
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
var reqDTO = _messageQueryGenerator.GetPublishMessageBody(parameters);
return(_twitterAccessor.ExecutePOSTQueryJsonBody <ICreateMessageDTO>(query, reqDTO));
}
public ICreateMessageDTO GetPublishMessageBody(IPublishMessageParameters parameters)
{
ICreateMessageDTO createMessageDTO = _createMessageDTOFactory.Create();
createMessageDTO.Event = _eventDTOFactory.Create();
createMessageDTO.Event.Type = EventType.MessageCreate;
createMessageDTO.Event.MessageCreate = _messageCreateDTOFactory.Create();
createMessageDTO.Event.MessageCreate.Target = _messageCreateTargetDTOFactory.Create();
createMessageDTO.Event.MessageCreate.Target.RecipientId = parameters.RecipientId;
createMessageDTO.Event.MessageCreate.MessageData = _messageDataDTOFactory.Create();
createMessageDTO.Event.MessageCreate.MessageData.Text = parameters.Text;
// If there is media attached, include it
if (parameters.AttachmentMediaId != null)
{
createMessageDTO.Event.MessageCreate.MessageData.Attachment = _attachmentDTOFactory.Create();
createMessageDTO.Event.MessageCreate.MessageData.Attachment.Type = AttachmentType.Media;
createMessageDTO.Event.MessageCreate.MessageData.Attachment.Media = _mediaEntityFactory.Create();
createMessageDTO.Event.MessageCreate.MessageData.Attachment.Media.Id = parameters.AttachmentMediaId;
}
// If there are quick reply options, include them
if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0)
{
createMessageDTO.Event.MessageCreate.MessageData.QuickReply = _quickReplyDTOFactory.Create();
createMessageDTO.Event.MessageCreate.MessageData.QuickReply.Type = QuickReplyType.Options;
createMessageDTO.Event.MessageCreate.MessageData.QuickReply.Options = parameters.QuickReplyOptions;
}
return(createMessageDTO);
}
public void ThrowIfMessageCannotBePublished(IPublishMessageParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters), "Publish message parameters cannot be null.");
}
if (!IsMessageTextValid(parameters.Text))
{
throw new ArgumentException("Message text is not valid.");
}
if (!_userQueryValidator.IsUserIdValid(parameters.RecipientId))
{
throw new ArgumentException("Recipient User ID is not valid");
}
// If quick reply options are specified, validate them
if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0)
{
if (parameters.QuickReplyOptions.Length > TweetinviConsts.MESSAGE_QUICK_REPLY_MAX_OPTIONS)
{
throw new ArgumentException("There are too many Quick Reply Options. You can only have up to " +
TweetinviConsts.MESSAGE_QUICK_REPLY_MAX_OPTIONS);
}
var hasDescription = parameters.QuickReplyOptions[0].Description != null;
foreach (var o in parameters.QuickReplyOptions)
{
// If one option has a description, then they all must
// https://developer.twitter.com/en/docs/direct-messages/quick-replies/api-reference/options
if ((hasDescription && o.Description == null) || (!hasDescription && o.Description != null))
{
throw new ArgumentException("If one Quick Reply Option has a description, then they all must");
}
if (o.Label == null)
{
throw new ArgumentException("Quick Reply Option Label is a required field");
}
if (o.Label.UTF32Length() > TweetinviConsts.MESSAGE_QUICK_REPLY_LABEL_MAX_LENGTH)
{
throw new ArgumentException("Quick Reply Option Label too long. Max length is " +
TweetinviConsts.MESSAGE_QUICK_REPLY_LABEL_MAX_LENGTH);
}
if (o.Description != null && o.Description.UTF32Length() >
TweetinviConsts.MESSAGE_QUICK_REPLY_DESCRIPTION_MAX_LENGTH)
{
throw new ArgumentException("Quick Reply Option Description too long. Max length is " +
TweetinviConsts.MESSAGE_QUICK_REPLY_DESCRIPTION_MAX_LENGTH);
}
if (o.Metadata != null && o.Metadata.UTF32Length() >
TweetinviConsts.MESSAGE_QUICK_REPLY_METADATA_MAX_LENGTH)
{
throw new ArgumentException("Quick Reply Option Metadata too long. Max length is " +
TweetinviConsts.MESSAGE_QUICK_REPLY_METADATA_MAX_LENGTH);
}
}
}
}
// Publish Message
public IMessageDTO PublishMessage(IPublishMessageParameters parameters)
{
_messageQueryValidator.ThrowIfMessageCannotBePublished(parameters);
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return(_twitterAccessor.ExecutePOSTQuery <IMessageDTO>(query));
}
public Task <ITwitterResult <ICreateMessageDTO> > PublishMessageAsync(IPublishMessageParameters parameters, ITwitterRequest request)
{
var requestWithPayload = _messageQueryGenerator.GetPublishMessageQuery(parameters);
request.Query.Url = requestWithPayload.Url;
request.Query.HttpMethod = HttpMethod.POST;
request.Query.HttpContent = requestWithPayload.Content;
return(_twitterAccessor.ExecuteRequestAsync <ICreateMessageDTO>(request));
}
// Publish Message
public string GetPublishMessageQuery(IPublishMessageParameters parameters)
{
_messageQueryValidator.ThrowIfMessageCannotBePublished(parameters);
var query = Resources.Message_NewMessage;
query += _queryParameterGenerator.GenerateAdditionalRequestParameters(parameters.FormattedCustomQueryParameters, false);
return(query);
}
public IMessage PublishMessage(IPublishMessageParameters parameter)
{
if (parameter == null)
{
throw new ArgumentNullException("Parameter cannot be null.");
}
var publishedMessageDTO = _messageQueryExecutor.PublishMessage(parameter);
return _messageFactory.GenerateMessageFromMessageDTO(publishedMessageDTO);
}
public IMessage PublishMessage(IPublishMessageParameters parameter)
{
if (parameter == null)
{
throw new ArgumentNullException("Parameter cannot be null.");
}
var publishedMessageDTO = _messageQueryExecutor.PublishMessage(parameter);
return(_messageFactory.GenerateMessageFromMessageDTO(publishedMessageDTO));
}
private void ArrangeQueryGeneratorPublishMessage(IPublishMessageParameters parameters, string query,
ICreateMessageDTO createMessageDTO)
{
_fakeMessageQueryGenerator
.CallsTo(x => x.GetPublishMessageQuery(parameters))
.Returns(query);
_fakeMessageQueryGenerator
.CallsTo(x => x.GetPublishMessageBody(parameters))
.Returns(createMessageDTO);
}
public void Validate(IPublishMessageParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (string.IsNullOrEmpty(parameters.Text))
{
throw new ArgumentNullException($"{nameof(parameters)}.{nameof(parameters.Text)}");
}
}
public RequestWithPayload GetPublishMessageQuery(IPublishMessageParameters parameters)
{
var query = new StringBuilder(Resources.Message_Create);
query.AddFormattedParameterToQuery(parameters.FormattedCustomQueryParameters);
var content = _jsonContentFactory.Create(GetPublishMessageBody(parameters));
return(new RequestWithPayload
{
Url = query.ToString(),
Content = content
});
}
// Publish Message
public string GetPublishMessageQuery(IPublishMessageParameters parameters)
{
_messageQueryValidator.ThrowIfMessageCannotBePublished(parameters);
var messageText = parameters.Text;
var recipient = parameters.Recipient;
var identifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(recipient);
var query = string.Format(Resources.Message_NewMessage, _twitterStringFormatter.TwitterEncode(messageText), identifierParameter);
query += _queryParameterGenerator.GenerateAdditionalRequestParameters(parameters.FormattedCustomQueryParameters);
return(query);
}
public void ThrowIfMessageCannotBePublished(IPublishMessageParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("Publish message parameters cannot be null.");
}
var text = parameters.Text;
_userQueryValidator.ThrowIfUserCannotBeIdentified(parameters.Recipient);
if (!IsMessageTextValid(text))
{
throw new ArgumentException("Message text is not valid.");
}
}
private ICreateMessageDTO GetPublishMessageBody(IPublishMessageParameters parameters)
{
var createMessageDTO = new CreateMessageDTO
{
MessageEvent = new MessageEventDTO
{
Type = EventType.MessageCreate,
CreatedAt = new DateTimeOffset(2000, 11, 22, 0, 0, 0, TimeSpan.Zero),
MessageCreate = new MessageCreateDTO
{
Target = new MessageCreateTargetDTO
{
RecipientId = parameters.RecipientId
},
MessageData = new MessageDataDTO
{
Text = parameters.Text
}
},
}
};
// If there is media attached, include it
if (parameters.MediaId != null)
{
createMessageDTO.MessageEvent.MessageCreate.MessageData.Attachment = new AttachmentDTO
{
Type = AttachmentType.Media,
Media = new MediaEntity {
Id = parameters.MediaId
}
};
}
// If there are quick reply options, include them
if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0)
{
createMessageDTO.MessageEvent.MessageCreate.MessageData.QuickReply = new QuickReplyDTO
{
Type = QuickReplyType.Options,
Options = parameters.QuickReplyOptions,
};
}
return(createMessageDTO);
}
private void ArrangeMessageDTORecipient(
IPublishMessageParameters parameters,
bool isRecipientValid,
bool isRecipientIdValid,
bool isRecipientScreenNameValid)
{
var recipient = A.Fake <IUserDTO>();
var recipientId = TestHelper.GenerateRandomLong();
var recipientScreenName = TestHelper.GenerateString();
parameters.CallsTo(x => x.Recipient).Returns(recipient);
parameters.CallsTo(x => x.RecipientId).Returns(recipientId);
parameters.CallsTo(x => x.RecipientScreenName).Returns(recipientScreenName);
_fakeUserQueryValidator.CallsTo(x => x.CanUserBeIdentified(recipient)).Returns(isRecipientValid);
_fakeUserQueryValidator.CallsTo(x => x.IsUserIdValid(recipientId)).Returns(isRecipientIdValid);
_fakeUserQueryValidator.CallsTo(x => x.IsScreenNameValid(recipientScreenName)).Returns(isRecipientScreenNameValid);
}
// Publish Message
public string GetPublishMessageQuery(IPublishMessageParameters parameters)
{
var messageText = parameters.Text;
var recipient = parameters.Recipient;
if (!_messageQueryValidator.IsMessageTextValid(messageText) || !_userQueryValidator.CanUserBeIdentified(recipient))
{
return(null);
}
var identifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(recipient);
var query = GetPublishMessageFormattedQuery(messageText, identifierParameter);
query += _queryParameterGenerator.GenerateAdditionalRequestParameters(parameters.FormattedCustomQueryParameters);
return(query);
}
public bool CanMessageBePublished(IPublishMessageParameters parameters)
{
var message = parameters.Message;
var text = parameters.Text;
bool messageTextIsValid = IsMessageTextValid(text);
bool isRecipientValid = _userQueryValidator.CanUserBeIdentified(parameters.Recipient) ||
_userQueryValidator.IsUserIdValid(parameters.RecipientId) ||
_userQueryValidator.IsScreenNameValid(parameters.RecipientScreenName);
bool isMessageInValidState = message == null || (!message.IsMessagePublished && !message.IsMessageDestroyed);
if (!isMessageInValidState)
{
return false;
}
return isRecipientValid && messageTextIsValid;
}
public bool CanMessageBePublished(IPublishMessageParameters parameters)
{
var message = parameters.Message;
var text = parameters.Text;
bool messageTextIsValid = IsMessageTextValid(text);
bool isRecipientValid = _userQueryValidator.CanUserBeIdentified(parameters.Recipient) ||
_userQueryValidator.IsUserIdValid(parameters.RecipientId) ||
_userQueryValidator.IsScreenNameValid(parameters.RecipientScreenName);
bool isMessageInValidState = message == null || (!message.IsMessagePublished && !message.IsMessageDestroyed);
if (!isMessageInValidState)
{
return(false);
}
return(isRecipientValid && messageTextIsValid);
}
public Task <ITwitterResult <ICreateMessageDTO> > PublishMessage(IPublishMessageParameters parameters)
{
_messagesClientParametersValidator.Validate(parameters);
return(ExecuteRequest(request => _messageController.PublishMessage(parameters, request)));
}
private void ArrangeMessagePublishParameterText(IPublishMessageParameters parameters, bool doesTextExists, bool textContainsChars)
{
string text = doesTextExists ? textContainsChars ? TestHelper.GenerateString() : string.Empty : null;
parameters.CallsTo(x => x.Text).Returns(text);
}
// Publish Message
public string GetPublishMessageQuery(IPublishMessageParameters parameters)
{
_messageQueryValidator.ThrowIfMessageCannotBePublished(parameters);
var messageText = parameters.Text;
var recipient = parameters.Recipient;
var identifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(recipient);
var query = string.Format(Resources.Message_NewMessage, _twitterStringFormatter.TwitterEncode(messageText), identifierParameter);
query += _queryParameterGenerator.GenerateAdditionalRequestParameters(parameters.FormattedCustomQueryParameters);
return query;
}
public static string PublishMessage(IPublishMessageParameters parameters)
{
return(MessageJsonController.PublishMessage(parameters));
}
public string PublishMessage(IPublishMessageParameters parameters)
{
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return(_twitterAccessor.ExecutePOSTQueryReturningJson(query));
}
// Publish Message
public static async Task <IMessage> PublishMessage(IPublishMessageParameters parameters)
{
return(await Sync.ExecuteTaskAsync(() => Message.PublishMessage(parameters)));
}
// Publish Message
public IMessageDTO PublishMessage(IPublishMessageParameters parameters)
{
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return(_twitterAccessor.ExecutePOSTQuery <IMessageDTO>(query));
}
private void ArrangeQueryGeneratorPublishMessage(IPublishMessageParameters parameters, string query)
{
_fakeMessageQueryGenerator
.CallsTo(x => x.GetPublishMessageQuery(parameters))
.Returns(query);
}
private void ArrangeMessagePublishParameterText(IPublishMessageParameters parameters, bool doesTextExists, bool textContainsChars)
{
string text = doesTextExists ? textContainsChars ? TestHelper.GenerateString() : string.Empty : null;
parameters.CallsTo(x => x.Text).Returns(text);
}
public string PublishMessage(IPublishMessageParameters parameters)
{
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return _twitterAccessor.ExecuteJsonPOSTQuery(query);
}
/// <summary>
/// Publish a message
/// </summary>
public static IMessage PublishMessage(IPublishMessageParameters parameters)
{
return(MessageController.PublishMessage(parameters));
}
private void ArrangeMessageDTORecipient(
IPublishMessageParameters parameters,
bool isRecipientValid,
bool isRecipientIdValid,
bool isRecipientScreenNameValid)
{
var recipient = A.Fake<IUserDTO>();
var recipientId = TestHelper.GenerateRandomLong();
var recipientScreenName = TestHelper.GenerateString();
parameters.CallsTo(x => x.Recipient).Returns(recipient);
parameters.CallsTo(x => x.RecipientId).Returns(recipientId);
parameters.CallsTo(x => x.RecipientScreenName).Returns(recipientScreenName);
_fakeUserQueryValidator.CallsTo(x => x.CanUserBeIdentified(recipient)).Returns(isRecipientValid);
_fakeUserQueryValidator.CallsTo(x => x.IsUserIdValid(recipientId)).Returns(isRecipientIdValid);
_fakeUserQueryValidator.CallsTo(x => x.IsScreenNameValid(recipientScreenName)).Returns(isRecipientScreenNameValid);
}
// Publish Message
public static async Task<IMessage> PublishMessage(IPublishMessageParameters parameters)
{
return await Sync.ExecuteTaskAsync(() => Message.PublishMessage(parameters));
}
/// <summary>
/// Publish a message
/// </summary>
public static IMessage PublishMessage(IPublishMessageParameters parameters)
{
return MessageController.PublishMessage(parameters);
}
public Task <ITwitterResult <ICreateMessageDTO> > PublishMessageAsync(IPublishMessageParameters parameters, ITwitterRequest request)
{
return(_messageQueryExecutor.PublishMessageAsync(parameters, request));
}
public Task <IMessage> PublishMessage(IPublishMessageParameters publishMessageParameters)
{
return(Client.Messages.PublishMessage(publishMessageParameters));
}
public IMessage PublishMessage(IPublishMessageParameters publishMessageParameters)
{
return(ExecuteAuthenticatedUserOperation(() => _messageController.PublishMessage(publishMessageParameters)));
}
// Publish Message
public string GetPublishMessageQuery(IPublishMessageParameters parameters)
{
var messageText = parameters.Text;
var recipient = parameters.Recipient;
if (!_messageQueryValidator.IsMessageTextValid(messageText) || !_userQueryValidator.CanUserBeIdentified(recipient))
{
return null;
}
var identifierParameter = _userQueryParameterGenerator.GenerateIdOrScreenNameParameter(recipient);
var query = GetPublishMessageFormattedQuery(messageText, identifierParameter);
query += _queryParameterGenerator.GenerateAdditionalRequestParameters(parameters.FormattedCustomQueryParameters);
return query;
}
public async Task <IMessage> PublishMessage(IPublishMessageParameters parameters)
{
var twitterResult = await _messageRequester.PublishMessage(parameters).ConfigureAwait(false);
return(_client.Factories.CreateMessage(twitterResult?.DataTransferObject));
}
// Publish
public async Task <IMessage> PublishMessageAsync(IPublishMessageParameters publishMessageParameters)
{
return(await ExecuteAuthenticatedUserOperation(() => _taskFactory.ExecuteTaskAsync(() => PublishMessage(publishMessageParameters))));
}
public void Validate(IPublishMessageParameters parameters)
{
_messagesClientRequiredParametersValidator.Validate(parameters);
if (parameters.Text.UTF32Length() > Limits.MESSAGE_MAX_SIZE)
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.Text)}",
Limits.MESSAGE_MAX_SIZE,
nameof(Limits.MESSAGE_MAX_SIZE),
"characters");
}
if (parameters.QuickReplyOptions != null && parameters.QuickReplyOptions.Length > 0)
{
if (parameters.QuickReplyOptions.Length > Limits.MESSAGE_QUICK_REPLY_MAX_OPTIONS)
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.QuickReplyOptions)}",
Limits.MESSAGE_QUICK_REPLY_MAX_OPTIONS,
nameof(Limits.MESSAGE_QUICK_REPLY_MAX_OPTIONS),
"options");
}
// If one option has a description, then they all must
// https://developer.twitter.com/en/docs/direct-messages/quick-replies/api-reference/options
var numberOfOptionsWithDescription = parameters.QuickReplyOptions.Count(x => !string.IsNullOrEmpty(x.Description));
if (numberOfOptionsWithDescription > 0 && numberOfOptionsWithDescription != parameters.QuickReplyOptions.Length)
{
throw new ArgumentException("If one Quick Reply Option has a description, then they all must", $"{nameof(parameters)}.{nameof(parameters.QuickReplyOptions)}");
}
if (numberOfOptionsWithDescription > 0 && parameters.QuickReplyOptions.Any(x => x.Description.UTF32Length() > Limits.MESSAGE_QUICK_REPLY_DESCRIPTION_MAX_LENGTH))
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.QuickReplyOptions)}.{nameof(QuickReplyOption.Description)}",
Limits.MESSAGE_QUICK_REPLY_DESCRIPTION_MAX_LENGTH,
nameof(Limits.MESSAGE_QUICK_REPLY_DESCRIPTION_MAX_LENGTH),
"characters per quick option description");
}
if (parameters.QuickReplyOptions.Any(x => string.IsNullOrEmpty(x.Label)))
{
throw new ArgumentException("Quick Reply Option Label is a required field",
$"{nameof(parameters)}{nameof(parameters.QuickReplyOptions)}.{nameof(QuickReplyOption.Label)}");
}
if (parameters.QuickReplyOptions.Any(x => x.Label.UTF32Length() > Limits.MESSAGE_QUICK_REPLY_LABEL_MAX_LENGTH))
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.QuickReplyOptions)}.{nameof(QuickReplyOption.Label)}",
Limits.MESSAGE_QUICK_REPLY_LABEL_MAX_LENGTH,
nameof(Limits.MESSAGE_QUICK_REPLY_LABEL_MAX_LENGTH),
"characters per quick option label");
}
if (parameters.QuickReplyOptions.Any(x => x.Metadata.UTF32Length() > Limits.MESSAGE_QUICK_REPLY_METADATA_MAX_LENGTH))
{
throw new TwitterArgumentLimitException($"{nameof(parameters)}.{nameof(parameters.QuickReplyOptions)}",
Limits.MESSAGE_QUICK_REPLY_METADATA_MAX_LENGTH,
nameof(Limits.MESSAGE_QUICK_REPLY_METADATA_MAX_LENGTH),
"characters per quick option metadata ");
}
}
}
public void Validate(IPublishMessageParameters parameters)
{
_messagesClientParametersValidator.Validate(parameters);
}
// Publish Message
public IMessageDTO PublishMessage(IPublishMessageParameters parameters)
{
string query = _messageQueryGenerator.GetPublishMessageQuery(parameters);
return _twitterAccessor.ExecutePOSTQuery<IMessageDTO>(query);
}
