/// <summary>
/// performs HTTP POST to Twitter
/// </summary>
/// <param name="url">URL of request</param>
/// <param name="postData">parameters to post</param>
/// <param name="getResult">callback for handling async Json response - null if synchronous</param>
/// <returns>Json Response from Twitter - empty string if async</returns>
public async Task <string> PostToTwitterAsync <T>(string url, IDictionary <string, string> postData, CancellationToken cancelToken)
{
WriteLog(url, nameof(PostToTwitterAsync));
var cleanPostData = new Dictionary <string, string>();
var dataString = new StringBuilder();
foreach (var pair in postData)
{
if (pair.Value != null)
{
dataString.AppendFormat("{0}={1}&", pair.Key, Url.PercentEncode(pair.Value));
cleanPostData.Add(pair.Key, pair.Value);
}
}
var content = new StringContent(dataString.ToString().TrimEnd('&'), Encoding.UTF8, "application/x-www-form-urlencoded");
var handler = new PostMessageHandler(this, cleanPostData, url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg = await client.PostAsync(url, content).ConfigureAwait(false);
return(await HandleResponseAsync(msg));
}
}
/// <summary>
/// Performs HTTP POST media byte array upload to Twitter.
/// </summary>
/// <param name="url">Url to upload to.</param>
/// <param name="postData">Request parameters.</param>
/// <param name="data">Image to upload.</param>
/// <param name="name">Image parameter name.</param>
/// <param name="fileName">Image file name.</param>
/// <param name="contentType">Type of image: must be one of jpg, gif, or png.</param>
/// <param name="reqProc">Request processor for handling results.</param>
/// <returns>JSON response From Twitter.</returns>
public async Task <string> PostImageAsync(string url, IDictionary <string, string> postData, byte[] data, string name, string fileName, string contentType, CancellationToken cancelToken)
{
WriteLog(url, nameof(PostImageAsync));
var multiPartContent = new MultipartFormDataContent();
var byteArrayContent = new ByteArrayContent(data);
byteArrayContent.Headers.Add("Content-Type", contentType);
multiPartContent.Add(byteArrayContent, name, fileName);
var cleanPostData = new Dictionary <string, string>();
foreach (var pair in postData)
{
if (pair.Value != null)
{
cleanPostData.Add(pair.Key, pair.Value);
multiPartContent.Add(new StringContent(pair.Value), pair.Key);
}
}
var handler = new PostMessageHandler(this, new Dictionary <string, string>(), url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg = await client.PostAsync(url, multiPartContent, cancelToken).ConfigureAwait(false);
return(await HandleResponseAsync(msg).ConfigureAwait(false));
}
}
async Task AppendChunksAsync(string url, ulong mediaID, byte[] data, string name, string fileName, string contentType, CancellationToken cancelToken)
{
const int ChunkSize = 5000000;
for (
int segmentIndex = 0, skip = 0;
skip < data.Length;
segmentIndex++, skip = segmentIndex * ChunkSize)
{
byte[] chunk = data.Skip(skip).Take(ChunkSize).ToArray();
var multiPartContent = new MultipartFormDataContent();
var byteArrayContent = new ByteArrayContent(chunk);
byteArrayContent.Headers.Add("Content-Type", contentType);
multiPartContent.Add(byteArrayContent, name, fileName);
multiPartContent.Add(new StringContent("APPEND"), "command");
multiPartContent.Add(new StringContent(mediaID.ToString()), "media_id");
multiPartContent.Add(new StringContent(segmentIndex.ToString()), "segment_index");
var handler = new PostMessageHandler(this, new Dictionary <string, string>(), url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg = await client.PostAsync(url, multiPartContent, cancelToken).ConfigureAwait(false);
await HandleResponseAsync(msg).ConfigureAwait(false);
}
}
}
async Task <ulong> InitAsync(string url, byte[] data, IDictionary <string, string> postData, string name, string fileName, string contentType, CancellationToken cancelToken)
{
var multiPartContent = new MultipartFormDataContent();
multiPartContent.Add(new StringContent("INIT"), "command");
multiPartContent.Add(new StringContent(contentType), "media_type");
multiPartContent.Add(new StringContent(data.Length.ToString()), "total_bytes");
foreach (var pair in postData)
{
if (pair.Value != null)
{
multiPartContent.Add(new StringContent(pair.Value), pair.Key);
}
}
var handler = new PostMessageHandler(this, new Dictionary <string, string>(), url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg = await client.PostAsync(url, multiPartContent, cancelToken).ConfigureAwait(false);
string response = await HandleResponseAsync(msg);
var media = JsonMapper.ToObject(response);
var mediaID = media.GetValue <ulong>("media_id");
return(mediaID);
}
}
/// <summary>
/// Performs HTTP POST, with JSON payload, to Twitter.
/// </summary>
/// <param name="method">Post or Put</param>
/// <param name="url">URL of request.</param>
/// <param name="postData">URL parameters to post.</param>
/// <param name="postObj">Serializable payload object.</param>
/// <param name="getResult">Callback for handling async Json response - null if synchronous.</param>
/// <returns>JSON Response from Twitter - empty string if async.</returns>
public async Task<string> SendJsonToTwitterAsync<T>(string method, string url, IDictionary<string, string> postData, T postObj, CancellationToken cancelToken)
{
WriteLog(url, nameof(PostFormUrlEncodedToTwitterAsync));
var postJson = JsonConvert.SerializeObject(postObj, new DefaultJsonSerializer());
var content = new StringContent(postJson, Encoding.UTF8, "application/json");
var cleanPostData = new Dictionary<string, string>();
foreach (var pair in postData)
if (pair.Value != null)
cleanPostData.Add(pair.Key, pair.Value);
var handler = new PostMessageHandler(this, cleanPostData, url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
HttpResponseMessage msg =
method == HttpMethod.Post.ToString() ?
await client.PostAsync(url, content).ConfigureAwait(false) :
await client.PutAsync(url, content).ConfigureAwait(false);
return await HandleResponseAsync(msg).ConfigureAwait(false);
}
}
async Task<string> FinalizeAsync(string url, ulong mediaID, CancellationToken cancelToken)
{
var multiPartContent = new MultipartFormDataContent();
multiPartContent.Add(new StringContent("FINALIZE"), "command");
multiPartContent.Add(new StringContent(mediaID.ToString()), "media_id");
var handler = new PostMessageHandler(this, new Dictionary<string, string>(), url);
using (var client = new HttpClient(handler))
{
if (Timeout != 0)
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
HttpResponseMessage msg = await client.PostAsync(url, multiPartContent, cancelToken).ConfigureAwait(false);
return await HandleResponseAsync(msg).ConfigureAwait(false);
}
}
async Task <ulong> InitAsync(string url, byte[] data, IDictionary <string, string> postData, string contentType, string mediaCategory, bool shared, CancellationToken cancelToken)
{
var multiPartContent = new MultipartFormDataContent
{
{ new StringContent("INIT"), "command" },
{ new StringContent(contentType), "media_type" }
};
if (!string.IsNullOrWhiteSpace(mediaCategory))
{
multiPartContent.Add(new StringContent(mediaCategory), "media_category");
}
if (shared)
{
multiPartContent.Add(new StringContent("true"), "shared");
}
multiPartContent.Add(new StringContent(data.Length.ToString()), "total_bytes");
foreach (var pair in postData)
{
if (pair.Value != null)
{
multiPartContent.Add(new StringContent(pair.Value), pair.Key);
}
}
var handler = new PostMessageHandler(this, new Dictionary <string, string>(), url);
var client = new HttpClient(handler);
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg = await client.PostAsync(url, multiPartContent, cancelToken).ConfigureAwait(false);
string response = await HandleResponseAsync(msg).ConfigureAwait(false);
var media = JsonDocument.Parse(response);
var mediaID = media.RootElement.GetProperty("media_id").GetUInt64();
return(mediaID);
}
public async Task <string> SendJsonToTwitterAsync <T>(string method, string url, IDictionary <string, string> postData, T postObj, CancellationToken cancelToken)
{
WriteLog(url, nameof(SendJsonToTwitterAsync));
var postJson = postObj == null ? "" : JsonSerializer.Serialize(postObj);
var content = new StringContent(postJson, Encoding.UTF8, "application/json");
var cleanPostData = new Dictionary <string, string>();
foreach (var pair in postData)
{
if (pair.Value != null)
{
cleanPostData.Add(pair.Key, pair.Value);
}
}
var handler = new PostMessageHandler(this, cleanPostData, url);
var client = new HttpClient(handler);
if (Timeout != 0)
{
client.Timeout = new TimeSpan(0, 0, 0, Timeout);
}
HttpResponseMessage msg;
if (method == HttpMethod.Post.ToString())
{
msg = await client.PostAsync(url, content).ConfigureAwait(false);
}
else if (method == HttpMethod.Delete.ToString())
{
msg = await client.DeleteAsync(url).ConfigureAwait(false);
}
else
{
msg = await client.PutAsync(url, content).ConfigureAwait(false);
}
return(await HandleResponseAsync(msg).ConfigureAwait(false));
}
public void SetUp()
{
bus = new Bus();
postMessageHandler = new PostMessageHandler(bus);
postMessageCommand = new PostMessage(UserName, Message);
}
