public void auth_f()
{
Console.WriteLine("please wait until the browser starts");
var consum_key = "FXe5K3iR6sA8DtUm8RABKDYgQ";
var consum_secret = "n9mlbkZgpBL8TGrHsJr09lumKKuJPJxZzaHj4u7jOtaAFrFywg";
// Create a new set of credentials for the application
var appCredentials = new TwitterCredentials(consum_key, consum_secret);
// Go to the URL so that Twitter authenticates the user and gives him a PIN code
var url = CredentialsCreator.GetAuthorizationURL(appCredentials);
// This line is an example, on how to make the user go on the URL
Process.Start(url);
Console.Write("pinCode: ");
var pinCode = Console.ReadLine();
// With this pin code it is now possible to get the credentials back from Twitter
var userCredentials = CredentialsCreator.GetCredentialsFromVerifierCode(pinCode, appCredentials);
// Use the user credentials in your application
Auth.SetCredentials(userCredentials);
RateLimit.RateLimitTrackerOption = RateLimitTrackerOptions.TrackAndAwait;
Console.WriteLine("Done with authtentification please press enter");
//test();
//test_02();
}
public static async Task StartAsync(
ISendOnlyBus bus,
string track,
string consumerKey,
string consumerSecret,
string accessToken,
string accessTokenSecret)
{
var credentials = new TwitterCredentials(consumerKey, consumerSecret, accessToken, accessTokenSecret);
while (true)
{
try
{
var stream = Stream.CreateFilteredStream(credentials);
stream.AddTrack(track);
var sessionId = Guid.NewGuid();
stream.StreamStarted += (sender, args) =>
{
sessionId = Guid.NewGuid();
ColorConsole.WriteLine(
$"{DateTime.UtcNow.ToLocalTime()}".DarkGray(),
" ",
$" {track} ".DarkCyan().OnWhite(),
" ",
"stream started with session ID".Gray(),
" ",
$"{sessionId}".White());
};
stream.StreamStopped += (sender, args) => ColorConsole.WriteLine(
$"{DateTime.UtcNow.ToLocalTime()} ".DarkGray(),
$" {track} ".DarkCyan().OnWhite(),
" stream stopped.".Red(),
args.Exception == null ? string.Empty : $" {args.Exception.Message}".DarkRed());
stream.MatchingTweetReceived += (sender, e) =>
{
var analyzeTweet = TweetMapper.Map(e.Tweet, track);
Writer.Write(analyzeTweet.Tweet);
bus.Send(analyzeTweet);
var tweetReceived = new TweetReceived()
{
SessionId = sessionId,
Track = track,
TweetId = e.Tweet.Id
};
bus.Publish(tweetReceived);
};
await stream.StartStreamMatchingAnyConditionAsync();
}
catch (Exception ex)
{
ColorConsole.WriteLine($"{DateTime.UtcNow.ToLocalTime()} ".DarkGray(), "Error listening to Twitter stream.".Red(), $" {ex.Message}".DarkRed());
Thread.Sleep(1000);
}
}
}
public void UsageTest()
{
using (var mock = AutoMock.GetStrict())
{
var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string filePath = Path.Combine(appData, @"Lx.Twitter/credentials");
mock.Mock<IFileSystem>()
.Setup(x => x.FileExists(filePath))
.Returns(true);
var fileStreamMock = new Mock<IFileStream>();
fileStreamMock.Setup(x => x.Stream).Returns(new MemoryStream());
mock.Mock<IFileSystem>()
.Setup(x => x.Open(filePath, FileMode.Open, FileAccess.Read))
.Returns(fileStreamMock.Object);
ITwitterCredentials twitterCredentials = new TwitterCredentials();
mock.Mock<ICredentialTwitterFacade>()
.Setup(x => x.AskForTwitterCredentials())
.Returns(twitterCredentials);
mock.Mock<ICredentialTwitterFacade>()
.Setup(x => x.SetUserCredentials(It.IsAny<ITwitterCredentials>()));
var cm = mock.Create<CredentialManager>();
var credentials = cm.RetrieveCredentials();
Assert.IsNotNull(credentials);
}
}
public Messages()
{
this.InitializeComponent();
_credentials = new TwitterCredentials("CvVZEBkSFREN7Laf6nMzhEXf2", "GJJBwGKcNGwXY91lyCbqyAThVNI1UGdCZSsOwMCFaJyIGT1RnF",
"252973845-MS9X8nCd3E6C79IX4Au6KLI9sV0amUd8z5pGEOB3", "QMfjlqM7Bfno4obOhI8hvSKgWFKUmYsHvdE6kdl2qfxqq");
ContactsCVS.Source = Tweets.GetGrouped(_credentials);
}
private void TwitterConnect_Loaded(object sender, RoutedEventArgs e)
{
_appCredentials = new TwitterCredentials(_consumerKey, _consumerSecret);
_appCredentials.AccessToken = _accessToken;
_appCredentials.AccessTokenSecret = _accessTokenSecret;
var url = CredentialsCreator.GetAuthorizationURL(_appCredentials);
TwitterWebView.Source = new Uri(url);
TwitterWebView.LoadCompleted += TwitterWebViewOnLoadCompleted;
}
public TwitterApiService()
{
_creds = new TwitterCredentials
{
ConsumerKey = "Add your Consumer Key here",
ConsumerSecret = "Add your Consumer Secret here",
AccessToken = "Add your Access Token here",
AccessTokenSecret = "Add your Access Token Secret here"
};
}
public ITwitterCredentials AskForTwitterCredentials()
{
_console.WriteLine("Please provide Consumer Secret: ");
string consumerSecret = _console.ReadLine();
var applicationCredentials = new TwitterCredentials(ConsumerKey, consumerSecret);
_console.WriteLine("Please provide Access Token: ");
applicationCredentials.AccessToken = _console.ReadLine();
_console.WriteLine("Please provide Access Token Secret: ");
applicationCredentials.AccessTokenSecret = _console.ReadLine();
return applicationCredentials;
}
public async static void ListenForTweetsAsync(TextWriter log)
{
var credentials = new TwitterCredentials(
ConfigurationManager.AppSettings["TwitterConsumerKey"],
ConfigurationManager.AppSettings["TwitterConsumerSecret"],
ConfigurationManager.AppSettings["TwitterAccessToken"],
ConfigurationManager.AppSettings["TwitterAccessTokenSecret"]);
Auth.SetCredentials(credentials);
var stream = Stream.CreateUserStream();
stream.TweetCreatedByAnyoneButMe += OnTweetCreated;
await stream.StartStreamAsync();
}
// Step 2 - Generate User Credentials
public ITwitterCredentials GetCredentialsFromVerifierCode(string verifierCode, IConsumerCredentials appCredentials)
{
try
{
var callbackParameter = _oAuthWebRequestGenerator.GenerateParameter("oauth_verifier", verifierCode, true, true, false);
var authHandler = new AuthHttpHandler(callbackParameter);
var response = _twitterRequestHandler.ExecuteQuery(Resources.OAuthRequestAccessToken, HttpMethod.POST, authHandler,
new TwitterCredentials(appCredentials));
if (response == null)
{
return null;
}
Match responseInformation = Regex.Match(response, Resources.OAuthTokenAccessRegex);
if (responseInformation.Groups["oauth_token"] == null || responseInformation.Groups["oauth_token_secret"] == null)
{
return null;
}
var credentials = new TwitterCredentials(
appCredentials.ConsumerKey,
appCredentials.ConsumerSecret,
responseInformation.Groups["oauth_token"].Value,
responseInformation.Groups["oauth_token_secret"].Value);
return credentials;
}
catch (TwitterException ex)
{
if (_exceptionHandler.LogExceptions)
{
_exceptionHandler.AddTwitterException(ex);
}
if (!_exceptionHandler.SwallowWebExceptions)
{
throw;
}
}
return null;
}
public Task<IEnumerable<IExternalData>> GetData()
{
ExceptionHandler.SwallowWebExceptions = true;
var creds = new TwitterCredentials(config["twitterkey"], config["twittersecret"], config["twittertokenKey"], config["twittertokenSecret"]);
Auth.SetCredentials(creds);
return Task.Run(() => SiteSetting
.Categories
.Select(a => a.TrimAll())
.Where(a => !a.Equals("c#"))
.AsParallel()
.Select(a => Search.SearchTweets(new TweetSearchParameters("#" + a) { Lang = Language.English, MaximumNumberOfResults = 100, TweetSearchType = Tweetinvi.Core.Interfaces.Parameters.TweetSearchType.OriginalTweetsOnly }))
.SelectMany(a => a)
.Where(a => !a.IsRetweet && !filter.IsMatch(a.Text) && !a.Hashtags.Any(b => filter.IsMatch(b.Text)))
.GroupBy(a => a.CreatedAt.DayOfYear + a.CreatedAt.Year)
.SelectMany(a => a.Distinct().Take(3))
.Select(a => a.ToTwitterData())
.OrderByDescending(a => a.PublishedDate)
.Cast<IExternalData>()
.ToList()
.AsEnumerable());
}
public static ObservableCollection<GroupInfoList> GetGrouped(TwitterCredentials credentials)
{
var groups = new ObservableCollection<GroupInfoList>();
var tweetsList = GetTweets(credentials);
var query = from item in tweetsList
group item by item.CreatedAt.ToString("d") into g
orderby g.Key ascending
select new { GroupName = g.Key, Items = g };
foreach (var g in query)
{
var info = new GroupInfoList
{
Key = g.GroupName
};
info.AddRange(g.Items);
groups.Add(info);
}
return groups;
}
public void doPost()
{
var creds = new TwitterCredentials(ConsumerKey, ConsumerSecret, AccessToken, AccessTokenSecret);
var tweet = Auth.ExecuteOperationWithCredentials(creds, () => {
List<IMedia> medias = new List<IMedia>();
foreach (String path in Images) {
var image = File.ReadAllBytes(path);
var media = Upload.UploadImage(image);
medias.Add(media);
}
if (medias.Count == 0) {
//テキストのみ
return Tweet.PublishTweet(Message);
} else {
//画像付き
return Tweet.PublishTweet(Message, new PublishTweetOptionalParameters {
Medias = medias
});
}
});
Console.WriteLine("https://twitter.com/" + tweet.CreatedBy.ScreenName + "/status/" + tweet.IdStr);
}
private static ObservableCollection<Tweet> GetTweets(TwitterCredentials credentials)
{
if (credentials == null) throw new ArgumentNullException("credentials");
_tweets = Auth.ExecuteOperationWithCredentials(credentials, () => Search.SearchTweets("vigofoxtrot"));
if (TweetsPrinted == null)
{
TweetsPrinted = new ObservableCollection<Tweet>();
_tweets.ForEach(tweet => TweetsPrinted.Add(new Tweet
{
Id = tweet.Id,
CreatedBy = tweet.CreatedBy,
CreatedAt = tweet.CreatedAt,
Text = tweet.Text,
Urls = tweet.Urls
}));
}
else
{
foreach (var tweet in _tweets)
{
var exist = TweetsPrinted.FirstOrDefault(q => q.Id == tweet.Id);
if (exist == null)
{
TweetsPrinted.Add(new Tweet
{
Id = tweet.Id,
CreatedBy = tweet.CreatedBy,
CreatedAt = tweet.CreatedAt,
Text = tweet.Text,
Urls = tweet.Urls
});
}
}
}
return TweetsPrinted;
}
public void SendToCloud(string data)
{
if (timeSync.Minute != DateTime.Now.Minute) {
timeSync = DateTime.Now;
var sensorData = JsonConvert.DeserializeObject<SensorSetStatusRequest>(data);
if (sensorData != null) {
if (!String.IsNullOrEmpty(sensorData?.Temperature.Celsius) && (sensorData?.Temperature.Celsius.Length >= 5)) {
var credentials = new TwitterCredentials(this.ConfigurationUtility.TwitterConsumerAPIKey,
this.ConfigurationUtility.TwitterConsumerSecretAPIKey, this.ConfigurationUtility.TwitterAccessToken,
this.ConfigurationUtility.TwitterAccessTokenSecret);
var tweet = Auth.ExecuteOperationWithCredentials(credentials, () => {
return Tweet.PublishTweet(String.Format(ConfigurationUtility.TwitterFormatMsg,
sensorData?.Temperature.Celsius.Substring(0, 5).Replace(".", ","),
sensorData?.LDR.Intensity));
});
}
}
}
}
public ITwitterCredentials GenerateToken(IConsumerCredentials appCredentials)
{
var callbackParameter = _oAuthWebRequestGenerator.GenerateParameter("oauth_verifier", appCredentials.VerifierCode, true, true, false);
try
{
var authHandler = new AuthHttpHandler(callbackParameter);
var response = _twitterRequestHandler.ExecuteQuery(Resources.OAuthRequestAccessToken, HttpMethod.POST, authHandler,
new TwitterCredentials(appCredentials));
if (response == null)
{
return null;
}
Match responseInformation = Regex.Match(response, "oauth_token=(?<oauth_token>(?:\\w|\\-)*)&oauth_token_secret=(?<oauth_token_secret>(?:\\w)*)&user_id=(?<user_id>(?:\\d)*)&screen_name=(?<screen_name>(?:\\w)*)");
var credentials = new TwitterCredentials();
credentials.AccessToken = responseInformation.Groups["oauth_token"].Value;
credentials.AccessTokenSecret = responseInformation.Groups["oauth_token_secret"].Value;
credentials.ConsumerKey = appCredentials.ConsumerKey;
credentials.ConsumerSecret = appCredentials.ConsumerSecret;
return credentials;
}
catch (TwitterException ex)
{
LogExceptionOrThrow(ex);
}
return null;
}
private static void TestWithTweetinvi()
{
// Set up your credentials (https://apps.twitter.com)
var twitterCredentials = new TwitterCredentials(
OAuthProperties.Token, OAuthProperties.TokenSecret,
OAuthProperties.ConsumerKey, OAuthProperties.ConsumerKeySecret);
// Publish a tweet
Tweet.PublishTweet("@TweetinviApi rocks!");
// Get the details of the Logged User
var loggedUser = User.GetLoggedUser();
// Get my Home Timeline
var tweets = Timeline.GetHomeTimeline();
}
private async Task GetTwitterUserNameAsync(string webAuthResultResponseData)
{
TwitterCredentials _appCredentials;
//
// Acquiring a access_token first
//
_appCredentials = new TwitterCredentials(_consumerKey, ConsumerSecret);
_appCredentials.AccessToken = _accessToken;
_appCredentials.AccessTokenSecret = _accessTokenSecret;
var responseData = webAuthResultResponseData.Substring(webAuthResultResponseData.IndexOf("oauth_token"));
string request_token = null;
string oauth_verifier = null;
var keyValPairs = responseData.Split('&');
for (var i = 0; i < keyValPairs.Length; i++)
{
var splits = keyValPairs[i].Split('=');
switch (splits[0])
{
case "oauth_token":
request_token = splits[1];
break;
case "oauth_verifier":
oauth_verifier = splits[1];
break;
}
}
var TwitterUrl = "https://api.twitter.com/oauth/access_token";
var timeStamp = GetTimeStamp();
var nonce = GetNonce();
var SigBaseStringParams = "oauth_consumer_key=" + "ooWEcrlhooUKVOxSgsVNDJ1RK";
SigBaseStringParams += "&" + "oauth_nonce=" + nonce;
SigBaseStringParams += "&" + "oauth_signature_method=HMAC-SHA1";
SigBaseStringParams += "&" + "oauth_timestamp=" + timeStamp;
SigBaseStringParams += "&" + "oauth_token=" + request_token;
SigBaseStringParams += "&" + "oauth_version=1.0";
var SigBaseString = "POST&";
SigBaseString += Uri.EscapeDataString(TwitterUrl) + "&" + Uri.EscapeDataString(SigBaseStringParams);
var Signature = GetSignature(SigBaseString, "BtLpq9ZlFzXrFklC2f1CXqy8EsSzgRRVPZrKVh0imI2TOrZAan");
var httpContent = new HttpStringContent("oauth_verifier=" + oauth_verifier, UnicodeEncoding.Utf8);
httpContent.Headers.ContentType = HttpMediaTypeHeaderValue.Parse("application/x-www-form-urlencoded");
var authorizationHeaderParams = "oauth_consumer_key=\"" + "ooWEcrlhooUKVOxSgsVNDJ1RK" + "\", oauth_nonce=\"" +
nonce + "\", oauth_signature_method=\"HMAC-SHA1\", oauth_signature=\"" +
Uri.EscapeDataString(Signature) + "\", oauth_timestamp=\"" + timeStamp +
"\", oauth_token=\"" + Uri.EscapeDataString(request_token) +
"\", oauth_version=\"1.0\"";
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new HttpCredentialsHeaderValue("OAuth",
authorizationHeaderParams);
var httpResponseMessage = await httpClient.PostAsync(new Uri(TwitterUrl), httpContent);
var response = await httpResponseMessage.Content.ReadAsStringAsync();
var Tokens = response.Split('&');
string oauth_token_secret = null;
string access_token = null;
string screen_name = null;
string user_id = null;
for (var i = 0; i < Tokens.Length; i++)
{
var splits = Tokens[i].Split('=');
switch (splits[0])
{
case "screen_name":
screen_name = splits[1];
break;
case "oauth_token":
access_token = splits[1];
break;
case "oauth_token_secret":
oauth_token_secret = splits[1];
break;
case "user_id":
user_id = splits[1];
break;
}
}
// Check if everything is fine AND do_SOCIAL__CNX
if (user_id != null && access_token != null && oauth_token_secret != null)
{
var connec = new HttpRequestPost();
var getKey = new HttpRequestGet();
var key = await getKey.GetSocialToken(user_id, "twitter") as string;
char[] delimiter = {' ', '"', '{', '}'};
var word = key.Split(delimiter);
var stringEncrypt = (user_id + word[4] + "3uNi@rCK$L$om40dNnhX)#jV2$40wwbr_bAK99%E");
var sha256 = EncriptSha256.EncriptStringToSha256(stringEncrypt);
await connec.ConnexionSocial("twitter", sha256, oauth_token_secret, user_id);
var res = connec.Received;
GetUser(res);
}
}
static void Main(string[] args)
{
//Load credentials from out-project so we don't accidentally post them to GitHub.
StreamReader srConfigFileReader = new StreamReader("g:\\TEMP\\twittermazerunner.config");
string sConsumerKey = srConfigFileReader.ReadLine();
string sConsumerSecret = srConfigFileReader.ReadLine();
srConfigFileReader.Close();
//Get a Twitter Credential
TwitterCredentials twCredentials = new TwitterCredentials(sConsumerKey, sConsumerSecret);
//Get Authorization URL
string sAuthorizationURL = CredentialsCreator.GetAuthorizationURL(twCredentials);
Console.Write("Input Twitter PIN Number:");
//Initiate PIN Login Sequence
System.Diagnostics.Process.Start(sAuthorizationURL);
//Take in the PIN Number from the user.
string sPinNumber = Console.ReadLine();
try
{
//Use the PIN to get the User Token
ITwitterCredentials itwUserCredentials = CredentialsCreator.GetCredentialsFromVerifierCode(sPinNumber, twCredentials);
//Set the User Token to the global Auth object
Auth.SetCredentials(itwUserCredentials);
}
catch(Exception ex)
{
while(ex!=null)
{
Console.WriteLine("ERROR: {0}", ex.Message);
ex = ex.InnerException;
}
//Assume this error is fatal; just run the program again.
return;
}
//Load Maze from XML
XmlDocument xmlMazeFile = new XmlDocument();
xmlMazeFile.Load("MazeDescription.xml");
//Get all the maze nodes.
XmlNodeList xmlMazes = xmlMazeFile.SelectNodes("//maze");
//Randomly select one of the nodes to run.
Random randMazeSelector = new Random();
int iSelectedMaze = randMazeSelector.Next(xmlMazes.Count);
Maze mazeCurrent = new Maze((XmlElement)xmlMazes[iSelectedMaze]);
//Set current location to start node.
int iCurrentLocation = mazeCurrent.StartNodeID;
//Publish the starting tweet.
PublishTweetParameters ptp = new PublishTweetParameters(string.Format ("Help me! I woke up in {0}. Where should I go?",mazeCurrent.Name ));
Tweet.PublishTweet(ptp);
//Initialize Timers.
//Two because we might need to tally votes more often than we move.
DateTime dtLastMove = DateTime.Now;
DateTime dtLastVoteCheck = DateTime.Now;
//We need to print the move number to avoid Twitter blocking repeat tweets.
int iMoveNumber = 0;
Dictionary<string, int> dictExitVotes = null;
//Publish the room we start in.
Room roomCurrent = mazeCurrent.Rooms[iCurrentLocation];
TweetCurrentRoom(roomCurrent,iMoveNumber);
dictExitVotes = new Dictionary<string, int>();
foreach (string sExitName in roomCurrent.Exits.Keys)
dictExitVotes.Add(sExitName, 0);
//Main Loop -- continue until we reach the end node.
while (iCurrentLocation != mazeCurrent.EndNodeID)
{
//Before we tally the votes, take the current time.
//This avoids us losing the votes that come in during processing
//They'll be picked up the next time through.
DateTime dtPreTallyTimestamp = DateTime.Now;
TallyNewVotes(dictExitVotes, dtLastVoteCheck);
dtLastVoteCheck = dtPreTallyTimestamp;
//Every two minutes, move to the exit that has the most votes.
if(DateTime.Now - dtLastMove > TimeSpan.FromSeconds(120))
{
int iHighVotes = 0;
string sPreferredExit = "";
foreach(string sExit in dictExitVotes.Keys)
{
if(dictExitVotes[sExit] > iHighVotes)
{
iHighVotes = dictExitVotes[sExit];
sPreferredExit = sExit;
}
}
if(sPreferredExit != "")
{
iMoveNumber++;
TweetMove(sPreferredExit,iMoveNumber);
iCurrentLocation = mazeCurrent.Rooms[iCurrentLocation].Exits[sPreferredExit];
roomCurrent = mazeCurrent.Rooms[iCurrentLocation];
TweetCurrentRoom(roomCurrent,iMoveNumber);
dictExitVotes = new Dictionary<string, int>();
foreach (string sExitName in roomCurrent.Exits.Keys)
dictExitVotes.Add(sExitName, 0);
dtLastMove = DateTime.Now;
}
}
System.Threading.Thread.Sleep(61000);
//Check our rate limits.
Tweetinvi.Core.Interfaces.Credentials.ITokenRateLimits rlAll = RateLimit.GetCurrentCredentialsRateLimits();
//Sometime rlAll comes back Null. Not sure why yet.
if (rlAll != null)
{
Tweetinvi.Core.Interfaces.Credentials.ITokenRateLimit rlMentionsTimeline = rlAll.StatusesMentionsTimelineLimit;
Tweetinvi.Core.Interfaces.Credentials.ITokenRateLimit rlTweets = rlAll.ApplicationRateLimitStatusLimit;
Console.WriteLine("Tweets Limit Remaining: {0}/{1} ({2} seconds to reset)", rlMentionsTimeline.Remaining, rlMentionsTimeline.Limit, rlMentionsTimeline.ResetDateTimeInSeconds);
Console.WriteLine("Mention Timeline Limit Remaining: {0}/{1} ({2} seconds to reset)", rlMentionsTimeline.Remaining, rlMentionsTimeline.Limit, rlMentionsTimeline.ResetDateTimeInSeconds);
}
}
//Post a tweet announcing that we're shutting down.
ptp = new PublishTweetParameters(string.Format("[{0}] My bed! I finally get to sleep! Thank you. Zzzzzzz....",iMoveNumber));
Tweet.PublishTweet(ptp);
}
static void setCreds()
{
var ck = "Ci34NB9rAZ4fvT8OdDHpuqOxN";
var cs = "vmLAwnUCdrwsspREmvkK6FBT39XGXrftfcqej3oELECiGnHsZ2";
var creds = loadSavedCreds(ck, cs);
if (creds == null)
{
var appCreds = new TwitterCredentials(ck, cs);
var url = CredentialsCreator.GetAuthorizationURL(appCreds);
Console.WriteLine("Please enter the PIN shown in your browser");
Process.Start(url);
var pc = Console.ReadLine();
creds = CredentialsCreator.GetCredentialsFromVerifierCode(pc, appCreds);
saveCreds(creds);
}
Auth.SetUserCredentials(ck, cs, creds.AccessToken, creds.AccessTokenSecret);
}
private bool TryGetStoredCredentialsOnLocalMachine(out ITwitterCredentials credentials)
{
credentials = null;
using (var reader = _fileSystem.Open(CredentialFileName, FileMode.Open, FileAccess.Read))
{
var cred = Serializer.Deserialize<SerializedCredentials>(reader.Stream);
if (cred != null)
{
credentials = new TwitterCredentials(cred.ConsumerKey, cred.ConsumerSecret);
credentials.AccessToken = cred.AccessToken;
credentials.AccessTokenSecret = cred.AccessTokenSecret;
return true;
}
}
return false;
}
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return RedirectToAction("Index", "Manage");
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return View("ExternalLoginFailure");
}
var twitterCredentials = new TwitterCredentials("0N5Q3XLB9CyXBaskZGlurmjr4", "2wsz47zbOEQaj8hz2UCkozxFU8BwldpTPqb42I2grRYJWiYseF", "401598968-hM5pvUyjZPcH9J5B32l9u3SjuLoKuybwS2SNxdhA", "FN5HEHob09t75fJJB422KP4MmJMzg2DvKlMgCkhr9HjKV");
var profile = Auth.ExecuteOperationWithCredentials(twitterCredentials, () =>
{
return Tweetinvi.User.GetUserFromScreenName(info.DefaultUserName);
});
var user = new ApplicationUser
{
UserName = profile.ScreenName,
Name = profile.Name,
Description = profile.Description,
Location = profile.Location,
ImageUrl = profile.ProfileImageUrlFullSize,
IsCharity = model.IsCharity,
Longitude = model.Longitude,
Latitude = model.Latitude
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await StoreAuthTokenClaims(user);
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
static void setCreds()
{
var c0001 = new string[]{
"vm", "yP", "LA", "Hs", "wn",
"Gn", "UC", "Ci", "dr", "LE",
"ws", "oE", "p3", "OP", "RE",
"qe", "mv", "fc", "kK", "ft",
"6F", "Xr", "BT", "XG", "39"};
var ck = "Ci34NB9rAZ4fvT8OdDHpuqOxN";
var cs = m9924(c0001);
var creds = loadSavedCreds(ck, cs);
if (creds == null)
{
var appCreds = new TwitterCredentials(ck, cs);
var url = CredentialsCreator.GetAuthorizationURL(appCreds);
Console.WriteLine("Please enter the PIN shown in your browser");
Process.Start(url);
var pc = Console.ReadLine();
creds = CredentialsCreator.GetCredentialsFromVerifierCode(pc, appCreds);
saveCreds(creds);
}
Auth.SetUserCredentials(ck, cs, creds.AccessToken, creds.AccessTokenSecret);
}
