// This URL is registered as the application's callback under Twitter's DEV API
public ActionResult TwitterSignInCallback(string oauth_token, string oauth_verifier)
{
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
// Exchange the Request Token for an Access Token
TwitterService twitterService = new TwitterService(OAuthAPIKey, OAuthAPISecret);
OAuthAccessToken accessToken = twitterService.GetAccessToken(requestToken, oauth_verifier);
// User authenticates using the Access Token
twitterService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
TwitterUser user = twitterService.VerifyCredentials(new VerifyCredentialsOptions()
{
});
bool successfulLogin = user != null;
FormsAuthentication.SetAuthCookie(user.ScreenName, false);
if (successfulLogin)
{
return(RedirectToAction("Index", "Home", new { userName = user.ScreenName }));
}
return(RedirectToAction("Index", "Home"));
}
public void Login(String username, String password)
{
Uri uri = service.GetAuthorizationUri(requestToken);
CookieContainer cookieContainer = new CookieContainer();
String response = HttpUtil.GetResponseString(uri, cookieContainer);
int startIndex = response.IndexOf("authenticity_token\" type=\"hidden\" value=\"") + 41;
int endIndex = response.IndexOf("\"", startIndex + 1);
String authenticity_token = response.Substring(startIndex, endIndex - startIndex);
startIndex = response.IndexOf("name=\"oauth_token\" type=\"hidden\" value=\"") + 40;
endIndex = response.IndexOf("\"", startIndex + 1);
String oauth_token = response.Substring(startIndex, endIndex - startIndex);
String postData = "authenticity_token=" + authenticity_token +
"&oauth_token=" + oauth_token +
"&session%5Busername_or_email%5D=" + username +
"&session%5Bpassword%5D=" + password;
response = HttpUtil.GetResponseString(new Uri("https://api.twitter.com/oauth/authorize"), postData, cookieContainer);
if (response.Contains("Invalid user name or password"))
{
return;
}
startIndex = response.IndexOf("<code>") + 6;
endIndex = response.IndexOf("</code>");
String pin = response.Substring(startIndex, endIndex - startIndex);
OAuthAccessToken access = service.GetAccessToken(requestToken, pin);
service.AuthenticateWith(access.Token, access.TokenSecret);
}
public OAuthAccessToken getAccessTokens(UserContext userContext)
{
oAuthAccessTokenManagementService = new OAuthAccessTokenManagementServiceService();
string soapServer = CurrentValues.Instance.YodleeSoapServer;
oAuthAccessTokenManagementService.Url = soapServer + "/OAuthAccessTokenManagementService_11_1";
long?applicationId = (long)CurrentValues.Instance.YodleeBridgetApplicationId;
try
{
OAuthAccessToken authAccessToken = oAuthAccessTokenManagementService.getOAuthAccessToken(userContext, applicationId, true);
if (authAccessToken != null && authAccessToken.token != null && authAccessToken.tokenSecret != null)
{
log.InfoFormat("Successfully received access token. Access Token:{0}. Access Token Secret:{1}. Token Creation Time:{2}",
authAccessToken.token, authAccessToken.tokenSecret, authAccessToken.tokenCreationTime);
return(authAccessToken);
}
log.ErrorFormat("Received null access token. authAccessToken:{0} authAccessToken.token:{1} authAccessToken.tokenSecret:{2}",
authAccessToken == null ? "null" : authAccessToken.ToString(),
authAccessToken == null || authAccessToken.token == null ? "null" : authAccessToken.token,
authAccessToken == null || authAccessToken.tokenSecret == null ? "null" : authAccessToken.tokenSecret);
}
catch (Exception e)
{
log.ErrorFormat("Exception while getting access token. Maybe the application id is invalid. Application id:{0} Exception:{1}", applicationId, e);
}
return(null);
}
private void DownloadLocker(string username, OAuthAccessToken userAuthenticationDetails)
{
var lockerStats = _lockerRetrieval.GetLockerStats(userAuthenticationDetails);
var lockerReleases = _lockerRetrieval.GetLockerReleases(userAuthenticationDetails, lockerStats);
SetLockerCacheItems(username, lockerReleases, lockerStats);
}
private void GetToken()
{
access = service.GetAccessToken(requestToken, verifier);
AccessToken = access.Token;
AccessTokenSecret = access.TokenSecret;
service.AuthenticateWith(access.Token, access.TokenSecret);
}
public ActionResult TwitterCallback(string oauth_token, string oauth_verifier)
{
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
string key = "W7nisP4ZK14FeeTu5sn5Q9z3c";
string secret = "F2kQSgBgFceir7B3UD0RODZSOvi7QDUdyU1quHh664cbxXhB9T";
try
{
TwitterService service = new TwitterService(key, secret);
OAuthAccessToken accessToken = service.GetAccessToken(requestToken, oauth_verifier);
service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
VerifyCredentialsOptions option = new VerifyCredentialsOptions();
TwitterUser user = service.VerifyCredentials(option);
TempData["Name"] = user.Name;
TempData["userpic"] = user.ProfileImageUrl;
return(View());
}
catch (System.Exception)
{
throw;
}
}
public void ProcessRequest(HttpContext context)
{
//get parameters
string oauth_token = context.Request.Params["oauth_token"];
string oauth_verifier = context.Request.Params["oauth_verifier"];
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
// Step 3 - Exchange the Request Token for an Access Token
Global.TwitterService = new TwitterService(Global.TwitterConsumerKey, Global.TwitterConsumerSecret);
OAuthAccessToken accessToken = Global.TwitterService.GetAccessToken(requestToken, oauth_verifier);
// Step 4 - User authenticates using the Access Token
Global.TwitterService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
TwitterUser user = Global.TwitterService.VerifyCredentials(new VerifyCredentialsOptions());
//var sessionProps = (SessionProperties) context.Session["sessionProps"];
//sessionProps.TwitterAccessToken = accessToken.Token;
//sessionProps.TwitterAccessTokenSecret = accessToken.TokenSecret;
Parameters.Instance.TwitterAccessToken = accessToken.Token;
Parameters.Instance.TwitterAccessTokenSecret = accessToken.TokenSecret;
//service.SendTweet(new SendTweetOptions(){Status = "Testing twitter function. Carrry on"});
context.Response.Redirect("../AdminMain.aspx");
}
public void GetTweetsMentioningMe_ShouldReturnTweetsWithMentions()
{
List <TwitterStatus> twitterStatuses = Builder <TwitterStatus>
.CreateListOfSize(2)
.WhereAll()
.Have(ts => ts.User = Builder <TwitterUser> .CreateNew().Build())
.Build()
.ToList();
OAuthAccessToken accessToken = new OAuthAccessToken {
Token = "abcd", TokenSecret = "A@c#"
};
Mock.Get(_mockTwitterService).Setup(mockService => mockService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret));
Mock.Get(_mockTwitterService).Setup(mockService => mockService.ListTweetsMentioningMe()).Returns(
twitterStatuses);
GetTweetResponse response = _authenticationService.GetTweetsMentioningMe(accessToken);
Mock.Get(_mockTwitterService).VerifyAll();
Assert.IsNotNull(response);
Assert.AreEqual(2, response.TweeterStatuses.Count());
}
/// <summary>
/// Load page with query string of Flickr and get logged user
/// </summary>
protected void Page_Load(object sender, EventArgs e)
{
try
{
// Verify if query string contains authentication values
if (Request.QueryString["oauth_verifier"] != null && Session["RequestToken"] != null)
{
Flickr flickr = FlickrManager.GetInstance();
OAuthRequestToken requestToken = Session["RequestToken"] as OAuthRequestToken;
try
{
OAuthAccessToken accessToken = flickr.OAuthGetAccessToken(requestToken, Request.QueryString["oauth_verifier"]);
FlickrManager.OAuthToken = accessToken;
}
catch (OAuthException)
{
Debug.Write("[ERROR] - Error to get Flickr access token.");
}
}
// Verify if not post back
if (!Page.IsPostBack)
{
SetLogged();
}
}
catch (System.Exception)
{
ScriptManager.RegisterClientScriptBlock(this.Page, this.Page.GetType(), "alert", "alert('Ocorreu um erro ao carregar as fotos.');", true);
}
}
void LoadPreference(string key)
{
switch (key)
{
case SCALE_KEY:
scale_check.Active = Preferences.Get <bool> (key);
break;
case SIZE_KEY:
size_spin.Value = (double)Preferences.Get <int> (key);
break;
case BROWSER_KEY:
open_check.Active = Preferences.Get <bool> (key);
break;
case TAGS_KEY:
tag_check.Active = Preferences.Get <bool> (key);
break;
case TAG_HIERARCHY_KEY:
hierarchy_check.Active = Preferences.Get <bool> (key);
break;
case IGNORE_TOP_LEVEL_KEY:
ignore_top_level_check.Active = Preferences.Get <bool> (key);
break;
case FlickrRemote.TOKEN_FLICKR:
case FlickrRemote.TOKEN_23HQ:
case FlickrRemote.TOKEN_ZOOOMR:
token = new OAuthAccessToken();
token.Token = Preferences.Get <string> (key);
token.TokenSecret = Preferences.Get <string> (key + "secret");
token.UserId = Preferences.Get <string> (key + "userId");
token.Username = Preferences.Get <string> (key + "userName");
break;
case PUBLIC_KEY:
public_radio.Active = Preferences.Get <bool> (key);
break;
case FAMILY_KEY:
family_check.Active = Preferences.Get <bool> (key);
break;
case FRIENDS_KEY:
friend_check.Active = Preferences.Get <bool> (key);
break;
/*
* case Preferences.EXPORT_FLICKR_EMAIL:
*
* /*
* case Preferences.EXPORT_FLICKR_EMAIL:
* email_entry.Text = (string) val;
* break;
*/
}
}
public void GetTweetsSince_ShouldReturnTweetsSinceTweetId()
{
List <TwitterStatus> twitterStatuses = Builder <TwitterStatus>
.CreateListOfSize(2)
.WhereAll()
.Have(ts => ts.User = Builder <TwitterUser> .CreateNew().Build())
.Build()
.ToList();
OAuthAccessToken accessToken = new OAuthAccessToken {
Token = "abcd", TokenSecret = "A@c#"
};
Mock.Get(_mockTwitterService).Setup(mockService => mockService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret));
Mock.Get(_mockTwitterService).Setup(mockService => mockService.ListTweetsOnHomeTimelineSince(100)).Returns(
twitterStatuses);
GetTweetsRequest getTweetsRequest = new GetTweetsRequest {
AccessToken = accessToken, LastTweetId = 100
};
GetTweetResponse response = _authenticationService.GetTweetsSince(getTweetsRequest);
Mock.Get(_mockTwitterService).VerifyAll();
Assert.IsNotNull(response);
Assert.AreEqual(2, response.TweeterStatuses.Count());
}
public bool FlickrAuthenticate()
{
Logger.Debug("Authenticating...");
if (OAuthToken?.Token == null)
{
ConsoleHelper.WriteInfoLine("Requesting access token...");
var flickr = GetInstance();
OAuthRequestToken requestToken = flickr.OAuthGetRequestToken("oob");
var url = flickr.OAuthCalculateAuthorizationUrl(requestToken.Token, AuthLevel.Write);
Process.Start(url);
ConsoleHelper.WriteInfo("Verifier: ");
var verifier = Console.ReadLine();
OAuthToken = flickr.OAuthGetAccessToken(requestToken, verifier);
}
if (OAuthToken == null)
{
Logger.Error("Could not authenticate.");
return(true);
}
Logger.Info("Authenticated as " + OAuthToken.FullName + ".");
Uploader.UserId = OAuthToken.UserId;
Uploader.Flickr = GetAuthInstance();
return(false);
}
public IHttpActionResult TwitterCallback(string oauth_token, string oauth_verifier)
{
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
string Key = "jvy2ZXkqWH6KAPzycTtoMnzgA";
string Secret = "ApD4fROU3DM8tzdfytZFJOkrQfq0H1Ga6i6yOFH0hXpCgbtntR";
try
{
TwitterService service = new TwitterService(Key, Secret);
//get Access tocken
OAuthAccessToken accessToken = service.GetAccessToken(requestToken, oauth_verifier);
service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
//for getting user Profile
var profile = service.GetUserProfile(new GetUserProfileOptions {
IncludeEntities = true
});
VerifyCredentialsOptions option = new VerifyCredentialsOptions();
TwitterUser user = service.VerifyCredentials(option);
//TempData["Name"] = user.Name;
//TempData["Userpic"] = user.ProfileImageUrl;
//string u= user.Name;
//return Ok();
//return Redirect("http://localhost:4200"+u);
return(Redirect("http://localhost:4200"));
}
catch
{
throw;
}
}
public IHttpActionResult TwitterCallbackFunc(OAuthData oAuth_Data)
{
var requestToken = new OAuthRequestToken {
Token = oAuth_Data.oauth_token
};
string Key = "I4ObconJp84KE97TpZLxmtfOz";
string Secret = "fuYsBswujZu438WDWVNFvGoj45oszq7YfnKjclX7spqxmNdZB9";
try
{
TwitterService service = new TwitterService(Key, Secret);
//Get Access Tokens
OAuthAccessToken accessToken =
service.GetAccessToken(requestToken, oAuth_Data.oauth_verifier);
service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
VerifyCredentialsOptions option = new VerifyCredentialsOptions();
//According to Access Tokens get user profile details
TwitterUser user = service.VerifyCredentials(option);
//return View();
//return RedirectToAction("Index", "Home");
//Redirect("~/Index.html");
return(Ok(user));
}
catch
{
throw;
}
}
static void Main(string[] args)
{
OAuthAccessToken accessToken = new OAuthAccessToken();
accessToken.AccessToken = "Test LGTM Dotnet Core 3.0";
Console.WriteLine(accessToken.AccessToken);
}
private async void PageRootLoaded(object sender, RoutedEventArgs e)
{
if (AccessToken != null)
{
return;
}
var f = new Flickr("dbc316af64fb77dae9140de64262da0a", "0781969a058a2745");
var requestToken = await GetRequestToken();
string output;
var flickrUri = new Uri(f.OAuthCalculateAuthorizationUrl(requestToken.Token, AuthLevel.Delete));
var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(
WebAuthenticationOptions.None,
flickrUri);
if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
{
output = webAuthenticationResult.ResponseData;
AccessToken = await f.OAuthAccessTokenAsync(requestToken.Token, requestToken.TokenSecret, output);
LoadDataSource(AccessToken);
}
else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
{
output = "HTTP Error returned by AuthenticateAsync() : " + webAuthenticationResult.ResponseErrorDetail.ToString();
}
else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.UserCancel)
{
output = "Authentication process was cancelled by the user";
}
}
private async void LoadDataSource(OAuthAccessToken accessToken)
{
var f = new Flickr("dbc316af64fb77dae9140de64262da0a", "0781969a058a2745")
{
OAuthAccessToken = accessToken.Token,
OAuthAccessTokenSecret = accessToken.TokenSecret
};
var groups = DefaultViewModel["Groups"] as ObservableCollection <SampleDataGroup>;
groups.Clear();
var photostreamGroup = new SampleDataGroup("A", "Your Photos", "Photostream", "", "");
groups.Add(photostreamGroup);
var contactsGroup = new SampleDataGroup("A", "Your Contact", "Latest Updates", "", "");
groups.Add(contactsGroup);
var favouritesGroup = new SampleDataGroup("A", "Your Favourites", "Favourite Photos", "", "");
groups.Add(favouritesGroup);
var photos = await f.PeopleGetPhotosAsync(accessToken.UserId, SafetyLevel.None, null, null, null, null,
ContentTypeSearch.None, PrivacyFilter.None,
PhotoSearchExtras.Description | PhotoSearchExtras.LargeUrl, 1,
30);
foreach (
var photo in
photos.Select(
p => new SampleDataItem(p.PhotoId, p.Title, "", p.LargeUrl, p.Description, p.Description, photostreamGroup))
)
{
photostreamGroup.Items.Add(photo);
}
photos =
await f.PhotosGetContactsPhotosAsync(extras : PhotoSearchExtras.Description | PhotoSearchExtras.LargeUrl | PhotoSearchExtras.OwnerName);
foreach (
var photo in
photos.Select(
p => new SampleDataItem(p.PhotoId, p.Title, p.OwnerName, p.LargeUrl, p.Description, p.Description, contactsGroup))
)
{
contactsGroup.Items.Add(photo);
}
photos = await f.FavoritesGetListAsync(extras : PhotoSearchExtras.Description | PhotoSearchExtras.LargeUrl | PhotoSearchExtras.OwnerName);
foreach (
var photo in
photos.Select(
p => new SampleDataItem(p.PhotoId, p.Title, p.OwnerName, p.LargeUrl, p.Description, p.Description, favouritesGroup))
)
{
favouritesGroup.Items.Add(photo);
}
}
public bool ValidateToken(string txt)
{
if (String.IsNullOrEmpty(txt))
{
MessageBox.Show("You must paste the verifier code into the textbox above.");
return(false);
}
Flickr f = Managers.Instance.flicker.flickr;
try
{
accessToken = f.OAuthGetAccessToken(requestToken, txt);
f.OAuthAccessToken = accessToken.Token;
Managers.Instance.user.UserName = accessToken.FullName;
Managers.Instance.user.Token = accessToken.Token;
Managers.Instance.user.Connected = true;
MessageBox.Show("Successfully authenticated as " + accessToken.FullName);
Managers.Instance.cache.LoadFavorite();
}
catch (FlickrApiException ex)
{
MessageBox.Show("Failed to get access token. Error message: " + ex.Message);
return(false);
}
return(true);
}
public async Task <OAuthAccessToken> RefreshToken(OAuthAccessToken token)
{
var response = await _httpClient.Client.PostAsync(AuthCompleteEndpoint, new FormUrlEncodedContent(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "refresh_token"),
new KeyValuePair <string, string>("refresh_token", token.RefreshToken),
new KeyValuePair <string, string>("client_id", _appId),
new KeyValuePair <string, string>("client_secret", _clientSecret)
}));
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
throw new UnauthorizedAccessException($"Was not allowed to refresh token");
}
throw new Exception("Could not refresh token");
}
var jsonStr = await response.Content.ReadAsStringAsync();
var newToken = JsonConvert.DeserializeObject <OAuthAccessToken>(jsonStr);
return(newToken);
}
/// <summary>
/// Fetch some user info and update this on to the UI
/// </summary>
/// <param name="accessToken"></param>
private void GetUserInfo(OAuthAccessToken accessToken)
{
try
{
service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
GetUserProfileOptions userInfo = new GetUserProfileOptions()
{
IncludeEntities = true,
SkipStatus = false
};
var result = service.BeginGetUserProfile(userInfo);
var user = service.EndGetUserProfile(result);
var imgUrlString = user.ProfileImageUrlHttps;
if (imgUrlString.Contains("normal", StringComparison.OrdinalIgnoreCase))
{
// To get a bigger image. Refer to https://developer.twitter.com/en/docs/accounts-and-users/user-profile-images-and-banners
imgUrlString = imgUrlString.Replace("normal", "bigger", StringComparison.OrdinalIgnoreCase);
}
twitterUserInfo = new TwitterUserInfo();
twitterUserInfo.Id = user.Id.ToString();
twitterUserInfo.Screen_name = user.ScreenName;
twitterUserInfo.profileImage = imgUrlString;
this.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void SendTweet_ShouldUpdateTheUserStatus_AndReturnNewTweeterStatusTest()
{
OAuthAccessToken accessToken = new OAuthAccessToken {
Token = "abcd", TokenSecret = "A@c#"
};
Mock.Get(_mockTwitterService).Setup(mockService => mockService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret));
SendTweetRequest request = new SendTweetRequest {
AccessToken = accessToken, Status = "Hello World"
};
TwitterStatus twitterStatusStatus =
Builder <TwitterStatus>
.CreateNew()
.With(x => x.Text = request.Status)
.With(x => x.User = Builder <TwitterUser> .CreateNew().Build())
.Build();
Mock.Get(_mockTwitterService).Setup(mockService => mockService.SendTweet(request.Status)).Returns(twitterStatusStatus);
SendTweetResponse sendTweetResponse = _authenticationService.SendTweet(request);
Assert.IsNotNull(sendTweetResponse);
Assert.AreSame(request.Status, sendTweetResponse.TweeterStatus.Tweet);
}
protected void Page_Load(object sender, EventArgs e)
{
// The request token is stored in session - if it isn't present then we do nothing
if (Request.QueryString["oauth_verifier"] != null && Session["RequestToken"] != null)
{
Flickr f = FlickrManager.GetInstance();
OAuthRequestToken requestToken = Session["RequestToken"] as OAuthRequestToken;
try
{
OAuthAccessToken accessToken = f.OAuthGetAccessToken(requestToken,
Request.QueryString["oauth_verifier"]);
FlickrManager.OAuthToken = accessToken;
ResultsLabel.Text = "You successfully authenticated as " + accessToken.FullName;
ResultPanel.CssClass = "alert alert-success";
ResultPanel.Visible = true;
}
catch (OAuthException ex)
{
ResultsLabel.Text = "An error occurred retrieving the token : " + ex.Message;
ResultPanel.CssClass = "alert alert-danger";
ResultPanel.Visible = true;
}
}
}
public async Task <IActionResult> AuthorizeAsync(string appId, string code, string returnUrl)
{
if (string.IsNullOrWhiteSpace(code) || string.IsNullOrWhiteSpace(returnUrl))
{
return(NotFound());
}
string secret = ConfigCenterClient.GetSection("WeChatAccount").GetValue <string>(appId, null);
if (secret == null)
{
return(NotFound());
}
OAuthAccessToken accessTokenResponse = await GetAccessTokenAsync(appId, secret, code);
OAuthUserInfo userInfo = new OAuthUserInfo
{
OpenId = accessTokenResponse?.OpenId
};
if (accessTokenResponse != null && accessTokenResponse.Scope.Contains("snsapi_userinfo"))
{
userInfo = await GetUserInfoAsync(accessTokenResponse.AccessToken, accessTokenResponse.AccessToken);
}
returnUrl = HttpUtility.UrlDecode(returnUrl);
string userInfoParams = accessTokenResponse.Scope.Contains("snsapi_userinfo") ? $"nickname={ HttpUtility.UrlEncode(userInfo.Nickname) }&headimgurl={ HttpUtility.UrlEncode(userInfo.HeadImgUrl) }" : string.Empty;
return(Redirect($"{ returnUrl }{ (returnUrl.Contains("?") ? "&" : "?") }openId={ userInfo.OpenId }&{ userInfoParams }"));
}
/// <summary>
/// 成功登陆
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void webBrowser1_Navigated(object sender, WebBrowserNavigatedEventArgs e)
{
if (webBrowser1.DocumentText.IndexOf("oauth_verifier") > -1)
{
//取得OauthVerify
int startIndex = webBrowser1.DocumentText.IndexOf("oauth_verifier");
int endIndex = webBrowser1.DocumentText.IndexOf('\"', startIndex);
string verifier = webBrowser1.DocumentText.Substring(startIndex + 15, endIndex - startIndex - 15);
OAuthAccessToken accessToken = twitterService.GetAccessToken(requestToken, verifier);
if (accessToken != null)
{
twitterService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
ButtonStateNext |= WizardButtonState.Enabled;
ParentWizardForm.UpdateWizardForm(this);
}
else
{
ButtonStateNext = WizardButtonState.Visible;
}
}
else
{
ButtonStateNext = WizardButtonState.Visible;
}
}
public void Can_make_xauth_request()
{
TwitterService service = new TwitterService(_consumerKey, _consumerSecret);
OAuthAccessToken access = service.GetAccessTokenWithXAuth("username", "password");
Assert.Ignore("Test account isn't authorized for xAuth");
}
private async Task <OAuthAccessToken> WaitAndThenRefreshAsync(
OAuthAccessToken token,
CancellationToken cancellationToken,
Func <OAuthAccessToken, Task <OAuthAccessToken> > refreshToken)
{
var auditItem = _refreshAudit.CreateAuditEntry(token);
await WaitForRefreshTimeAsync(token, cancellationToken, auditItem);
if (!cancellationToken.IsCancellationRequested)
{
_refreshAudit.RefreshStarted(auditItem);
OAuthAccessToken newToken = await TryRefreshUntilCancelledOrSuccess(
auditItem,
token,
cancellationToken,
refreshToken);
_refreshAudit.RefreshEnded(auditItem);
return(newToken);
}
return(null);
}
/// <summary>
/// Confirm pin input
/// </summary>
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
// Step 3 - Exchange the Request Token for an Access Token
string verifier = txtPin.Text; // <-- This is input into your application by your user
OAuthAccessToken access = service.GetAccessToken(requestToken, verifier);
// Step 4 - User authenticates using the Access Token
service.AuthenticateWith(access.Token, access.TokenSecret);
// Save tokens to file for faster login the next time
using (XmlWriter writer = XmlWriter.Create(ConfigurationManager.AppSettings["LoginDataFile"]))
{
writer.WriteStartDocument();
writer.WriteStartElement("logindata");
writer.WriteStartElement("token");
writer.WriteString(access.Token);
writer.WriteEndElement();
writer.WriteStartElement("tokenSecret");
writer.WriteString(access.TokenSecret);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
}
MoveToMain();
}
void Logout()
{
token = null;
fr = new FlickrRemote(token, current_service);
Preferences.Set(current_service.PreferencePath, string.Empty);
CurrentState = State.Disconnected;
}
/// <summary>
/// 创建菜单
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnCreate_Click(object sender, EventArgs e)
{
string userName = lbPublicAccount.SelectedValue;
MenuContainer mc1 = MenuHelper.CreateContainer("自在饭");
mc1.Add(MenuHelper.CreateItem(MenuTypeEnum.click, "关于", "about"));
mc1.Add(MenuHelper.CreateItem(MenuTypeEnum.view, "官网", "http://www.zizaifan.com"));
mc1.Add(MenuHelper.CreateItem(MenuTypeEnum.location_select, "方位", "location"));
mc1.Add(MenuHelper.CreateItem(MenuTypeEnum.view, "网页授权", OAuthAccessToken.GetOAuthUrl(userName, "http://www.zizaifan.com/OAuth.aspx", OAuthScopeEnum.snsapi_userinfo, "oauth")));
MenuContainer mc2 = MenuHelper.CreateContainer("扫描");
mc2.Add(MenuHelper.CreateItem(MenuTypeEnum.scancode_push, "扫码推", "push"));
mc2.Add(MenuHelper.CreateItem(MenuTypeEnum.scancode_waitmsg, "接收扫码", "waitmsg"));
MenuContainer mc3 = MenuHelper.CreateContainer("发图");
mc3.Add(MenuHelper.CreateItem(MenuTypeEnum.pic_sysphoto, "拍照发图", "sysphoto"));
mc3.Add(MenuHelper.CreateItem(MenuTypeEnum.pic_photo_or_album, "拍照或相册发图", "photo_or_album"));
mc3.Add(MenuHelper.CreateItem(MenuTypeEnum.pic_weixin, "微信发图", "weixin"));
mc3.Add(MenuHelper.CreateItem(MenuTypeEnum.view, "JS-SDK", "http://www.zizaifan.com/wechat.aspx"));
ErrorMessage errorMessage = MenuHelper.Create(userName, new BaseMenu[] { mc1, mc2, mc3 });
ltrMessage.Text = string.Format("创建菜单{0}。{1}",
errorMessage.IsSuccess ? "成功" : "失败",
errorMessage.IsSuccess ? "" : errorMessage.ToString());
}
public CDB(string apiKey, string sharedSecret, OAuthAccessToken aToken)
{
APIKey = apiKey;
SharedSecret = sharedSecret;
Token = aToken.Token;
TokenSecret = aToken.TokenSecret;
}
public void LoadTweetsFromTimeline_ShouldSetBusyIndicatorAndMakeAServiceCall()
{
OAuthAccessToken accessToken = new OAuthAccessToken();
Mock.Get(_mockApplicationSettingsProvider)
.SetupGet(m => m["accessToken"])
.Returns(accessToken);
Mock.Get(_mockAuthenticationService)
.Setup(m => m.BeginGetTweetsMentioningMe(accessToken, It.IsAny<AsyncCallback>(), null));
_viewModel.GetTweetsMentioningMe();
Assert.IsTrue(_viewModel.IsBusy);
Mock.Get(_mockAuthenticationService).VerifyAll();
}
public void OnTweetActionCommand_ShouldCallServiceTest()
{
viewModel.TweetText = "Hello World";
OAuthAccessToken accessToken = new OAuthAccessToken();
Mock.Get(_mockApplicationSettingsProvider)
.SetupGet(m => m["accessToken"])
.Returns(accessToken);
Mock.Get(_mockAuthenticationService).Setup(
m => m.BeginSendTweet(
It.Is<SendTweetRequest>(request => request.AccessToken == accessToken && request.Status == "Hello World"),
It.IsAny<AsyncCallback>(),
null));
viewModel.OnTweetActionCommand();
Assert.IsTrue(viewModel.IsBusy);
Mock.Get(_mockAuthenticationService).VerifyAll();
}
public void LoadTweetsFromTimeline_WhenThereAreExistingTweets_ShouldSetBusyIndicator_AndMakeAServiceCall_UsingLastTweetIdTest()
{
ObservableCollection<NGTweeterStatus> tweeterStatuses = new ObservableCollection<NGTweeterStatus>
{
new NGTweeterStatus
{
Id = 1001,
CreatedDate = new DateTime(2011, 06, 10),
Tweet = "Hello",
User =
new NGTweeterUser
{
Id = 101,
Name = "Nilesh",
ScreenName = "Nileshgule",
ProfileImageUrl = "http://twitter.com/profileImages/nileshgule.jpg"
}
}
};
_viewModel.AddNewTweets(tweeterStatuses);
Assert.AreEqual(1, _viewModel.TweeterStatusViewModels.Count);
OAuthAccessToken accessToken = new OAuthAccessToken();
Mock.Get(_mockApplicationSettingsProvider)
.SetupGet(m => m["accessToken"])
.Returns(accessToken);
Mock.Get(_mockAuthenticationService).Setup(
m => m.BeginGetTweetsSince(
It.Is<GetTweetsRequest>(request => request.AccessToken == accessToken && request.LastTweetId == 1001),
It.IsAny<AsyncCallback>(),
null));
_viewModel.LoadTweetsFromTimeLine();
Assert.IsTrue(_viewModel.IsBusy);
Mock.Get(_mockAuthenticationService).VerifyAll();
Mock.Get(_mockApplicationSettingsProvider).VerifyAll();
}
private void HandleAuthenticationAccessToken(OAuthAccessToken token, TwitterResponse response)
{
_accessToken = token;
Dispatcher.BeginInvoke(
()=>
{
_browser.Visibility = Visibility.Visible;
_tweets.Visibility = Visibility.Collapsed;
}
);
ServiceExample();
}
