private async Task StartReadingFeed()
{
try
{
var tokens = await TwitterRequest.GetAccessToken(_twitterSettingsConfigElement.ConsumerKey, _twitterSettingsConfigElement.ConsumerSecret, Tokens.OAuthToken, Tokens.OAuthSecret, Pin);
Pin = string.Empty;
if (tokens == null)
{
return;
}
if (!string.IsNullOrEmpty(tokens.UserId))
{
IsFeedReadingRunning = true;
SendSnackbarMessage(new SnackbarMessage("Loading of Twitter messages started."));
await _twitterReader.StartAsync(tokens.OAuthToken, tokens.OAuthSecret);
}
else
{
SendSnackbarMessage(new SnackbarMessage("You are not propertly authenticated with your Twitter account.", "DISMISS"));
}
}
catch (WebException ex) when(ex.Message.Contains("401"))
{
SendSnackbarMessage(new SnackbarMessage("Got an 401 unauthorized error. Are you properly authenticated and did you use a new PIN?", "DISMISS"));
}
catch (Exception)
{
SendSnackbarMessage(new SnackbarMessage("An error occured. Are you using a correct PIN?", "DISMISS"));
}
}
//각종 API요청용 함수
public void RequestTwitter(BasePacket parameter)
{
if (parameter == null)
{
return;
}
HttpWebRequest req;
if (parameter.method == "POST")
{
req = (HttpWebRequest)WebRequest.Create(parameter.url);
}
else//GET일 경우
{
req = (HttpWebRequest)WebRequest.Create(parameter.MethodGetUrl());
}
req.ContentType = "application/x-www-form-urlencoded;encoding=utf-8";
req.Method = parameter.method;
req.Headers.Add("Authorization", OAuth.GetInstence().GetHeader(parameter));
try
{
if (parameter.dicParams.Count > 0 && parameter.method == "POST")//POST일 때에만 Stream사용
{
TwitterRequest twitterRequest = new TwitterRequest(req, parameter);
req.BeginGetRequestStream(new AsyncCallback(AsyncRequest), twitterRequest);
}
else
{
TwitterRequest twitterRequest = new TwitterRequest(req, parameter);
req.BeginGetResponse(new AsyncCallback(AsyncResponse), twitterRequest);
}
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return;
}
StreamReader srReadData = new StreamReader(stream, Encoding.Default);
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
catch (TimeoutException time)
{
//DalsaeInstence.ResponseTimeoutException(parameter);
}
catch (Exception e)
{
}
}
/// <summary>
/// Destroys the status specified by the required ID parameter. The authenticating user must be the author of the specified status.
/// </summary>
/// <param name="ID">Required. The ID of the status to destroy.</param>
public void Destroy(int ID)
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.UserName = userName;
Data.Password = password;
Data.ActionUri = new Uri(
string.Format(Twitter.Urls.DestroyStatusUrl, ID));
Request.PerformWebRequest(Data);
}
private async void GetPin()
{
try
{
Tokens = await TwitterRequest.GetRequestToken(_twitterSettingsConfigElement.ConsumerKey, _twitterSettingsConfigElement.ConsumerSecret);
Process.Start(new ProcessStartInfo(TwitterRequest.GetRequestUrl(Tokens)));
}
catch (WebException ex) when(ex.Message.Contains("401"))
{
SendSnackbarMessage(new SnackbarMessage("Got an 401 unauthorized error. Did you set up the Twitter consumer key and consumer secret correctly?", "DISMISS"));
}
}
/// <summary>
/// Returns the authenticating user's followers, each with current status.
/// </summary>
/// <param name="Parameters">Optional. Accepts ID and Page parameters.</param>
/// <returns></returns>
public TwitterUserCollection Followers(TwitterParameters Parameters)
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.UserName = userName;
Data.Password = password;
string actionUri = (Parameters == null ? Twitter.Urls.FollowersUrl : Parameters.BuildActionUri(Twitter.Urls.FollowersUrl));
Data.ActionUri = new Uri(actionUri);
Data = Request.PerformWebRequest(Data);
return Data.Users;
}
/// <summary>
/// Gets an user profile information.
/// </summary>
/// <param name="request">Request message.</param>
/// <returns>User profile.</returns>
public TwitterProfile GetProfile(TwitterRequest request)
{
// Pass your credentials to the service
string consumerKey = _settings.TwitterConsumerKey;
string consumerSecret = _settings.TwitterConsumerSecret;
// Authorize
var service = new TwitterService(consumerKey, consumerSecret);
service.AuthenticateWith(request.Token, request.TokenSecret);
// Get user info
TwitterUser user = service.GetUserProfile(new GetUserProfileOptions());
if (user != null)
{
return(new TwitterProfile
{
Id = user.Id,
ImageUrl = user.ProfileImageUrl,
Name = user.Name,
ScreenName = user.ScreenName
});
}
// Check response status code
switch (service.Response.StatusCode)
{
case HttpStatusCode.Unauthorized:
case HttpStatusCode.BadRequest:
// Invalid credentials or request data
throw new BadRequestException(service.Response.Response);
case (HttpStatusCode)429:
throw new TooManyRequestsException(service.Response.Response);
}
// Twitter internal errors
if ((int)service.Response.StatusCode >= 500)
{
throw new BadGatewayException(service.Response.Response);
}
string message = string.Format("Unable to receive twitter profile. Status code {0}: {1}", service.Response.StatusCode, service.Response);
throw new InternalServerErrorException(message);
}
private void AsyncResponse(IAsyncResult ar)
{
TwitterRequest req = (TwitterRequest)ar.AsyncState;
//HttpWebRequest request = (HttpWebRequest)ar.AsyncState;
try
{
HttpWebResponse response = (HttpWebResponse)req.request.EndGetResponse(ar);
Stream stream = response.GetResponseStream();
StreamReader streamRead = new StreamReader(stream);
string responseString = streamRead.ReadToEnd();
stream.Close();
streamRead.Close();
response.Close();
//DalsaeInstence.ResponseJson(responseString, req.parameter.eresponse, req.parameter.isMore);
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return;
}
StreamReader srReadData = new StreamReader(stream, Encoding.Default);
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
catch (Exception e)
{
}
}
private void AsyncRequest(IAsyncResult ar)
{
TwitterRequest req = (TwitterRequest)ar.AsyncState;
try
{
using (Stream stream = req.request.EndGetRequestStream(ar))
{
StringBuilder sb = new StringBuilder();
foreach (string item in req.parameter.dicParams.Keys)
{
if (req.parameter.dicParams[item] != "")
{
sb.Append(item);
sb.Append("=");
OAuth.GetInstence().CalcParamUri(sb, req.parameter.dicParams[item]);
sb.Append("&");
//sb.Append(Uri.EscapeDataString(req.parameter.dicParams[item]));
}
}
string sendData = sb.ToString();
byte[] bytes = Encoding.UTF8.GetBytes(sendData);
// Write to the request stream.
stream.Write(bytes, 0, sendData.Length);
//stream.Close();
}
}
catch (WebException we)
{
}
catch (TimeoutException time)
{
//DalsaeInstence.ResponseTimeoutException(req.parameter);
}
req.request.BeginGetResponse(new AsyncCallback(AsyncResponse), req);
}
public void ProcessRequest(TwitterRequest request)
{
lock (requestLock)
{
try
{
log.Info("Received Request: " + request);
if (request is GetFriendsRequest)
{
ProcessGetFriendsRequest(request as GetFriendsRequest);
}
else if (request is GetFollowersRequest)
{
ProcessGetFollowersRequest(request as GetFollowersRequest);
}
else if (request is UserInfoRequest)
{
ProcessUserInfoRequest(request as UserInfoRequest);
}
else if (request is TestRequest)
{
// nothing to do
}
else
{
throw new ArgumentOutOfRangeException("request", "Unknown or unhandled request type: " + request.GetType().Name);
}
}
catch(Exception ex)
{
responseQueue.Send(new ErrorResponse(request, "Exception: " + ex.GetType().Name, ex));
}
requestQueue.BeginReceive(); // next..
}
}
//이미지 업로드 시 요청하는 함수, 동기 전송
//obj: 이미지 bytes를 담고있는 파라메터
public string SendMultimedia2(PacketMediaUpload parameter)
{
string ret = string.Empty;
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(parameter.url);
TwitterRequest request = new TwitterRequest(req, parameter);
var boundary = Guid.NewGuid().ToString().Replace("-", string.Empty);
req.ContentType = "multipart/form-data;encoding=utf-8;boundary=" + boundary;
req.Method = parameter.method;
req.Headers.Add("Authorization", OAuth.GetInstence().GetHeader(parameter));
boundary = "--" + boundary;
//-----------------------------------------------------------------------------------
//------------------------------------Send------------------------------------------
//-----------------------------------------------------------------------------------
try//send!
{
using (Stream stream = req.GetRequestStream())
using (var writer = new StreamWriter(stream, Encoding.UTF8))
{
writer.NewLine = "\r\n";
writer.WriteLine(boundary);
writer.WriteLine("Content-Type: application/octet-stream");
writer.WriteLine($"Content-Disposition: form-data; name=\"media\"; filename=\"img{parameter.extension}\"");
writer.WriteLine();
writer.Flush();
parameter.mediaStream.Position = 0;
parameter.mediaStream.CopyTo(stream);
writer.WriteLine();
writer.WriteLine(boundary + "--");
writer.Flush();
}
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return(string.Empty);
}
using (StreamReader srReadData = new StreamReader(stream, Encoding.Default))
{
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
}
//-----------------------------------------------------------------------------------
//-------------------------------Response------------------------------------------
//-----------------------------------------------------------------------------------
try//Response!!!
{
using (WebResponse response = req.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
using (StreamReader streamRead = new StreamReader(stream))
ret = streamRead.ReadToEnd();
}
}
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return(string.Empty);
}
using (StreamReader srReadData = new StreamReader(stream, Encoding.Default))
{
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
}
return(ret);
}
/// <summary>
/// Returns the 20 most recent statuses posted by the authenticating user and that user's friends. This is the equivalent of /home on the Web.
/// </summary>
/// <param name="Parameters">Accepts Since, SinceID, Count, and Page parameters.</param>
/// <returns></returns>
public TwitterStatusCollection FriendsTimeline(TwitterParameters Parameters)
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.UserName = userName;
Data.Password = password;
string actionUri = (Parameters == null ? Twitter.Urls.FriendsTimelineUrl : Parameters.BuildActionUri(Twitter.Urls.FriendsTimelineUrl));
Data.ActionUri = new Uri(actionUri);
Data = Request.PerformWebRequest(Data);
return Data.Statuses;
}
public ErrorResponse(TwitterRequest request, string message, Exception exception)
{
Request = request;
Message = message;
Exception = exception;
}
/// <summary>
/// Updates the authenticating user's status.
/// </summary>
/// <param name="Status">Required. The text of your status update.</param>
/// <param name="InReplyToStatusID">Optional. The ID of an existing status that the status to be posted is in reply to.</param>
/// <returns></returns>
public TwitterStatus Update(string Status, long? InReplyToStatusID)
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.UserName = userName;
Data.Password = password;
Data.Source = source;
Data.ActionUri = new Uri(
string.Format(Twitter.Urls.UpdateUrl, HttpUtility.UrlEncode(Status), source,
InReplyToStatusID.HasValue ? InReplyToStatusID.Value.ToString () : ""));
Data = Request.PerformWebRequest(Data, "POST");
return Data.Statuses[0];
}
public ErrorResponse(TwitterRequest request, string message)
: this(request, message, null)
{
}
public void SendMultimedia(PacketMediaUpload packet, ClientSendTweet tweet, Action <ClientSendTweet, ClientMultimedia> callback)
{
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(packet.url);
TwitterRequest request = new TwitterRequest(req, packet);
var boundary = Guid.NewGuid().ToString().Replace("-", string.Empty);
req.ContentType = "multipart/form-data;encoding=utf-8;boundary=" + boundary;
req.Method = packet.method;
req.Headers.Add("Authorization", OAuth.GetInstence().GetHeader(packet));
boundary = "--" + boundary;
try //send!
{
using (Stream stream = req.GetRequestStream())
using (var writer = new StreamWriter(stream, Encoding.UTF8))
{
writer.NewLine = "\r\n";
writer.WriteLine(boundary);
writer.WriteLine("Content-Type: application/octet-stream");
writer.WriteLine($"Content-Disposition: form-data; name=\"media\"; filename=\"img{packet.extension}\"");
writer.WriteLine();
writer.Flush();
packet.mediaStream.Position = 0;
packet.mediaStream.CopyTo(stream);
writer.WriteLine();
writer.WriteLine(boundary + "--");
writer.Flush();
}
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return;
}
using (StreamReader srReadData = new StreamReader(stream, Encoding.Default))
{
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { packet, log });
}
}
}
}
catch (Exception e)
{
packet.Dispose();
App.SendException(e);
return;
}
try //Response!!!
{
using (WebResponse response = req.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
if (stream == null)
{
return;
}
using (StreamReader streamRead = new StreamReader(stream))
{
string json = streamRead.ReadToEnd();
ClientMultimedia media = JsonConvert.DeserializeObject <ClientMultimedia>(json);
callback?.Invoke(tweet, media);
}
}
}
}
catch (WebException e)
{
using (Stream stream = e.Response?.GetResponseStream())
{
if (stream == null)
{
return;
}
using (StreamReader srReadData = new StreamReader(stream, Encoding.Default))
{
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
}
catch (Exception e)
{
App.SendException(e);
}
finally
{
packet.Dispose();
}
}
public static bool VerifyCredentials(string username, string password)
{
if (string.IsNullOrEmpty (username))
Console.Error.WriteLine ("username empty");
if (string.IsNullOrEmpty (password))
Console.Error.WriteLine ("password empty");
TwitterRequest request = new TwitterRequest();
TwitterRequestData data = new TwitterRequestData();
data.UserName = username;
data.Password = password;
data.ActionUri = new Uri (Urls.VerifyCredentialsUrl);
try
{
data = request.PerformWebRequest(data, "GET");
if (data == null) {
Console.Error.WriteLine ("DATA IS NULL ABORT");
return false;
}
if (data.Users[0].ScreenName == username)
{
return true;
}
}
catch { } // ignore exeptions - authentication failed
return false;
}
public RequestReceivedEventArgs(TwitterRequest request)
{
TwitterRequest = request;
}
//public void DisconnectingUserStreaming()
//{
// userStream.Disconnecting();
// userStream = new UserStream();
// DalsaeInstence.ConnectedStreaming(false);
//}
//public bool isConnectedUserStreaming() { return userStream.isConnectedStreaming; }
//public void ConnectUserStream(object obj)
//{
// if (obj == null) return;
// userStream.ConnectStreaming(obj as BasePacket);
//}
public void SyncRequest <TRes>(BasePacket packet, UIProperty property, Action <TRes, UIProperty> callback)
{
HttpWebRequest req;
if (packet.method == "POST")
{
req = (HttpWebRequest)WebRequest.Create(packet.url);
}
else //GET일경우
{
req = (HttpWebRequest)WebRequest.Create(packet.MethodGetUrl());
}
TwitterRequest request = new TwitterRequest(req, packet);
req.ContentType = "application/x-www-form-urlencoded;encoding=utf-8";
req.Method = packet.method;
req.Headers.Add("Authorization", OAuth.GetInstence().GetHeader(packet));
if (packet.dicParams.Count > 0 && packet.method == "POST") //POST일 때에만 Stream사용
{
//-----------------------------------------------------------------------------------
//------------------------------------Send------------------------------------------
//-----------------------------------------------------------------------------------
try //send!
{
Send(packet, req);
}
catch (WebException e)
{
using (Stream stream2 = e.Response?.GetResponseStream())
{
StreamReader srReadData = new StreamReader(stream2, Encoding.Default);
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
catch (Exception e)
{
OnResponseError?.Invoke(packet, null);
}
}
try //Response!!!
{
string json = Recv(packet, req);
TRes ret = default(TRes);
if (json?.Length > 0)
{
ret = JsonConvert.DeserializeObject <TRes>(json);
}
if (callback != null)
{
Application.Current.Dispatcher.BeginInvoke(callback, new object[] { ret, property });
}
}
catch (WebException e)
{
if (e.Message.IndexOf("408") > -1) //timeout시 재 전송
{
Manager.APICallAgent.apiInstence.RequestSingleTweetPacket <TRes>(packet, property, callback);
}
else if (e.Response == null)
{
App.SendException(e);
}
else
{
//ClientAPIError error = null;
using (Stream stream = e.Response?.GetResponseStream())
using (StreamReader srReadData = new StreamReader(stream, Encoding.Default))
{
string log = srReadData.ReadToEnd();
if (string.IsNullOrEmpty(log) == false)
{
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { packet, log });
}
}
}
}
}
catch (Exception e)
{
OnResponseError?.Invoke(packet, null);
App.SendException(e);
}
}
public void Send(TwitterRequest request)
{
SendMessage(request);
}
public string SyncRequest(BasePacket parameter)
{
string ret = string.Empty;
HttpWebRequest req;
if (parameter.method == "POST")
{
req = (HttpWebRequest)WebRequest.Create(parameter.url);
}
else//GET일경우
{
req = (HttpWebRequest)WebRequest.Create(parameter.MethodGetUrl());
}
TwitterRequest request = new TwitterRequest(req, parameter);
req.ContentType = "application/x-www-form-urlencoded;encoding=utf-8";
req.Method = parameter.method;
req.Headers.Add("Authorization", OAuth.GetInstence().GetHeader(parameter));
if (parameter.dicParams.Count > 0 && parameter.method == "POST")//POST일 때에만 Stream사용
{
//-----------------------------------------------------------------------------------
//------------------------------------Send------------------------------------------
//-----------------------------------------------------------------------------------
try//send!
{
Stream stream = req.GetRequestStream();
StringBuilder sb = new StringBuilder();
foreach (string item in parameter.dicParams.Keys)
{
if (parameter.dicParams[item] != "")
{
sb.Append(item);
sb.Append("=");
OAuth.GetInstence().CalcParamUri(sb, parameter.dicParams[item]);
sb.Append("&");
}
}
string sendData = sb.ToString();
byte[] bytes = Encoding.UTF8.GetBytes(sendData);
stream.Write(bytes, 0, sendData.Length);
stream.Close();
}
catch (WebException e)
{
using (Stream stream2 = e.Response?.GetResponseStream())
{
if (stream2 == null)
{
return(string.Empty);
}
StreamReader srReadData = new StreamReader(stream2, Encoding.Default);
string log = srReadData.ReadToEnd();
if (OnResponseError != null)
{
Application.Current.Dispatcher.BeginInvoke(OnResponseError, new object[] { log });
}
}
}
catch (Exception e)
{
App.SendException(e);
}
}
//-----------------------------------------------------------------------------------
//-------------------------------Response------------------------------------------
//-----------------------------------------------------------------------------------
try//Response!!!
{
using (WebResponse response = req.GetResponse())
using (Stream stream = response.GetResponseStream())
using (StreamReader streamRead = new StreamReader(stream))
ret = streamRead.ReadToEnd();
}
catch (WebException e)
{
//using (Stream stream = e.Response.GetResponseStream())
//{
// StreamReader srReadData = new StreamReader(stream, Encoding.Default);
// string log = srReadData.ReadToEnd();
// DalsaeInstence.ResponseError(log);
//}
}
catch (Exception e)
{
App.SendException(e);
}
return(ret);
}
public async Task <IChunkUploadResult> UploadBinary(IUploadParameters uploadQueryParameters, ITwitterRequest baseRequest)
{
var binary = uploadQueryParameters.Binary;
var uploader = CreateChunkedUploader();
var initParameters = new ChunkUploadInitParameters
{
TotalBinaryLength = binary.Length,
MediaType = uploadQueryParameters.QueryMediaType,
MediaCategory = uploadQueryParameters.QueryMediaCategory,
AdditionalOwnerIds = uploadQueryParameters.AdditionalOwnerIds,
CustomRequestParameters = uploadQueryParameters.InitCustomRequestParameters,
};
var initRequest = new TwitterRequest(baseRequest);
var initOperationSucceeded = await uploader.Init(initParameters, initRequest).ConfigureAwait(false);
if (!initOperationSucceeded)
{
return(uploader.Result);
}
var binaryChunks = GetBinaryChunks(binary, uploadQueryParameters.MaxChunkSize);
var totalSize = await CalculateSize("media", binary).ConfigureAwait(false);
long uploadedSize = 0;
uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.INITIALIZED, 0, totalSize));
for (var i = 0; i < binaryChunks.Count; ++i)
{
var binaryChunk = binaryChunks[i];
var startUploadedSize = uploadedSize;
var appendParameters = new ChunkUploadAppendParameters(
binaryChunk,
"media", // Must be `media`, if using the real media type as content id, Twitter does not accept when invoking .Finalize().
uploadQueryParameters.Timeout)
{
UploadProgressChanged = (args) =>
{
uploadedSize = startUploadedSize + args.NumberOfBytesUploaded;
uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.PROGRESS_CHANGED, uploadedSize, totalSize));
},
CustomRequestParameters = uploadQueryParameters.AppendCustomRequestParameters
};
var appendRequest = new TwitterRequest(baseRequest);
var appendOperationSucceeded = await uploader.Append(appendParameters, appendRequest).ConfigureAwait(false);
if (!appendOperationSucceeded)
{
uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.FAILED, uploadedSize, totalSize));
return(uploader.Result);
}
}
var finalizeRequest = new TwitterRequest(baseRequest);
var finalizeSucceeded = await uploader.Finalize(uploadQueryParameters.FinalizeCustomRequestParameters, finalizeRequest).ConfigureAwait(false);
if (finalizeSucceeded)
{
var result = uploader.Result;
uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.COMPLETED, uploadedSize, totalSize));
var category = uploadQueryParameters.MediaCategory;
var isAwaitableUpload = category == MediaCategory.Gif || category == MediaCategory.Video;
if (isAwaitableUpload && uploadQueryParameters.WaitForTwitterProcessing)
{
var request = new TwitterRequest(baseRequest);
await _uploadHelper.WaitForMediaProcessingToGetAllMetadata(result.Media, request).ConfigureAwait(false);
}
}
return(uploader.Result);
}
/// <summary>
/// Returns the 20 most recent statuses from non-protected users who have set a custom user icon. Does not require authentication.
/// </summary>
/// <returns></returns>
public TwitterStatusCollection PublicTimeline()
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.ActionUri = new Uri(Twitter.Urls.PublicTimelineUrl);
Data = Request.PerformWebRequest(Data);
return Data.Statuses;
}
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>
/// Returns a single status, specified by the id parameter
/// </summary>
/// <param name="ID">id. Required. The numerical ID of the status you're trying to retrieve.</param>
/// <returns></returns>
public TwitterUser Show(string ID)
{
TwitterRequest Request = new TwitterRequest();
TwitterRequestData Data = new TwitterRequestData();
Data.UserName = userName;
Data.Password = password;
Data.ActionUri = new Uri(
string.Format(Twitter.Urls.ShowStatusUrl, ID));
Data = Request.PerformWebRequest(Data, "GET");
return Data.Users[0];
}
