protected override TransientCredentials Login() { TransientCredentials tc = base.Login(); VerifyAndRefreshCredentials(tc); return(tc); }
private void VerifyAndRefreshCredentials(TransientCredentials tc) { var userCredential = tc.Token as UserCredential; var token = userCredential?.Token; if (IsValidToken(token)) { // We already have a valid OAuth token. return; } if (userCredential == null) { // Attempt to load a cached OAuth token. var flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer { ClientSecretsStream = ClientSecretsStream, DataStore = GetCredentialsDataStoreForBlog(tc.Username), Scopes = GoogleAPIScopes, }); var loadTokenTask = flow.LoadTokenAsync(tc.Username, CancellationToken.None); loadTokenTask.Wait(); if (loadTokenTask.IsCompleted) { // We were able re-create the user credentials from the cache. userCredential = new UserCredential(flow, tc.Username, loadTokenTask.Result); token = loadTokenTask.Result; } } if (!IsValidToken(token)) { // The token is invalid, so we need to login again. This likely includes popping out a new browser window. if (BlogClientUIContext.SilentModeForCurrentThread) { // If we're in silent mode where prompting isn't allowed, throw the verification exception throw new BlogClientAuthenticationException(String.Empty, String.Empty); } // Start an OAuth flow to renew the credentials. var authorizationTask = GetOAuth2AuthorizationAsync(tc.Username, CancellationToken.None); authorizationTask.Wait(); if (authorizationTask.IsCompleted) { userCredential = authorizationTask.Result; token = userCredential?.Token; } } if (!IsValidToken(token)) { // The token is still invalid after all of our attempts to refresh it. The user did not complete the // authorization flow, so we interpret that as a cancellation. throw new BlogClientOperationCancelledException(); } // Stash the valid user credentials. tc.Token = userCredential; }
private void RefreshAccessToken(TransientCredentials transientCredentials) { // Using the BloggerService automatically refreshes the access token, but we call the Picasa endpoint // directly and therefore need to force refresh the access token on occasion. var userCredential = transientCredentials.Token as UserCredential; userCredential?.RefreshTokenAsync(CancellationToken.None).Wait(); }
protected override void VerifyCredentials(TransientCredentials tc) { // This sucks. We really want to authenticate against the actual feed, // not just the service document. Uri uri = FeedServiceUrl; xmlRestRequestHelper.Get(ref uri, RequestFilter); }
private BloggerService GetService() { TransientCredentials transientCredentials = Login(); return(new BloggerService(new BaseClientService.Initializer() { HttpClientInitializer = (UserCredential)transientCredentials.Token, ApplicationName = string.Format(CultureInfo.InvariantCulture, "{0} {1}", ApplicationEnvironment.ProductName, ApplicationEnvironment.ProductVersion), })); }
public override void DeletePost(string blogId, string postId, bool publish) { TransientCredentials tc = Login(); XmlNode result = CallMethod("blogger.deletePost", new XmlRpcString(APP_KEY), new XmlRpcString(postId), new XmlRpcString(tc.Username), new XmlRpcString(tc.Password, true), new XmlRpcBoolean(publish)); }
public static GDataCredentials FromCredentials(TransientCredentials credentials) { GDataCredentials cred = credentials.Token as GDataCredentials; if (cred == null) { credentials.Token = cred = new GDataCredentials(); } return(cred); }
private HttpCredentialsProvider GetHttpCredentialsProvider() { TransientCredentials tc = Credentials.TransientCredentials as TransientCredentials; if (tc != null) { HttpCredentialsProvider credentialsProvider = tc.Token as HttpCredentialsProvider; return(credentialsProvider); } return(null); }
private void PostNewImage(string albumName, string filename, out string srcUrl, out string editUri) { TransientCredentials transientCredentials = Credentials.TransientCredentials as TransientCredentials; GDataCredentials.FromCredentials(transientCredentials).EnsureLoggedIn(transientCredentials.Username, transientCredentials.Password, GDataCredentials.PICASAWEB_SERVICE_NAME, false); string albumUrl = GetBlogImagesAlbum(albumName); HttpWebResponse response = RedirectHelper.GetResponse(albumUrl, new RedirectHelper.RequestFactory(new UploadFileRequestFactory(this, filename, "POST").Create)); using (Stream s = response.GetResponseStream()) ParseMediaEntry(s, out srcUrl, out editUri); }
private async Task RefreshAccessToken(TransientCredentials transientCredentials) { // Using the BloggerService automatically refreshes the access token, but we call the Picasa endpoint // directly and therefore need to force refresh the access token on occasion. var userCredential = transientCredentials.Token as UserCredential; var refreshTokenAsync = userCredential?.RefreshTokenAsync(CancellationToken.None); if (refreshTokenAsync != null) { await refreshTokenAsync; } }
private void VerifyAndRefreshCredentials(TransientCredentials tc) { GDataCredentials gc = GDataCredentials.FromCredentials(tc); if (gc.IsValid(tc.Username, tc.Password, GDataCredentials.BLOGGER_SERVICE_NAME)) return; else { bool showUI = !BlogClientUIContext.SilentModeForCurrentThread; gc.EnsureLoggedIn(tc.Username, tc.Password, GDataCredentials.BLOGGER_SERVICE_NAME, showUI); return; } }
private void InitTransientCredential(TransientCredentials tc) { HttpCredentialsProvider credentialsProvider = new HttpCredentialsProvider(UrlHelper.SafeToAbsoluteUri(_postApiUrl), Credentials, tc.Username, tc.Password); tc.Token = credentialsProvider; bool useMetaweblogCredentials = credentialsProvider.GetAuthenticationScheme() == AuthenticationScheme.MetaWeblog; string username = useMetaweblogCredentials ? Credentials.Username : ""; string password = useMetaweblogCredentials ? Credentials.Password : ""; tc.Username = username; tc.Password = password; }
protected virtual HttpRequestFilter CreateCredentialsFilter(string requestUri) { TransientCredentials tc = Login(); if (tc != null) { return(HttpRequestCredentialsFilter.Create(tc.Username, tc.Password, requestUri, true)); } else { return(null); } }
private bool AuthorizeRequest(HttpWebRequest request, string serviceName) { // This line is required to avoid Error 500 from non-beta Blogger blogs. // According to Pete Hopkins it is "something with .NET". request.Accept = "*/*"; TransientCredentials transientCredentials = Login(); GDataCredentials cred = GDataCredentials.FromCredentials(transientCredentials); return(cred.AttachCredentialsIfValid( request, transientCredentials.Username, transientCredentials.Password, serviceName)); }
private void VerifyAndRefreshCredentials(TransientCredentials tc) { GDataCredentials gc = GDataCredentials.FromCredentials(tc); if (gc.IsValid(tc.Username, tc.Password, GDataCredentials.BLOGGER_SERVICE_NAME)) { return; } else { // bool showUI = !BlogClientUIContext.SilentModeForCurrentThread; //gc.EnsureLoggedIn(tc.Username, tc.Password, GDataCredentials.BLOGGER_SERVICE_NAME, showUI); return; } }
public static bool VerifyCredentialsAndDetectAuthScheme(IBlogCredentials blogCredentials, SharePointClient client) { //Attempt to execute the GetUsersBlogs() operation using standard HTTP authentication //If the server challenges with an HTTP 401, but doesn't include with WWW-authentication //header, then the server is configured to use MetaWeblog for authentication, so we //re-issue the request using that authentication scheme instead. AuthenticationScheme authScheme = AuthenticationScheme.Http; AuthenticationScheme requiredAuthScheme = AuthenticationScheme.Unknown; while (requiredAuthScheme == AuthenticationScheme.Unknown || authScheme != requiredAuthScheme) { if (requiredAuthScheme != AuthenticationScheme.Unknown) { authScheme = requiredAuthScheme; } blogCredentials.SetCustomValue(AUTH_SCHEME, authScheme.ToString()); try { TransientCredentials tc = new TransientCredentials(blogCredentials.Username, blogCredentials.Password, null); client.Credentials.TransientCredentials = tc; client.InitTransientCredential(tc); client.GetUsersBlogs(); return(true); } catch (WebException e) { requiredAuthScheme = GetRequiredAuthScheme(e); } catch (BlogClientHttpErrorException e) { requiredAuthScheme = GetRequiredAuthScheme(e.Exception); } catch (BlogClientAuthenticationException e) { requiredAuthScheme = GetRequiredAuthScheme(e.WebException); } catch (Exception) { throw; } Debug.Assert(requiredAuthScheme != AuthenticationScheme.Unknown, "Unexpected authscheme"); //this would cause an infinite loop! } return(false); }
protected override void VerifyCredentials(TransientCredentials tc) { try { GetUsersBlogs(tc.Username, tc.Password); return; } catch (BlogClientAuthenticationException) { throw; } catch (Exception e) { if (!BlogClientUIContext.SilentModeForCurrentThread) ShowError(e.Message); throw; } }
protected override async Task VerifyCredentials(TransientCredentials tc) { try { await GetUsersBlogs(tc.Username, tc.Password); return; } catch (BlogClientAuthenticationException) { throw; } catch (Exception e) { //if(!BlogClientUIContext.SilentModeForCurrentThread) // ShowError(e.Message); throw; } }
public bool Login(string username, string password) { using (new WaitCursor()) { try { _username = username; _password = password; TransientCredentials creds = new TransientCredentials(username, password, null); _credentials = GDataCredentials.FromCredentials(creds); _credentials.EnsureLoggedIn(username, password, GDataCredentials.YOUTUBE_SERVICE_NAME, true, GDataCredentials.YOUTUBE_CLIENT_LOGIN_URL); } catch (Exception) { _credentials = null; } } OnLoginStatusChanged(); return(IsLoggedIn); }
protected override void VerifyCredentials(TransientCredentials tc) { InitTransientCredential(tc); base.VerifyCredentials(tc); }
protected override void VerifyCredentials(TransientCredentials tc) { VerifyAndRefreshCredentials(tc); }
protected virtual async Task <HttpAsyncRequestFilter> CreateCredentialsFilter(string requestUri) { TransientCredentials tc = await Login(); return(HttpRequestCredentialsFilter.Create(tc.Username, tc.Password, requestUri, true)); }
public static bool VerifyCredentialsAndDetectAuthScheme(IBlogCredentials blogCredentials, SharePointClient client) { //Attempt to execute the GetUsersBlogs() operation using standard HTTP authentication //If the server challenges with an HTTP 401, but doesn't include with WWW-authentication //header, then the server is configured to use MetaWeblog for authentication, so we //re-issue the request using that authentication scheme instead. AuthenticationScheme authScheme = AuthenticationScheme.Http; AuthenticationScheme requiredAuthScheme = AuthenticationScheme.Unknown; while (requiredAuthScheme == AuthenticationScheme.Unknown || authScheme != requiredAuthScheme) { if (requiredAuthScheme != AuthenticationScheme.Unknown) authScheme = requiredAuthScheme; blogCredentials.SetCustomValue(AUTH_SCHEME, authScheme.ToString()); try { TransientCredentials tc = new TransientCredentials(blogCredentials.Username, blogCredentials.Password, null); client.Credentials.TransientCredentials = tc; client.InitTransientCredential(tc); client.GetUsersBlogs(); return true; } catch (WebException e) { requiredAuthScheme = GetRequiredAuthScheme(e); } catch (BlogClientHttpErrorException e) { requiredAuthScheme = GetRequiredAuthScheme(e.Exception); } catch (BlogClientAuthenticationException e) { requiredAuthScheme = GetRequiredAuthScheme(e.WebException); } catch (Exception) { throw; } Debug.Assert(requiredAuthScheme != AuthenticationScheme.Unknown, "Unexpected authscheme"); //this would cause an infinite loop! } return false; }
protected override void VerifyCredentials(TransientCredentials transientCredentials) { }
private void VerifyAndRefreshCredentials(TransientCredentials tc) { var userCredential = tc.Token as UserCredential; var token = userCredential?.Token; if (IsValidToken(token)) { // We already have a valid OAuth token. return; } if (userCredential == null) { // Attempt to load a cached OAuth token. var flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer { ClientSecretsStream = ClientSecretsStream, DataStore = GetCredentialsDataStoreForBlog(tc.Username), Scopes = new List<string>() { BloggerServiceScope, PicasaServiceScope }, }); var loadTokenTask = flow.LoadTokenAsync(tc.Username, CancellationToken.None); loadTokenTask.Wait(); if (loadTokenTask.IsCompleted) { // We were able re-create the user credentials from the cache. userCredential = new UserCredential(flow, tc.Username, loadTokenTask.Result); token = loadTokenTask.Result; } } if (!IsValidToken(token)) { // The token is invalid, so we need to login again. This likely includes popping out a new browser window. if (BlogClientUIContext.SilentModeForCurrentThread) { // If we're in silent mode where prompting isn't allowed, throw the verification exception throw new BlogClientAuthenticationException(String.Empty, String.Empty); } // Start an OAuth flow to renew the credentials. var authorizationTask = GetOAuth2AuthorizationAsync(tc.Username, CancellationToken.None); authorizationTask.Wait(); if (authorizationTask.IsCompleted) { userCredential = authorizationTask.Result; token = userCredential?.Token; } } if (!IsValidToken(token)) { // The token is still invalid after all of our attempts to refresh it. The user did not complete the // authorization flow, so we interpret that as a cancellation. throw new BlogClientOperationCancelledException(); } // Stash the valid user credentials. tc.Token = userCredential; }
public static GDataCredentials FromCredentials(TransientCredentials credentials) { GDataCredentials cred = credentials.Token as GDataCredentials; if (cred == null) { credentials.Token = cred = new GDataCredentials(); } return cred; }
public override BlogInfo[] GetUsersBlogs() { TransientCredentials tc = Login(); return(GetUsersBlogs(tc.Username, tc.Password)); }
protected override Task VerifyCredentials(TransientCredentials tc) { return(VerifyAndRefreshCredentials(tc)); }
//private void ShowError(string error) //{ // ShowErrorHelper helper = // new ShowErrorHelper(BlogClientUIContext.ContextForCurrentThread, MessageId.UnexpectedErrorLogin, // new object[] {error}); // if (BlogClientUIContext.ContextForCurrentThread != null) // BlogClientUIContext.ContextForCurrentThread.Invoke(new ThreadStart(helper.Show), null); // else // helper.Show(); //} //private class ShowErrorHelper //{ // private readonly IWin32Window _owner; // private readonly MessageId _messageId; // private readonly object[] _args; // public ShowErrorHelper(IWin32Window owner, MessageId messageId, object[] args) // { // _owner = owner; // _messageId = messageId; // _args = args; // } // public void Show() // { // DisplayMessage.Show(_messageId, _owner, _args); // } //} public override async Task <BlogInfo[]> GetUsersBlogsAsync() { TransientCredentials tc = await Login(); return(await GetUsersBlogs(tc.Username, tc.Password)); }