Exemplo n.º 1
0
        public static IEnumerable <TwitterStatus> Search(TweetSearchOption option)
        {
            List <TwitterStatus> returns = new List <TwitterStatus>();

            IEnumerable <TwitterStatus> searchResult = TwitterApi.Search(option);

            char[] invalidChara  = Path.GetInvalidFileNameChars();
            string queryFileName = option.Query + "_" + DateTime.Now.ToString("yyMMdd_HHmm") + ".json";

            foreach (char c in invalidChara)
            {
                queryFileName = queryFileName.Replace(c, Strings.StrConv(c.ToString(), VbStrConv.Wide)[0]);
            }

            if (!Directory.Exists("検索結果/"))
            {
                Directory.CreateDirectory("検索結果");
            }

            using (StreamWriter writer = new StreamWriter("検索結果/" + queryFileName))
            {
                writer.WriteLine(JsonConvert.SerializeObject(searchResult, Formatting.Indented));
            }
            returns = returns.Concat(searchResult).ToList();

            return(returns);
        }
        /// <summary>
        /// Use OAuth2 Bearer To do read-only GET query
        /// </summary>
        /// <param name="url">URL to call</param>
        /// <param name="parameters">Params to send</param>
        /// <returns></returns>
        public async Task<HttpResponseMessage> GetAsync(string url, SortedDictionary<string, string> parameters)
        {
            // ensure we have a bearerToken before progressing
            if (clientID != null && clientSecret != null && bearerToken == null)
            {
                await this.StartApplicationOnlyAuth();
            }
            if (bearerToken == null) return null;

            var querystring = parameters.Aggregate("", (current, entry) => current + (entry.Key + "=" + entry.Value + "&"));

            var oauth2 = String.Format("Bearer {0}", bearerToken);
            var fullUrl = url;

            var handler = new HttpClientHandler();
            if (handler.SupportsAutomaticDecompression)
            {
                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
            }
            var client = new HttpClient(handler);
            client.DefaultRequestHeaders.Add("Authorization", oauth2);
            client.DefaultRequestHeaders.Add("User-Agent", TwitterApi.UserAgent());

            if (!string.IsNullOrWhiteSpace(querystring))
                fullUrl += "?" + querystring.TrimLastChar();

            var download = client.GetAsync(fullUrl).ToObservable().Timeout(TimeSpan.FromSeconds(waitTimeoutSeconds));
            return await download;
       }
Exemplo n.º 3
0
        public TwitterService()
        {
            const string consumerKey    = "ZScn2AEIQrfC48Zlw";
            const string consumerSecret = "8gKdPBwUfZCQfUiyeFeEwVBQiV3q50wIOrIjoCxa2Q";

            TwitterApi = new TwitterApi(consumerKey, consumerSecret);
        }
Exemplo n.º 4
0
        private static async Task <string> PostData(string url, string authdata, string content = null)
        {
            try
            {
                var handler = new HttpClientHandler();
                if (handler.SupportsAutomaticDecompression)
                {
                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
                }
                var client  = new HttpClient(handler);
                var request = new HttpRequestMessage(HttpMethod.Post, new Uri(url));
                request.Headers.Add("Accept-Encoding", "identity");
                request.Headers.Add("User-Agent", TwitterApi.UserAgent());
                request.Headers.Add("Authorization", authdata);
                if (content != null)
                {
                    request.Content = new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded");
                }
                var response = await client.SendAsync(request);

                var clientresponse =
                    response.Content.ReadAsStringAsync().ToObservable().Timeout(TimeSpan.FromSeconds(30));
                return(await clientresponse);
            }
            catch (Exception e)
            {
                return(e.Message);
            }
        }
Exemplo n.º 5
0
        protected TwitterCommandBase(TwitterApi twitterApi, string command)
        {
            this._TwitterApi = twitterApi;

            this._CommandBaseUri = TwitterApi.ApiBaseUri + "/" + this._TwitterApi.ApiVersion.ToString("D") +
                                   "/" + command;
        }
Exemplo n.º 6
0
        public LoginProgressForm(TwitterApi login)
        {
            Login = login;
            authorizationUrlString = "https://api.twitter.com/oauth/authorize?oauth_token=" + login.OAuth.User.Token;

            InitializeComponent();
        }
Exemplo n.º 7
0
        /// <summary>
        /// Using client(consumer) id and key, start a 'readonly' Application-auth'd session
        /// </summary>
        /// <remarks>ref: https://dev.twitter.com/docs/api/1.1/post/oauth2/invalidate_token </remarks>
        public static async Task <bool> StopApplicationOnlyAuth(this IApplicationSession appsession)
        {
            if (string.IsNullOrEmpty(appsession.clientID))
            {
                throw new ArgumentException("Twitter Consumer Key is required for Application only Auth");
            }
            if (string.IsNullOrEmpty(appsession.clientSecret))
            {
                throw new ArgumentException("Twitter Consumer Secret is required for Application only Auth");
            }

            // ref: https://dev.twitter.com/docs/auth/application-only-auth
            // and ref: http://tools.ietf.org/html/rfc6749#section-4.4
            // and ref: https://dev.twitter.com/docs/api/1.1/post/oauth2/invalidate_token

            var oAuth2TokenUrlPostRequestRfc6749 = new SortedDictionary <string, string>
            {
                { "access_token", appsession.bearerToken }
            };

            var result = await appsession.PostAsync(TwitterApi.OAuth2TokenRevokeUrl(), oAuth2TokenUrlPostRequestRfc6749, forInitialAuth : true);

            if (!result.IsSuccessStatusCode)
            {
                return(false);
            }
            var content = await result.Content.ReadAsStringAsync();

            var jresponse = JObject.Parse(content);

            appsession.bearerToken = (string)jresponse["access_token"];
            appsession.IsActive    = false;
            return(true);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Removes the uploaded profile banner for the authenticating user. Returns HTTP 20x upon success.
        /// </summary>
        /// <param name="fileName">file name for upload</param>
        /// <param name="imageContentStream">Stream of image content</param>
        /// <param name="bannerWidth">The width of the preferred section of the image being uploaded in pixels. Use with height, offset_left, and offset_top to select the desired region of the image to use.</param>
        /// <param name="bannerHeight">The height of the preferred section of the image being uploaded in pixels. Use with width, offset_left, and offset_top to select the desired region of the image to use.</param>
        /// <param name="bannerLeftOffset">The number of pixels by which to offset the uploaded image from the left. Use with height, width, and offset_top to select the desired region of the image to use.</param>
        /// <param name="bannerTopOffset">The number of pixels by which to offset the uploaded image from the top. Use with height, width, and offset_left to select the desired region of the image to use.</param>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/post/account/update_profile_banner </remarks>
        public static async Task <TwitterSuccess> ChangeProfileBanner(this IUserSession session, string fileName, Stream imageContentStream, int bannerWidth = 0, int bannerHeight = 0, int bannerLeftOffset = 0, int bannerTopOffset = 0)
        {
            var parameters = new TwitterParametersCollection();

            if (bannerWidth != 0)
            {
                parameters.Add("width", bannerWidth.ToString());
            }

            if (bannerHeight != 0)
            {
                parameters.Add("height", bannerWidth.ToString());
            }

            if (bannerLeftOffset != 0)
            {
                parameters.Add("offset_left", bannerWidth.ToString());
            }

            if (bannerTopOffset != 0)
            {
                parameters.Add("offset_top", bannerWidth.ToString());
            }

            return(await session.PostFileAsync(TwitterApi.Resolve("/1.1/account/update_profile_banner.json"), parameters, fileName, "banner", srImage : imageContentStream)
                   .ContinueWith(c => c.MapToTwitterSuccess()));
        }
Exemplo n.º 9
0
        /// <summary>
        /// Returns the current configuration used by Twitter including twitter.com slugs which are not usernames, maximum photo resolutions, and t.co URL lengths.
        /// </summary>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/rest/reference/get/help/configuration </remarks>
        public async static Task <Configuration> GetConfiguration(this IUserSession session)
        {
            var parameters = new TwitterParametersCollection();

            parameters.Create();
            return(await session.GetAsync(TwitterApi.Resolve("/1.1/help/configuration.json"), parameters).ContinueWith(c => c.MapToSingle <Configuration>()));
        }
Exemplo n.º 10
0
        /// <summary>
        /// Removes the uploaded profile banner for the authenticating user. Returns HTTP 200 upon success.
        /// </summary>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/post/account/remove_profile_banner </remarks>
        public static async Task <TwitterSuccess> DeleteProfileBanner(this IUserSession session)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.PostAsync(TwitterApi.Resolve("/1.1/account/remove_profile_banner.json"), parameters)
                   .ContinueWith(c => c.MapToTwitterSuccess()));
        }
Exemplo n.º 11
0
        /// <summary>
        /// Updates the authenticating user's profile image.
        /// </summary>
        /// <param name="fileName">file name for upload</param>
        /// <param name="imageContent">byte array of image content</param>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/post/account/update_profile_image </remarks>
        public static async Task <User> ChangeAccountProfileImage(this IUserSession session, string fileName, byte[] imageContent)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.PostFileAsync(TwitterApi.Resolve("/1.1/account/update_profile_image.json"), parameters, fileName, "image", imageContent)
                   .ContinueWith(c => c.MapToSingle <User>()));
        }
Exemplo n.º 12
0
        /// <summary>
        /// Returns settings (including current trend, geo and sleep time information) for the authenticating user.
        /// </summary>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/account/settings </remarks>
        public static async Task <AccountSettings> GetAccountSettings(this IUserSession session)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.GetAsync(TwitterApi.Resolve("/1.1/account/settings.json"), parameters)
                   .ContinueWith(c => c.MapToSingle <AccountSettings>()));
        }
Exemplo n.º 13
0
        private static async Task TweetMessage()
        {
            TwitterApi twitter = new TwitterApi(ConsumerKey, ConsumerKeySecret, AccessToken, AccessTokenSecret);

            string[]   txtTweets = File.ReadAllText("Tweets\\SriRamMandir.txt").Split(('\n'));
            int        count     = 0;
            List <int> lst       = new List <int>();

            foreach (string twt in txtTweets)
            {
                string msg = $"{tags} {twt}";
                if (msg.Length > 280)
                {
                    Console.WriteLine("Message {0} is too long.", ++count);
                    lst.Add(count);
                    //Console.WriteLine("{0} is more than 280 chars.", msg);
                    //msg = msg.Substring(279);
                }
                else
                {
                    string response = await twitter.Tweet(msg);

                    Console.WriteLine(response);
                }
            }
            int[] array = lst.ToArray();
        }
Exemplo n.º 14
0
        /// <summary>
        /// Use OAuth1.0a auth to do more intensive POST
        /// </summary>
        /// <param name="url">URL to call</param>
        /// <param name="parameters">Params to send</param>
        /// <returns></returns>
        public async Task <HttpResponseMessage> PostAsync(string url, SortedDictionary <string, string> parameters)
        {
            if (TwitterCredentials == TwitterCredentials.Null || TwitterCredentials.Valid == false)
            {
                throw new ArgumentException("TwitterCredentials must be specified and validated");
            }

            var oauth1aAuthheader = BuildAuthenticatedResult(url, parameters, "POST");
            var handler           = new HttpClientHandler();

            if (handler.SupportsAutomaticDecompression)
            {
                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
            }
            var client = new HttpClient(handler);

            client.DefaultRequestHeaders.Add("Authorization", oauth1aAuthheader.Header);
            client.DefaultRequestHeaders.Add("User-Agent", TwitterApi.UserAgent());

            var content = parameters.Aggregate(string.Empty, (current, e) => current + string.Format("{0}={1}&", e.Key, Uri.EscapeDataString(e.Value)));
            var data    = new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded");

            var download       = client.PostAsync(url, data).ToObservable().Timeout(TimeSpan.FromSeconds(waitTimeoutSeconds));
            var clientdownload = await download;

            return(clientdownload);
        }
Exemplo n.º 15
0
        public MainWindow()
        {
            InitializeComponent();

            var keys = XElement.Load(".\\Keys.xml");

            TwitterApi = new TwitterApi(keys.Element("consumerKey").Value,
                                        keys.Element("consumerSecret").Value,
                                        keys.Element("token").Value,
                                        keys.Element("tokenSecret").Value);

            this.TimelineTimer = new Timer(state =>
                                    {
                                        var task = new Task(this.UpdateHomeTimeline);
                                        task.Start((TaskScheduler)state);

                                    }, TaskScheduler.FromCurrentSynchronizationContext(), 90000, 90000);


            this.RefreshHomeTimeline.Click += (sender, args) =>
                {
                    if (String.IsNullOrWhiteSpace(this.SinceId))
                        return;

                    this.UpdateHomeTimeline();
                };

            var bgWorker = new BackgroundWorker();
            bgWorker.DoWork += (sender, args) =>
                {
                    if (!this.TwitterApi.AccountCommand.VerifyCredentials(out this.AuthenticatedUser))
                        return;
                };
            bgWorker.RunWorkerCompleted += (sender, args) =>
                {
                    if (this.AuthenticatedUser == null)
                        return;

                    this.ProfileImage.Source = new BitmapImage(new Uri("https://si0.twimg.com/profile_images/1943624052/1cc1blmkl7yg2ud3b8ke_bigger.jpeg"));
                    this.UserInfoStackPanel.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.Name)));
                    this.UserInfoStackPanel.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.Location)));
                    this.UserInfoStackPanel.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.Description)));

                    this.StatisticInfo.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.StatusesCount.ToString())) { HorizontalAlignment = HorizontalAlignment.Center });
                    this.StatisticInfo.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.FollowersCount.ToString())) { HorizontalAlignment = HorizontalAlignment.Center });
                    this.StatisticInfo.Children.Add(new TextBlock(new Run(this.AuthenticatedUser.FriendsCount.ToString())) { HorizontalAlignment = HorizontalAlignment.Center });
                    this.StatisticInfo.Children.Add(new TextBlock(new Run("Tweets")) { HorizontalAlignment = HorizontalAlignment.Center });
                    this.StatisticInfo.Children.Add(new TextBlock(new Run("Followers")) { HorizontalAlignment = HorizontalAlignment.Center });
                    this.StatisticInfo.Children.Add(new TextBlock(new Run("Following")) { HorizontalAlignment = HorizontalAlignment.Center });

                    this.UpdateHomeTimeline();
                };
            bgWorker.RunWorkerAsync();

            this.SendTweet.Click += (sender, args) =>
                {
                    this.TwitterApi.TweetCommand.Update(this.NewTweetBox.Text); 
                    this.NewTweetBox.Clear();
                };
        }
Exemplo n.º 16
0
            public MobypictureApi(TwitterApi twitterApi)
            {
                var handler = twitterApi.CreateOAuthEchoHandler(AuthServiceProvider, OAuthRealm);

                this.http         = Networking.CreateHttpClient(handler);
                this.http.Timeout = Networking.UploadImageTimeout;
            }
Exemplo n.º 17
0
        private void Share_Tap(object sender, GestureEventArgs e)
        {
            Indicator.SetLoadingIndicator(this, "Sending tweet");
            var activite = App.DataContext.CurrentActivity;

            byte[] imageBytes;
            using (MemoryStream ms = new MemoryStream())
            {
                WriteableBitmap btmMap = new WriteableBitmap(activite.Image);

                btmMap.SaveJpeg(ms, activite.Image.PixelWidth, activite.Image.PixelHeight, 0, 100);
                imageBytes = ms.ToArray();
            }

            App.DataContext.IsLoading = true;
            TaskFactory s = new TaskFactory();

            s.StartNew(
                () =>
            {
                TwitterApi.PostMessageWithImageToTwitter(
                    App.DataContext.CurrentActivity.ActivityType.Type + " "
                    + App.DataContext.CurrentActivity.TimeStamp,
                    imageBytes);
            });
        }
        /// <summary>
        /// Returns detailed information about the relationship between two arbitrary users.
        /// </summary>
        /// <param name="sourceScreenName">The user_id of the subject user.</param>
        /// <param name="sourceId">The screen_name of the subject user.</param>
        /// <param name="targetId">The user_id of the target user.</param>
        /// <param name="targetScreenName">The screen_name of the target user.</param>
        /// <returns></returns>
        /// <remarks> ref: https://api.twitter.com/1.1/friendships/show.json </remarks>
        public async static Task <UserStatus> GetFriendship(this IUserSession session, string sourceScreenName = "", string targetScreenName = "", int sourceId = 0, int targetId = 0)
        {
            var parameters = new TwitterParametersCollection();

            if (!string.IsNullOrWhiteSpace(sourceScreenName))
            {
                parameters.Add("source_screen_name", sourceScreenName);
            }

            if (sourceId != 0)
            {
                parameters.Add("source_id", sourceId.ToString());
            }

            if (!string.IsNullOrWhiteSpace(targetScreenName))
            {
                parameters.Add("target_screen_name", targetScreenName);
            }

            if (targetId != 0)
            {
                parameters.Add("target_id", targetId.ToString());
            }

            if (parameters.EnsureAllArePresent(new [] { "source_screen_name", "source_id", "target_screen_name", "target_id" }).IsFalse())
            {
                return(session.MapParameterError <UserStatus>(
                           "source_screen_name, source_id, target_screen_name and target_id are all required"));
            }


            return(await session.PostAsync(TwitterApi.Resolve("/1.1/friendships/show.json"), parameters)
                   .ContinueWith(c => c.MapToSingle <UserStatus>()));
        }
        /// <summary>
        /// Returns detailed information about the relationship between two arbitrary users.
        /// </summary>
        /// <param name="sourceScreenName">The user_id of the subject user.</param>
        /// <param name="sourceId">The screen_name of the subject user.</param>
        /// <param name="targetId">The user_id of the target user.</param>
        /// <param name="targetScreenName">The screen_name of the target user.</param>
        /// <returns></returns>
        /// <remarks> ref: https://api.twitter.com/1.1/friendships/show.json </remarks>
        public async static Task <UserStatus> GetFriendship(this ITwitterSession session, string sourceScreenName = "", string targetScreenName = "", int sourceId = 0, int targetId = 0)
        {
            var parameters = new TwitterParametersCollection();

            if (!string.IsNullOrWhiteSpace(sourceScreenName))
            {
                parameters.Add("source_screen_name", sourceScreenName);
            }

            if (sourceId != 0)
            {
                parameters.Add("source_id", sourceId.ToString());
            }

            if (!string.IsNullOrWhiteSpace(targetScreenName))
            {
                parameters.Add("target_screen_name", targetScreenName);
            }

            if (targetId != 0)
            {
                parameters.Add("target_id", targetId.ToString());
            }

            return(await session.GetAsync(TwitterApi.Resolve("/1.1/friendships/show.json"), parameters)
                   .ContinueWith(c => c.MapToSingle <UserStatus>()));
        }
Exemplo n.º 20
0
        /// <summary>
        /// Returns the locations that Twitter has trending topic information for.
        /// </summary>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/trends/available </remarks>
        public static async Task <TwitterResponseCollection <TrendsAvailableLocationsResponse> > GetTrendsAvailableLocations(this ITwitterSession session)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.GetAsync(TwitterApi.Resolve("/1.1/trends/available.json"), parameters)
                   .ContinueWith(c => c.MapToMany <TrendsAvailableLocationsResponse>()));
        }
Exemplo n.º 21
0
        /// <summary>
        /// Sets values that users are able to set under the "Account" tab of their settings page. Only the parameters specified will be updated.
        /// </summary>
        /// <param name="name">Full name associated with the profile. Maximum of 20 characters.</param>
        /// <param name="profileUrl">URL associated with the profile. Will be prepended with "http://" if not present. Maximum of 100 characters.</param>
        /// <param name="location">The city or country describing where the user of the account is located.</param>
        /// <param name="description">A description of the user owning the account. Maximum of 160 characters.</param>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/post/account/update_profile </remarks>
        public static async Task <User> ChangeAccountProfile(this IUserSession session, string name = "",
                                                             string profileUrl = "", string location = "", string description = "")
        {
            var parameters = new TwitterParametersCollection();

            parameters.Create(include_entities: true, skip_status: true);

            // first 20 chars
            if (!string.IsNullOrWhiteSpace(name))
            {
                parameters.Add("name", name.TrimAndTruncate(20));
            }

            // first 100 chars
            if (!string.IsNullOrWhiteSpace(profileUrl))
            {
                parameters.Add("purl", profileUrl.TrimAndTruncate(100));
            }

            // first 30 chars
            if (!string.IsNullOrWhiteSpace(location))
            {
                parameters.Add("location", location.TrimAndTruncate(30));
            }

            // first 160 chars
            if (!string.IsNullOrWhiteSpace(description))
            {
                parameters.Add("description", description.TrimAndTruncate(160));
            }

            return(await session.PostAsync(TwitterApi.Resolve("/1.1/account/update_profile.json"), parameters)
                   .ContinueWith(c => c.MapToSingle <User>()));
        }
Exemplo n.º 22
0
        /// <summary>
        /// Returns the authenticated user's saved search queries.
        /// </summary>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/saved_searches/list </remarks>
        public async static Task <TwitterResponseCollection <SavedSearch> > GetSavedSearches(this IUserSession session)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.GetAsync(TwitterApi.Resolve("/1.1/saved_searches/list.json"), parameters)
                   .ContinueWith(c => c.MapToMany <SavedSearch>()));
        }
Exemplo n.º 23
0
        private void MainForm_Load(object sender, EventArgs e)
        {
            settings  = new IniSettings(new FileInfo("BlockThemAll.ini"));
            loginTemp = TwitterApi.Login(settings);
            ProcessTwitterLogin();

            SetProgressLabel(workStatus.ToString());

            foreach (KeyValuePair <string, Dictionary <string, object> > item in settings)
            {
                if (item.Key.Equals("Authenticate"))
                {
                    continue;
                }

                loginTemp = TwitterApi.Login(settings, item.Key);
                ProcessTwitterLogin(item.Key);
            }

            CredentialManager.Instance.SelectCredential("Default");

            if (CredentialManager.Instance.Status == UserStatus.LOGIN_SUCCESS)
            {
                RefreshMyInfo();
            }
        }
Exemplo n.º 24
0
        /// <summary>
        /// Use OAuth1.0a auth to do more intensive reads
        /// </summary>
        /// <param name="url">URL to call</param>
        /// <param name="parameters">Params to send</param>
        /// <returns></returns>
        public new async Task <HttpResponseMessage> GetAsync(string url, SortedDictionary <string, string> parameters)
        {
            if (TwitterCredentials == TwitterCredentials.Null || TwitterCredentials.Valid == false)
            {
                throw new ArgumentException("TwitterCredentials must be specified and validated");
            }

            var querystring = parameters.Aggregate("", (current, entry) => current + (entry.Key + "=" + entry.Value + "&"));

            var oauth1aAuthheader = BuildAuthenticatedResult(url, parameters, "GET");
            var fullUrl           = url;

            var handler = new HttpClientHandler();

            if (handler.SupportsAutomaticDecompression)
            {
                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
            }
            var client = new HttpClient(handler);

            client.DefaultRequestHeaders.Add("Authorization", oauth1aAuthheader.Header);
            client.DefaultRequestHeaders.Add("User-Agent", TwitterApi.UserAgent());

            if (!string.IsNullOrWhiteSpace(querystring))
            {
                fullUrl += "?" + querystring.Substring(0, querystring.Length - 1);
            }

            var download       = client.GetAsync(fullUrl).ToObservable().Timeout(TimeSpan.FromSeconds(waitTimeoutSeconds));
            var clientdownload = await download;

            return(clientdownload);
        }
        /// <summary>
        /// Access to Twitter's suggested user list. This returns the list of suggested user categories.
        /// </summary>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/users/suggestions </remarks>
        public static async Task <TwitterResponseCollection <SuggestedUsers> > GetSuggestedLists(this ITwitterSession session)
        {
            var parameters = new TwitterParametersCollection();

            return(await session.GetAsync(TwitterApi.Resolve("/1.1/users/suggestions.json"), parameters)
                   .ContinueWith(c => c.MapToMany <SuggestedUsers>()));
        }
Exemplo n.º 26
0
        protected void Page_Load(object sender, EventArgs e)
        {
            // Create Twitter API
            TwitterApi api = new TwitterApi(
                new ApiCallOptions
            {
                AuthorizationCallbackUri = new Uri(
                    this.Request.Url,
                    new VPathResolver().Resolve("~/User.aspx"))
            });

            try
            {
                // Load current user
                // If the user has not yet connected to Twitter, this will
                // throw an AuthorizationRequiredException, handled below
                CachingContainer <ExtendedUser> extendedUserInfoCache
                    = this.Session[UserInfoKey] as CachingContainer <ExtendedUser>;

                if (extendedUserInfoCache == null)
                {
                    this.Session[UserInfoKey]             = extendedUserInfoCache
                                                          = new CachingContainer <ExtendedUser>();
                }

                this.TwitterUser = extendedUserInfoCache.Load(
                    TimeSpan.FromMinutes(5),
                    () =>
                {
                    ExtendedUser user;
                    if (api.VerifyCredentials(out user))
                    {
                        return(user);
                    }
                    else
                    {
                        throw new BadCredentialsException();
                    }
                });

                // Load user timeline
                CachingContainer <IList <Status> > userTimelineCache
                    = this.Session[UserTimelineKey] as CachingContainer <IList <Status> >;

                if (userTimelineCache == null)
                {
                    this.Session[UserTimelineKey]             = userTimelineCache
                                                              = new CachingContainer <IList <Status> >();
                }

                this.UserTimeline = userTimelineCache.Load(
                    TimeSpan.FromSeconds(30),
                    () => api.UserTimeline());
            }
            catch (BadCredentialsException)
            {
                this.Response.Redirect("~/Disconnect.aspx?error=badcredentials", true);
            }
        }
Exemplo n.º 27
0
 protected void Page_Load(object sender, EventArgs e)
 {
     // Redirect to User page if user is already authorized with Twitter
     if (TwitterApi.IsAuthorized())
     {
         this.Response.Redirect("~/User.aspx");
     }
 }
Exemplo n.º 28
0
        /// <summary>
        /// Returns all the information about a known place.
        /// </summary>
        /// <param name="placeId">A place in the world.</param>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/geo/id/%3Aplace_id </remarks>
        public static async Task <Place> GetPlaceInfo(this IUserSession session, string placeId)
        {
            var parameters = new SortedDictionary <string, string>();
            var url        = TwitterApi.Resolve("/1.1/geo/id/{0}.json", placeId);

            return(await session.GetAsync(url, parameters)
                   .ContinueWith(c => c.MapToSingle <Place>()));
        }
Exemplo n.º 29
0
        /// <summary>
        /// Retrieve the information for the saved search represented by the given id.
        /// </summary>
        /// <param name="id">The ID of the saved search.</param>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/saved_searches/show/%3Aid </remarks>
        public async static Task <SavedSearch> GetSaveASearch(this IUserSession session, string id)
        {
            var parameters = new TwitterParametersCollection();
            var url        = TwitterApi.Resolve("/1.1/saved_searches/show/{0}.json", id);

            return(await session.GetAsync(url, parameters)
                   .ContinueWith(c => c.MapToSingle <SavedSearch>()));
        }
        /// <summary>
        /// Access the users in a given category of the Twitter suggested user list.
        /// </summary>
        /// <param name="slug">The short name of list or a category returned by GetSuggestedList</param>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/users/suggestions/%3Aslug </remarks>
        public static async Task <SuggestedUsers> GetSuggestedUsers(this ITwitterSession session, string slug)
        {
            var parameters = new TwitterParametersCollection();
            var url        = TwitterApi.Resolve("/1.1/users/suggestions/{0}.json", slug);

            return(await session.GetAsync(url, parameters)
                   .ContinueWith(c => c.MapToSingle <SuggestedUsers>()));
        }
Exemplo n.º 31
0
        /// <summary>
        /// Returns the current rate limits for methods belonging to the specified resource families.
        /// </summary>
        /// <returns></returns>
        /// <remarks> ref: https://dev.twitter.com/docs/api/1.1/get/application/rate_limit_status </remarks>
        public static async Task <ApiRateStatusResponse> GetCurrentApiStatus(this ITwitterSession session)
        {
            var parameters = new SortedDictionary <string, string>();
            var url        = TwitterApi.Resolve("/1.1/application/rate_limit_status.json");
            var c          = session.GetAsync(url, parameters);

            return(await c.MapToApiRateLimits());
        }
 public TwitterFeedViewModel(TwitterApi.TwitterApi twitterApi)
 {
     _twitterApi = twitterApi;
     Items = new ObservableCollection<TweetViewItem>();
 }