/// <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, "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 HttpStringContent(dataString.ToString().TrimEnd('&'), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/x-www-form-urlencoded");
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var filter = new PostMessageFilter(this, cleanPostData, url, baseFilter, CancellationToken);
using (var client = new HttpClient(filter))
{
HttpResponseMessage msg = await client.PostAsync(new Uri(url), content);
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 HttpMultipartFormDataContent();
var byteArrayContent = new HttpBufferContent(data.AsBuffer());
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 HttpStringContent(pair.Value), pair.Key);
}
}
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var handler = new PostMessageFilter(this, new Dictionary <string, string>(), url, baseFilter, cancelToken);
var client = new HttpClient(handler);
HttpResponseMessage msg = await client.PostAsync(new Uri(url), multiPartContent);
return(await HandleResponseAsync(msg));
}
///// <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, "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 HttpStringContent(dataString.ToString().TrimEnd('&'), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/x-www-form-urlencoded");
// var baseFilter = new HttpBaseProtocolFilter
// {
// AutomaticDecompression = Authorizer.SupportsCompression,
// ProxyCredential = Authorizer.ProxyCredential,
// UseProxy = Authorizer.UseProxy
// };
// var filter = new PostMessageFilter(this, cleanPostData, url, baseFilter, CancellationToken);
// using (var client = new HttpClient(filter))
// {
// HttpResponseMessage msg = await client.PostAsync(new Uri(url), content);
// return await HandleResponseAsync(msg);
// }
//}
/// <summary>
/// Performs HTTP POST, with JSON payload, to Twitter.
/// </summary>
/// <param name="method">Delete, 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 HttpStringContent(postJson, Windows.Storage.Streams.UnicodeEncoding.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 baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var filter = new PostMessageFilter(this, cleanPostData, url, baseFilter, CancellationToken);
using (var client = new HttpClient(filter))
{
HttpResponseMessage msg;
if (method == HttpMethod.Post.ToString())
{
msg = await client.PostAsync(new Uri(url), content);
}
else if (method == HttpMethod.Delete.ToString())
{
msg = await client.DeleteAsync(new Uri(url));
}
else
{
msg = await client.PutAsync(new Uri(url), content);
}
return(await HandleResponseAsync(msg));
}
}
async Task <ulong> InitAsync(string url, byte[] data, IDictionary <string, string> postData, string name, string fileName, string contentType, string mediaCategory, bool shared, CancellationToken cancelToken)
{
var multiPartContent = new HttpMultipartFormDataContent();
multiPartContent.Add(new HttpStringContent("INIT"), "command");
multiPartContent.Add(new HttpStringContent(contentType), "media_type");
if (!string.IsNullOrWhiteSpace(mediaCategory))
{
multiPartContent.Add(new HttpStringContent(mediaCategory), "media_category");
}
if (shared)
{
multiPartContent.Add(new HttpStringContent("true"), "shared");
}
multiPartContent.Add(new HttpStringContent(data.Length.ToString()), "total_bytes");
foreach (var pair in postData)
{
if (pair.Value != null)
{
multiPartContent.Add(new HttpStringContent(pair.Value), pair.Key);
}
}
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var filter = new PostMessageFilter(this, new Dictionary <string, string>(), url, baseFilter, CancellationToken);
using (var client = new HttpClient(filter))
{
HttpResponseMessage msg = await client.PostAsync(new Uri(url), multiPartContent);
string response = await HandleResponseAsync(msg);
var media = JsonMapper.ToObject(response);
var mediaID = media.GetValue <ulong>("media_id");
return(mediaID);
}
}
async Task AppendChunksAsync(string url, ulong mediaID, byte[] data, string name, string fileName, string contentType, CancellationToken cancelToken)
{
const int ChunkSize = 500000;
for (
int segmentIndex = 0, skip = 0;
skip < data.Length;
segmentIndex++, skip = segmentIndex * ChunkSize)
{
int take = Math.Min(data.Length - skip, ChunkSize);
byte[] chunk = data.Skip(skip).Take(ChunkSize).ToArray();
var multiPartContent = new HttpMultipartFormDataContent();
var byteArrayContent = new HttpBufferContent(chunk.AsBuffer());
byteArrayContent.Headers.Add("Content-Type", contentType);
multiPartContent.Add(byteArrayContent, name, fileName);
multiPartContent.Add(new HttpStringContent("APPEND"), "command");
multiPartContent.Add(new HttpStringContent(mediaID.ToString()), "media_id");
multiPartContent.Add(new HttpStringContent(segmentIndex.ToString()), "segment_index");
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var filter = new PostMessageFilter(this, new Dictionary <string, string>(), url, baseFilter, CancellationToken);
using (var client = new HttpClient(filter))
{
HttpResponseMessage msg = await client.PostAsync(new Uri(url), multiPartContent);
await HandleResponseAsync(msg);
}
}
}
async Task <string> FinalizeAsync(string url, ulong mediaID, CancellationToken cancelToken)
{
var multiPartContent = new HttpMultipartFormDataContent();
multiPartContent.Add(new HttpStringContent("FINALIZE"), "command");
multiPartContent.Add(new HttpStringContent(mediaID.ToString()), "media_id");
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var filter = new PostMessageFilter(this, new Dictionary <string, string>(), url, baseFilter, CancellationToken);
using (var client = new HttpClient(filter))
{
HttpResponseMessage msg = await client.PostAsync(new Uri(url), multiPartContent);
return(await HandleResponseAsync(msg));
}
}
