public ActionResult Search(SearchModel model)
{
ITwitterClient twitterClient = new TwitterClient();
var tweetRepository = new TweetPageRepository();
var cachedPage = tweetRepository.GetPageBySearchString(model.HashtagToSearchFor, model.PageToRetrieve);
if (cachedPage != null)
{
return PartialView(cachedPage.ToModel(model.PageToRetrieve, PAGE_SIZE, model.HashtagToSearchFor));
}
int twitterPage = (int)Math.Ceiling(model.PageToRetrieve / (float)PAGE_SIZE);
var searchResults = twitterClient.SearchByHashtag(model.HashtagToSearchFor, CACHE_SIZE, twitterPage);
int pageCount = (int)Math.Ceiling(searchResults.Count()/(decimal)PAGE_SIZE);
int cachePageRangeStart = ((twitterPage - 1) * PAGE_SIZE) + 1;
var searchResultPages = Enumerable.Range(0, pageCount)
.Select(pageNo => searchResults.Skip(pageNo * PAGE_SIZE).Take(PAGE_SIZE))
.Select((page, pageNo) => page.ToRepositoryContract(cachePageRangeStart + pageNo, PAGE_SIZE, model.HashtagToSearchFor));
tweetRepository.ReplacePages(searchResultPages);
var currentPageResult = searchResultPages.FirstOrDefault(page => page.Page == model.PageToRetrieve);
return PartialView(currentPageResult.ToModel(model.PageToRetrieve, PAGE_SIZE, model.HashtagToSearchFor));
}
void UpdateTimeLine(RestUsage r, RestUpdateDelegate func, TimeLineType type, int sinceListIndex)
{
r.LastExecTime = DateTime.Now;
r.IsRunning = true;
ThreadPool.QueueUserWorkItem(delegate(object o) {
try {
Status[] statuses = func(_restSinceList[sinceListIndex], null, r.Count, null);
_restSinceList[sinceListIndex] = TwitterClient.GetMaxStatusID(_restSinceList[sinceListIndex], statuses);
_dispatcher.BeginInvoke(new EmptyDelegate(delegate() {
for (int i = 0; i < statuses.Length; i++)
{
statuses[i].AccountInfo = this;
if (type == TimeLineType.Home && IsMention(statuses[i]))
{
Mentions.Add(statuses[i]);
if (!_mgr.HomeIncludeMentions)
{
continue;
}
}
else if (type == TimeLineType.Mentions && _mgr.HomeIncludeMentions)
{
HomeTimeline.Add(statuses[i]);
}
r.TimeLine.Add(statuses[i]);
}
}));
} catch {
} finally {
r.IsRunning = false;
r.LastExecTime = DateTime.Now;
r.UpdateNextExecTimeRemaining();
}
});
}
public async Task <ActionResult> ValidateTwitterAuth()
{
var verifierCode = Request.Params.Get("oauth_verifier");
var authenticationRequestId = Request.Params.Get(TWITTER_AUTH_QUERY_PARAMETER);
if (verifierCode == null)
{
return(View());
}
if (!AuthenticationRequestsInProgress.TryGetValue(authenticationRequestId, out var jsonAuthRequest))
{
return(View());
}
var authRequest = AppClient.Json.Deserialize <AuthenticationRequest>(jsonAuthRequest);
var userCredentials = await AppClient.Auth.RequestCredentialsFromCallbackUrl(Request.Url, authRequest);
var client = new TwitterClient(userCredentials);
MyCredentials.LastAuthenticatedCredentials = userCredentials;
var user = await client.Users.GetAuthenticatedUser();
ViewBag.User = user;
return(View());
}
private void shareImageToolStripMenuItem_Click(object sender, EventArgs e)
{
Tweet tweet = new Tweet(GetImageFromSelection());
tweet.TweetSubmitted += (s, args) => {
string msg = args.GetTweet();
Image img = args.GetImage();
string fileName = Path.GetTempFileName();
img.Save(fileName, ImageFormat.Png);
TwitterClient twitterClient = new TwitterClient(new OAuth(
consumerKey,
consumerSecret,
accessToken,
accessTokenSecret
));
TwitterResponse tweetResponse = twitterClient.SendTweetWithMedia(msg, fileName);
if (tweetResponse.Failed)
{
Console.WriteLine("Failed to post tweet");
Console.Write(tweetResponse.FailedMessage);
}
else
{
Console.WriteLine("Successfully posted tweet and media");
}
};
tweet.Show(this);
}
/// <summary>
/// Registers a supported OAuth client with the specified consumer key and consumer secret.
/// </summary>
/// <param name="client">One of the supported OAuth clients.</param>
/// <param name="consumerKey">The consumer key.</param>
/// <param name="consumerSecret">The consumer secret.</param>
public static void RegisterOAuthClient(BuiltInOAuthClient client, string consumerKey, string consumerSecret)
{
IAuthenticationClient authenticationClient;
switch (client)
{
case BuiltInOAuthClient.LinkedIn:
authenticationClient = new LinkedInClient(consumerKey, consumerSecret);
break;
case BuiltInOAuthClient.Twitter:
authenticationClient = new TwitterClient(consumerKey, consumerSecret);
break;
case BuiltInOAuthClient.Facebook:
authenticationClient = new FacebookClient(consumerKey, consumerSecret);
break;
case BuiltInOAuthClient.WindowsLive:
authenticationClient = new WindowsLiveClient(consumerKey, consumerSecret);
break;
default:
throw new ArgumentOutOfRangeException("client");
}
RegisterClient(authenticationClient);
}
public void SearchByHashtag_Returns_Search_Results_With_HashTag_In_Them()
{
string hashTagToSearchFor = "yarr";
var target = new TwitterClient();
var results = target.SearchByHashtag(hashTagToSearchFor, 10, 1);
Assert.IsTrue(results.All(result => result.Text.ToLower().Contains("#" + hashTagToSearchFor)), "Search returned result not containing hashtag searched for.");
}
public TweetsPanelViewModel(AppInfo appInfo, TwitterClient client, Func <string, UserViewModel> userViewModelFactory)
{
AppInfo = appInfo;
Tweets = new TweetCollection();
_client = client;
_userViewModelFactory = userViewModelFactory;
}
public TwitterAccount(TwitterAccountManager mgr)
{
_mgr = mgr;
_oauthClient = new OAuthClient(ConsumerKeyStore.Key, ConsumerKeyStore.Secret, TwitterClient.RequestTokenURL,
TwitterClient.AccessTokenURL, TwitterClient.AuthorizeURL, TwitterClient.XAuthURL);
_client = new TwitterClient(_oauthClient);
_dispatcher = Dispatcher.CurrentDispatcher;
// defaults
SelfUserID = 0;
RestHome = new RestUsage {
Interval = TimeSpan.FromSeconds(30), Count = 200
};
RestMentions = new RestUsage {
Interval = TimeSpan.FromSeconds(600), Count = 20
};
RestDirectMessages = new RestUsage {
Interval = TimeSpan.FromSeconds(600), Count = 20
};
RestList = new TwitterAccount.RestUsage {
Interval = TimeSpan.FromSeconds(30), Count = 200
};
RestSearch = new TwitterAccount.RestUsage {
Interval = TimeSpan.FromSeconds(30), Count = 100
};
_restInfoList = new RestUsage[] { RestHome, RestMentions, RestDirectMessages };
_restSinceList = new ulong?[] { null, null, null };
}
public static async Task <IActionResult> TwitterAuth(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log)
{
try
{
var appClient = new TwitterClient(Environment.GetEnvironmentVariable("TwitterConsumerKey"), Environment.GetEnvironmentVariable("TwitterConsumerSecret"));
var authenticationRequestId = Guid.NewGuid().ToString();
var redirectPath = Environment.GetEnvironmentVariable("RedirectUri");
var redirectURL = $"{redirectPath}";
var authenticationRequestToken = await appClient.Auth.RequestAuthenticationUrlAsync(redirectURL);
var tokenRepsonse = new TwitterAuthResponse
{
Success = true,
TokenResponse = new TokenResponse
{
OAuthToken = authenticationRequestToken.AuthorizationKey,
OAuthTokenSecret = authenticationRequestToken.AuthorizationSecret
}
};
return(new OkObjectResult(tokenRepsonse));
}
catch (Exception ex)
{
log.LogError(ex.Message);
return(ErrorResponse.InternalServerError(detail: "Authentication Issue", success: false));
}
}
public async Task <IActionResult> Timeline([FromQuery(Name = "older")] string olderFrom, [FromQuery(Name = "newer")] string newerFrom)
{
var client = new TwitterClient(await this.HttpContext.GetTwitterAccessToken());
var data = await client.GetTimeLine(olderFrom, newerFrom);
return(Content(data, "application/javascript"));
}
static async Task Main(string[] args)
{
DotNetEnv.Env.Load();
string TWITTER = Environment.GetEnvironmentVariable("TWITTER_TOKEN");
string TWITTER_URL = Environment.GetEnvironmentVariable("TWITTER_URL");
string LINE_TOKEN = Environment.GetEnvironmentVariable("LINE_TOKEN");
string LINE_URL = Environment.GetEnvironmentVariable("LINE_URL");
LineClient client = new LineClient(LINE_URL, LINE_TOKEN);
TwitterClient <Tweet> twitterClient = new TwitterClient <Tweet>(TWITTER, TWITTER_URL, client);
while (true)
{
try
{
await twitterClient.Stream();
}
catch (IOException e)
{
Console.WriteLine(e);
Console.WriteLine("Attempting to reconnect waiting 10 second.");
System.Threading.Thread.Sleep(10000);
}
catch (HttpRequestException e)
{
Console.WriteLine(e);
Console.WriteLine("Attempting to reconnect waiting 10 second.");
System.Threading.Thread.Sleep(10000);
}
}
}
protected override IEnumerable<IEntry> GetStatuses(TwitterClient client, StatusRange range)
{
var name = this.UserName ?? client.Account.Name;
IEnumerable<IEntry> rt;
switch (this.Mode)
{
case IndexMode.Index:
rt = client.Lists.Index(name);
break;
case IndexMode.Subscriptions:
rt = client.Lists.Subscriptions(name);
break;
case IndexMode.Memberships:
rt = client.Lists.Memberships(name);
break;
default:
rt = Enumerable.Empty<IEntry>();
break;
}
if (name != client.Account.Name)
rt = rt.ReduceAuthenticatedQuery();
return rt;
}
public async Task <ContentResult> OnPostUserDataAsync(string userid)
{
if (!string.IsNullOrEmpty(userid))
{
try
{
TwitterClient client = new TwitterClient(new TwitterCreds().GenerateCredentials());
var usr = await client.Users.GetUserAsync(userid).ConfigureAwait(true);
if (usr != null)
{
TweetUser tweetUser = new TweetUser
{
Avatar = usr.ProfileImageUrl,
CreationDate = $"Joined {usr.CreatedAt}",
Description = usr.Description,
Fullname = usr.Name,
PrifileBannerImg = usr.ProfileBackgroundImageUrl,
GeoLoc = usr.Location,
Profile = $"https://twitter.com/{usr.ScreenName}"
};
return(Content(JsonConvert.SerializeObject(tweetUser)));
}
}
catch (Exception)
{
return(Content("Raw data not found"));
}
}
else
{
return(Content("Raw data not found"));
}
return(Content("Raw data not found"));
}
public TwitterBot(TwitterSettings settings, PokeTradeHub <PK8> hub)
{
Hub = hub;
Settings = settings;
client = new TwitterClient(Settings.ConsumerKey, Settings.ConsumerSecret, Settings.AccessToken, Settings.AccessTokenSecret);
client.Events.OnTwitterException += HandleTwitterException;
try
{
var taskAuthenticate = Task.Run(async() => await client.Users.GetAuthenticatedUserAsync());
TwitterUser = taskAuthenticate.Result;
LogUtil.LogText($"Successfully authenticated as: @{TwitterUser.ScreenName}");
MentionParams = new GetMentionsTimelineParameters {
PageSize = Settings.MentionCount
};
var taskGetInitialMentions = Task.Run(async() => await client.Timelines.GetMentionsTimelineAsync(MentionParams));
localMentions = new TwitterMentions(taskGetInitialMentions.Result);
Task.Run(() => CheckMentionsForTradesAsync(localMentions, CancellationToken.None));
}
catch (Exception e)
{
LogUtil.LogError($"Unable to authenticate with error: {e.Message}", nameof(TwitterBot));
}
}
public void SearchByHashtag_Returns_Non_Null_Value()
{
string hashTagToSearchFor = "yarr";
var target = new TwitterClient();
var results = target.SearchByHashtag(hashTagToSearchFor, 10, 1);
Assert.IsNotNull(results, "SearchByHashtag returned null results");
}
public ITwitterPageIterator <ITwitterResult <ITweetDTO[]>, long?> GetUserFavoriteTweetsIterator(IGetUserFavoriteTweetsParameters parameters)
{
_tweetsClientRequiredParametersValidator.Validate(parameters);
var request = TwitterClient.CreateRequest();
return(_tweetController.GetFavoriteTweetsIterator(parameters, request));
}
public void SendTweet()
{
var client = new TwitterClient(applicationSecrets.TwitterApiKey, applicationSecrets.TwitterSecretKey, applicationSecrets.TwitterBearerToken);
var username = client.Tweets.PublishTweetAsync("test2").Result;
Console.WriteLine(username);
}
private void FetchReply(TwitterMessage message, StatusView statusView)
{
if (message.InReplyToId > 0)
{
TwitterClient client = new TwitterClient();
client.GetStatusCompleted += (o, e) =>
{
if (e.Error == null)
{
TwitterMessage newMessage = new TwitterMessage(XElement.Parse(e.Result));
// Create a new
var animatee = new AnimatableMessage()
{
TwitterMessage = newMessage
};
var timelines = animatee.GetAnimations();
var parentMessage = animatemessages.First(a => a.TwitterMessage == message);
int index = animatemessages.IndexOf(parentMessage);
animatemessages.Insert(index, animatee);
mainBoard.Stop();
foreach (var timeline in timelines)
{
mainBoard.Children.Add(timeline);
}
animatee.AnimateTo(parentMessage.X, parentMessage.Y + 300, parentMessage.Z);
MoveToMessage(index);
}
};
client.GetStatusAsync(message.InReplyToId);
}
}
static void Main(string[] args)
{
int i = args.Count() == 4 ? 0 : 1;
string consumerKey = args.ElementAtOrDefault(i++) ?? CONSUMER_KEY;
string consumerSecret = args.ElementAtOrDefault(i++) ?? CONSUMER_SECRET;
string accessToken = args.ElementAtOrDefault(i++) ?? ACCESS_TOKEN;
string accessSecret = args.ElementAtOrDefault(i++) ?? ACCESS_SECRET;
var client = new TwitterClient(consumerKey, consumerSecret, accessToken, accessSecret);
var user = client.Users.GetAuthenticatedUserAsync().Result;
DateTime lastUpdate = Convert.ToDateTime(Regex.Match(user.GetUserTimelineAsync().Result.FirstOrDefault().Text, @"\[(.*?)\]").Groups[1].Value, new CultureInfo("es-ES"));
List <Vaccination> vaccinations = GetVaccinations(lastUpdate);
if (vaccinations.Any())
{
foreach (var vaccination in vaccinations.OrderBy(v => v.Date))
{
var progressBar = new string(FULL, (int)vaccination.Percentage / 5) + new string(EMPTY, 20 - ((int)vaccination.Percentage / 5));
var tweet = $"[{vaccination.Date.ToString("dd/MM/yyyy")}] {vaccination.Percentage}% #COVID19 #VacunaCOVID19\n{progressBar}";
_ = user.PublishTweetAsync(tweet).Result;
Console.WriteLine($"Tweet published: {tweet}");
}
}
else
{
Console.WriteLine($"No updated data. Try again later.");
}
}
public UserViewModel(AppInfo appInfo, TwitterClient client, string username)
{
_appInfo = appInfo;
_client = client;
Reload(username);
}
private void Test_SearchTwitterUserByScreenName_ReturnCorrectResults_OrRateLimitedResponse(string twitterScreenName)
{
TwitterClient client = new TwitterClient();
TweetUsers tweetUser = new TweetUsers();
try
{
tweetUser = client.GetUserDetailsByScrapping(twitterScreenName);
Assert.IsNotNull(tweetUser);
Assert.AreEqual(tweetUser.ScreenName, twitterScreenName, true);
}
catch (Exception ex)
{
string twitterLimitException = "The remote server returned an unexpected response: (400) Bad Request.";
string twitterHttpException = "The HTTP request was forbidden with client authentication scheme 'Basic'.";
if (ex.Message.Equals(twitterHttpException))
{
Assert.AreEqual(twitterHttpException, ex.Message);
}
else
{
Assert.AreEqual(twitterLimitException, ex.Message);
}
}
}
public TweetsPanelViewModel(AppInfo appInfo, TwitterClient client, Func<string, UserViewModel> userViewModelFactory)
{
AppInfo = appInfo;
Tweets = new TweetCollection();
_client = client;
_userViewModelFactory = userViewModelFactory;
}
public override IClaimsIdentity ProcessSignInResponse(string realm, string originalUrl, HttpContextBase httpContext)
{
var client = new TwitterClient(this.consumerKey, this.consumerSecret);
AuthenticationResult result;
try
{
result = client.VerifyAuthentication(httpContext);
}
catch (WebException wex)
{
throw new InvalidOperationException(new StreamReader(wex.Response.GetResponseStream()).ReadToEnd(), wex);
}
var claims = new List <Claim>
{
new Claim(System.IdentityModel.Claims.ClaimTypes.NameIdentifier, result.ExtraData["name"])
};
foreach (var claim in result.ExtraData)
{
claims.Add(new Claim("http://schemas.twitter.com/" + claim.Key, claim.Value));
}
return(new ClaimsIdentity(claims, "Twitter"));
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
_client = new TwitterClient();
var loading = new UIAlertView("Downloading Tweets", "Please wait...", null, null, null);
loading.Show();
var indicator = new UIActivityIndicatorView(UIActivityIndicatorViewStyle.WhiteLarge);
indicator.Center = new System.Drawing.PointF(loading.Bounds.Width / 2, loading.Bounds.Size.Height - 40);
indicator.StartAnimating();
loading.AddSubview(indicator);
_client.GetTweetsForUser("OReillyMedia", tweets =>
{
InvokeOnMainThread(() =>
{
TableView.Source = new TwitterTableViewSource(tweets);
TableView.ReloadData();
loading.DismissWithClickedButtonIndex(0, true);
});
});
_client.MentionReceived += (object sender, MentionEventArgs args) =>
{
InvokeOnMainThread(() =>
new UIAlertView("Mention Received", args.Tweet.Text,
null, "Ok", null).Show());
};
}
private static Tuple <IFilteredStream, Func <Action <string> > > InitForCatchingJsonEvents()
{
// arrange
var fakeStreamResultGenerator = A.Fake <IStreamResultGenerator>();
var container = new TweetinviContainer();
container.BeforeRegistrationCompletes += (sender, args) =>
{
container.RegisterInstance(typeof(IStreamResultGenerator), fakeStreamResultGenerator);
};
container.Initialize();
Action <string> jsonReceivedCallback = null;
A.CallTo(() => fakeStreamResultGenerator.StartAsync(It.IsAny <Action <string> >(), It.IsAny <Func <ITwitterRequest> >()))
.ReturnsLazily(callInfo =>
{
jsonReceivedCallback = callInfo.Arguments.Get <Action <string> >("onJsonReceivedCallback");
return(Task.CompletedTask);
});
var client = new TwitterClient(A.Fake <ITwitterCredentials>(), new TwitterClientParameters
{
Container = container
});
var fs = client.Streams.CreateFilteredStream();
return(new Tuple <IFilteredStream, Func <Action <string> > >(fs, () => jsonReceivedCallback));
}
private async Task Retweet(Tweet tweet, UserAccessToken user)
{
var client = new TwitterClient(user.accessToken);
HttpResponseMessage res;
try
{
res = await client.ChangeRetweet(tweet);
if (!res.IsSuccessStatusCode)
{
throw new Exception(res.ReasonPhrase);
}
else
{
tmpRetweet.retweetedImageUrl = "/Assets/TwitterIcons/retweet_on.png";
tweet.retweeted = true;
}
}
catch (Exception ex)
{
//throw new Exception("おや？ なにかがおかしいようです。", ex);
var message = new MessageDialog(ex.Message, "おや？ なにかがおかしいようです。");
await message.ShowAsync();
}
}
public async Task <RedirectResult> OnGet()
{
var appClient = new TwitterClient(TwitifyController.ConsumerKey, TwitifyController.ConsumerSecret);
// Extract the information from the redirection url
var requestParameters = await RequestCredentialsParameters.FromCallbackUrlAsync(Request.QueryString.Value, TwitifyController._myAuthRequestStore);
// Request Twitter to generate the credentials.
var userCreds = await appClient.Auth.RequestCredentialsAsync(requestParameters);
Response.Cookies.Append("AccessToken", userCreds.AccessToken);
Response.Cookies.Append("AccessTokenSecret", userCreds.AccessTokenSecret);
// Congratulations the user is now authenticated!
var userClient = new TwitterClient(userCreds);
var user = await userClient.Users.GetAuthenticatedUserAsync();
Response.Cookies.Append("Bio", userClient.Users.GetAuthenticatedUserAsync().Result.Description);
Response.Cookies.Append("UserName", userClient.Users.GetAuthenticatedUserAsync().Result.ScreenName);
Response.Cookies.Append("Profile", userClient.Users.GetAuthenticatedUserAsync().Result.ProfileImageUrl400x400);
Uri baseUri = TwitifyController.SpotifyUri;
var loginRequest = new LoginRequest(baseUri, TwitifyController.clientId, LoginRequest.ResponseType.Token)
{
Scope = new[] { Scopes.UserReadPlaybackState, Scopes.UserReadEmail, Scopes.UserReadCurrentlyPlaying }
};
return(Redirect(loginRequest.ToUri().ToString()));
}
public override async void Navigated(string navigationParameter)
{
try
{
IsSearching = true;
Tweets.Clear();
var clientResponse = await _twitterAuthenticator.AuthenticateAsync(_authInformation.AccessToken, _authInformation.AccessTokenSecret);
if (clientResponse.StatusCode != HttpStatusCode.OK)
{
Debug.WriteLine("Error authenticating: " + clientResponse.StatusCode + ": " + clientResponse.ErrorMessage);
return;
}
TwitterClient client = clientResponse.Content;
var searchResponse = await client.SearchAsync(navigationParameter, RESULTS_TO_SHOW);
if (searchResponse.StatusCode != HttpStatusCode.OK)
{
Debug.WriteLine("Error searching: " + clientResponse.StatusCode + ": " + clientResponse.ErrorMessage);
return;
}
Tweets.Clear();
//Tweets.Add(new Tweet()
//{
// Author = "dsplaisted",
// ProfileImageUrl = new Uri("https://pbs.twimg.com/profile_images/51934680/iguana_bigger.jpg"),
// Text = "Short tweet",
// Timestamp = DateTime.Now
//});
//Tweets.Add(new Tweet()
//{
// Author = "dsplaisted",
// ProfileImageUrl = new Uri("https://pbs.twimg.com/profile_images/51934680/iguana_bigger.jpg"),
// Text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
// Timestamp = DateTime.Now
//});
foreach (var tweet in searchResponse.Content)
{
Tweets.Add(new Tweet()
{
Author = tweet.User.ScreenName,
ProfileImageUrl = tweet.User.ProfileImageUri,
Text = tweet.Text,
Timestamp = tweet.CreatedAt
});
}
IsSearching = false;
}
catch (Exception ex)
{
Debug.WriteLine("Error searching Twitter: " + ex.ToString());
}
}
public void WhenSearchingForNull()
{
// Arrange
var twitterClient = new TwitterClient();
// Act & Assert
twitterClient.Search(null);
}
private static void TweetThis(TwitterClient twitterClient, Tweet tweet, Sender<TweetStatus> sender) {
var response = twitterClient.Tweet(tweet.Message, tweet.Token);
var tweetStatus = new TweetStatus {
CorrelationId = tweet.CorrelationId,
Status = response
};
sender.Send(tweetStatus);
}
public void WhenSearchingForAnEmptyString()
{
// Arrange
var twitterClient = new TwitterClient();
// Act & Assert
twitterClient.Search(string.Empty);
}
/// <summary>
/// Twitter クライアントと基になる JSON オブジェクトを指定し TwitterStreamEventArgs の新しいインスタンスを初期化します。
/// </summary>
/// <param name="client">Twitter クライアント。</param>
/// <param name="json">基になる JSON オブジェクト。</param>
public TwitterStreamEventArgs(TwitterClient client, DynamicJson json)
{
this.json = json;
this.Account = client.Account;
this.Source = new User(client, this.json.source);
this.Target = new User(client, this.json.target);
this.TargetStatus = this.json.target_object() ? new Status(client, this.json.target_object, this.Target) : null;
}
public NotificationService(AppInfo appInfo, TwitterClient client)
{
_appInfo = appInfo;
_subscription = client
.Sample(TimeSpan.FromSeconds(6))
.Where(t => (DateTime.Now - t.CreatedAt) < TimeSpan.FromSeconds(5))
.DispatcherSubscribe(ShowWindow);
}
public TwitterClientAccountsTests()
{
TwitterClient = new TwitterClient(
new TwitterEngine(),
@"489215628-Q2annlx2kf64c7eXSHdY1gWtqvOqbNKcro01CpWy",
@"P3UC7wfoOqwAr0tr6M2tmVxXDsMNygvLIYUyUbceRy0",
@"pb7MDQjxovHvexFhf4PFg",
@"Web3xweVUG6wxgZr2V4JpbOR0qdtltHt8j5b8oQPlY");
}
protected override IEnumerable<IEntry> GetStatuses(TwitterClient client, StatusRange range)
{
if (string.IsNullOrEmpty(this.Query))
return Enumerable.Empty<IEntry>();
else
return client.StatusCache.GetStatuses()
.AsQueryable()
.Where(this.Query);
}
private static void Authenticate() {
var twitterClient = new TwitterClient();
twitterClient.AuthenticateAppViaBrowser();
Console.Write("Please enter the pin: ");
var pin = Console.ReadLine();
var token = twitterClient.CreateTokenFromPin(pin);
token.WriteToFile(CredentialsFilename);
}
public void WhenSearchingForAWordWithSpaces()
{
// Arrange
var twitterClient = new TwitterClient();
// Act
var results = twitterClient.Search("United States of America");
// Assert
Assert.IsNotNull(results);
}
public void WhenSearchingForAWord()
{
// Arrange
var twitterClient = new TwitterClient();
// Act
var results = twitterClient.Search("America");
// Assert
Assert.IsNotNull(results);
}
public void BeginStream_WithSimpleCallback_ReturnsAValue()
{
// arrange
var restClient = Substitute.For<IRestClient>();
const string callback = "http://something.com/foo";
// act
var client = new TwitterClient(restClient, "foo", "bar", callback);
var result = client.BeginStream((a, b) => { }, null);
Assert.That(result, Is.Not.Null);
}
/// <summary>
/// クライアントと取得範囲を指定しソースからエントリを取得します。
/// </summary>
/// <param name="client">クライアント。</param>
/// <param name="range">取得範囲。</param>
/// <returns>取得したエントリ。</returns>
protected override IEnumerable<IEntry> GetStatuses(TwitterClient client, StatusRange range)
{
if (this.Query == null)
return Enumerable.Empty<IEntry>();
var words = this.Query.Split(' ', ' ');
if (words.Any())
return client.StatusCache.GetStatuses().Where(_ => words.All(_.UserName.Contains) || words.All(_.Text.Contains));
else
return Enumerable.Empty<IEntry>();
}
public void Constructor_WithCallback_IsSetToCredentials()
{
// arrange
var restClient = Substitute.For<IRestClient>();
const string callback = "http://something.com/foo";
// act
var client = new TwitterClient(restClient, "foo", "bar", callback);
// assert
var credentials = client.Credentials as OAuthCredentials;
Assert.That(credentials.CallbackUrl == callback);
}
public void Constructor_WithMockService_SetsCredentials()
{
// arrange
var restClient = Substitute.For<IRestClient>();
const string consumerKey = "foo";
const string consumerSecret = "bar";
// act
var client = new TwitterClient(restClient, consumerKey, consumerSecret, "");
//assert
var credentials = client.Credentials as OAuthCredentials;
Assert.That(credentials.ConsumerKey == consumerKey);
Assert.That(credentials.ConsumerSecret == consumerSecret);
}
protected override IEnumerable<IEntry> GetStatuses(TwitterClient client, StatusRange range)
{
if (statuses == null ||
range == null ||
range.Page == 1 ||
range.Page < currentPage)
{
statuses = client.Statuses.Followers(this.UserName ?? client.Account.Name).GetEnumerator();
currentPage = 1;
}
for (int i = currentPage; i <= range.Page; i++)
statuses.MoveNext();
return statuses.Current;
}
void getFriendsWorker_DoWork(object sender, DoWorkEventArgs e)
{
// get friends from twitter
TwitterClient client = new TwitterClient(_username, _password);
try
{
_following = client.Friends();
//_followers = client.Followers();
client.Close();
}
catch (Exception ex)
{
client.Abort();
throw ex;
}
}
public static void Main(string[] args) {
var receiver = new Receiver<Tweet>();
var twitterClient = new TwitterClient();
var sender = new Sender<TweetStatus>();
receiver.Received += tweet => {
TweetThis(twitterClient, tweet, sender);
};
//receiver.Received += tweet => Console.WriteLine($"{tweet.Message}");
receiver.Receive();
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
receiver.Stop();
}
public void Constructor_WithMockService_IsSetToTwittersAPI()
{
// arrange
var restClient = Substitute.For<IRestClient>();
const string consumerKey = "foo";
const string consumerSecret = "bar";
// act
var client = new TwitterClient(restClient, consumerKey, consumerSecret, "");
//assert
Assert.That(client.OAuthBase == "https://api.twitter.com/oauth/");
Assert.That(client.TokenRequestUrl == "request_token");
Assert.That(client.TokenAuthUrl == "authorize");
Assert.That(client.TokenAccessUrl == "access_token");
Assert.That(client.Authority == "https://api.twitter.com/");
Assert.That(client.Version == "1");
}
public TwitterAccount(TwitterAccountManager mgr)
{
_mgr = mgr;
_oauthClient = new OAuthClient (ConsumerKeyStore.Key, ConsumerKeyStore.Secret, TwitterClient.RequestTokenURL,
TwitterClient.AccessTokenURL, TwitterClient.AuthorizeURL, TwitterClient.XAuthURL);
_client = new TwitterClient (_oauthClient);
_dispatcher = Dispatcher.CurrentDispatcher;
// defaults
SelfUserID = 0;
RestHome = new RestUsage {Interval = TimeSpan.FromSeconds (30), Count = 200};
RestMentions = new RestUsage {Interval = TimeSpan.FromSeconds (600), Count = 20};
RestDirectMessages = new RestUsage {Interval = TimeSpan.FromSeconds (600), Count = 20};
RestList = new TwitterAccount.RestUsage {Interval = TimeSpan.FromSeconds (30), Count = 200};
RestSearch = new TwitterAccount.RestUsage {Interval = TimeSpan.FromSeconds (30), Count = 100};
_restInfoList = new RestUsage[] {RestHome, RestMentions, RestDirectMessages};
_restSinceList = new ulong?[] {null, null, null};
}
internal StatusStore(TwitterClient client)
{
this.client = client;
this.statuses = new Dictionary<StatusId, Status>();
this.statusSeq = new Subject<StatusStoreItem>();
}
private void RefreshWorker_DoWork(object sender, DoWorkEventArgs e)
{
// retrieve id argument
string id = e.Argument as string;
// call twitter api
Statuses tweets = null;
TwitterClient client = new TwitterClient(_username, _password);
try
{
if (string.IsNullOrEmpty(id))
{
tweets = client.Replies();
}
else
{
tweets = client.Replies(id);
}
client.Close();
e.Result = new TweetsResult { Id = id, Tweets = tweets };
}
finally
{
client.Abort();
}
}
/// <summary>
/// クライアントと取得範囲を指定しソースからエントリを取得します。
/// </summary>
/// <param name="client">クライアント。</param>
/// <param name="range">取得範囲。</param>
/// <returns>取得したエントリ。</returns>
protected override IEnumerable<IEntry> GetStatuses(TwitterClient client, StatusRange range)
{
return client.Statuses.RetweetsOfMe(range);
}
void ThreadMain(object state)
{
var auth = (OAuthAuthorization)state;
this.Account = auth.Token;
this.Terminated = false;
try
{
var ub = new UriBuilder(TwitterUriBuilder.Stream.User(this.Track, this.Follows));
var query = string.IsNullOrEmpty(ub.Query) ? null : ub.Query.TrimStart('?');
ub.Query = null;
using (var wc = new CustomWebClient
{
Headers =
{
{ HttpRequestHeader.UserAgent, "Solar/" + Assembly.GetEntryAssembly().GetName().Version },
},
})
using (var ns = wc.OpenPost(ub.Uri, (string.IsNullOrEmpty(query) ? null : query + "&") + auth.CreateParameters("POST", ub.Uri, query)))
using (var sr = new StreamReader(ns))
{
Connected.RaiseEvent(this, EventArgs.Empty);
try
{
foreach (var i in sr.EnumerateLines()
.Where(_ => !string.IsNullOrEmpty(_))
.Select(DynamicJson.Parse))
{
if (IsDelete(i))
{
// delete
if (i.delete.status())
DeleteStatus.RaiseEvent(this, new EventArgs<StatusID>(i.delete.status.id));
}
else if (IsFriends(i))
{
// friends
Friends.RaiseEvent(this, new EventArgs<IList<UserID>>(((dynamic[])i.friends).Select(_ => (UserID)_).Freeze()));
}
else if (IsEvent(i))
{
// event
using (var client = new TwitterClient(auth.Token, StatusCache))
{
var e = new TwitterStreamEventArgs(client, i);
switch (e.Type)
{
case "follow":
if (e.Source.UserID == this.Account.UserID)
Follow.RaiseEvent(this, e);
else
Followed.RaiseEvent(this, e);
break;
case "unfollow":
Unfollow.RaiseEvent(this, e);
break;
case "block":
Block.RaiseEvent(this, e);
break;
case "unblock":
Unblock.RaiseEvent(this, e);
break;
case "favorite":
if (e.Source.UserID == this.Account.UserID)
Favorite.RaiseEvent(this, e);
else
Favorited.RaiseEvent(this, e);
break;
case "unfavorite":
if (e.Source.UserID == this.Account.UserID)
Unfavorite.RaiseEvent(this, e);
else
Unfavorited.RaiseEvent(this, e);
break;
case "retweet":
if (e.Source.UserID == this.Account.UserID)
Retweet.RaiseEvent(this, e);
else
Retweeted.RaiseEvent(this, e);
break;
}
}
}
else if (IsDirectMessage(i))
{
// direct message
using (var client = new TwitterClient(auth.Token, StatusCache))
DirectMessage.RaiseEvent(this, new EventArgs<DirectMessage>(new DirectMessage(client, i.direct_message)));
}
else if (IsStatus(i))
{
// status
using (var client = new TwitterClient(auth.Token, StatusCache))
Status.RaiseEvent(this, new EventArgs<Status>(new Status(client, i)));
}
}
}
finally
{
wc.LastRequest.Abort();
}
}
}
catch (ThreadAbortException)
{
}
catch (WebException ex)
{
WebError.RaiseEvent(this, new EventArgs<WebException>(ContentedWebException.Create(ex)));
}
catch (IOException ex)
{
ConnectionError.RaiseEvent(this, new EventArgs<IOException>(ex));
}
catch (Exception ex)
{
Exception.RaiseEvent(this, new EventArgs<Exception>(ex));
}
finally
{
streamingThread = null;
Disconnected.RaiseEvent(this, EventArgs.Empty);
this.Terminated = true;
}
}
