private static IAuthorizationState GetAuthentication(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. const string STORAGE = "google.analytics.xstat"; const string KEY = "=UwuqAtRaqe-3daV"; // Check if there is a cached refresh token available. IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { CommandLine.WriteError("Using existing refresh token failed: " + ex.Message); } } string[] scopes = new string[] { "https://www.google.com/analytics/feeds/", "https://www.googleapis.com/auth/analytics.readonly" }; // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, scopes); AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); return state; }
private static IAuthorizationState GetAuthorization(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. const string STORAGE = "latitude.client"; const string KEY = "45dfgvq2345"; // Check if there is a cached refresh token available. IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { CommandLine.WriteError("Using existing refresh token failed: " + ex.Message); } } // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, Scope); AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); return state; }
private static IAuthorizationState GetAuthentication(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. const string STORAGE = "google.samples.dotnet.prediction"; const string KEY = "AF41sdBra7ufra)VD:@#A#a++=3e"; string scope = PredictionService.Scopes.Prediction.GetStringValue(); // Check if there is a cached refresh token available. IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { CommandLine.WriteError("Using existing refresh token failed: " + ex.Message); } } // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, scope); AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); return state; }
private static IAuthorizationState GetAuthorization(NativeApplicationClient arg) { // Get the auth URL: IAuthorizationState state = new AuthorizationState(new[] { DriveService.Scopes.Drive.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); if (!String.IsNullOrWhiteSpace(RefreshToken)) { state.RefreshToken = RefreshToken; if (arg.RefreshToken(state)) return state; } return state; }
public static GoogleAuthenticator RefreshAuthenticator(string refreshToken) { var state = new AuthorizationState(_scopes) { RefreshToken = refreshToken }; var client = new NativeApplicationClient(GoogleAuthenticationServer.Description, _clientId, _clientSecret); bool result = client.RefreshToken(state); var auth = new OAuth2Authenticator<NativeApplicationClient>(client, (c) => state); auth.LoadAccessToken(); return new GoogleAuthenticator(auth); }
private static IAuthorizationState GetAuthorization(NativeApplicationClient client) { var storage = MethodBase.GetCurrentMethod().DeclaringType.ToString(); var key = "storage_key"; IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(storage, key); if (state != null) { client.RefreshToken(state); } else { state = AuthorizationMgr.RequestNativeAuthorization(client, YoutubeService.Scopes.Youtube.GetStringValue()); AuthorizationMgr.SetCachedRefreshToken(storage, key, state); } return state; }
private static IAuthorizationState AuthProvider(NativeApplicationClient argTokenProvider) { try { IAuthorizationState state = new AuthorizationState(new[] { AnalyticsService.Scopes.Analytics.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); string refreshToken = LoadRefreshToken(); if (!String.IsNullOrEmpty(refreshToken)) { state.RefreshToken = refreshToken; if (argTokenProvider.RefreshToken(state, null)) return state; } Uri authUri = argTokenProvider.RequestUserAuthorization(state); Process.Start(authUri.ToString()); Console.Write(" authorization Code: "); string authCode = Console.ReadLine(); //4/pBCEKiIoAJCjvZSgKaEw03eO0gdk.ctpr2xLkGjoVgrKXntQAax0QqPmbcwI Console.WriteLine(); // Retrieve the access token by using the authorization code: var result = argTokenProvider.ProcessUserAuthorization(authCode, state); StoreRefreshToken(result); return result; } catch (Exception ex) { throw; } }
private IAuthorizationState GetAuthentication(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. const string STORAGE = "google.musicplayer.dotnet.drive"; const string KEY = "y},drdzf11x9;87"; string scope = DriveService.Scopes.Drive.GetStringValue(); // Check if there is a cached refresh token available. IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { } } // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, scope); AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); return state; }
private static IAuthorizationState GetAuthentication(NativeApplicationClient arg) { // Get the auth URL: IAuthorizationState state = new AuthorizationState(new[] { CalendarService.Scopes.Calendar.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); state.RefreshToken = Settings.Instance.RefreshToken; Uri authUri = arg.RequestUserAuthorization(state); IAuthorizationState result = null; if (state.RefreshToken == "") { // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); EnterAuthorizationCode eac = new EnterAuthorizationCode(); if (eac.ShowDialog() == DialogResult.OK) { // Retrieve the access/refresh tokens by using the authorization code: result = arg.ProcessUserAuthorization(eac.authcode, state); //save the refresh token for future use Settings.Instance.RefreshToken = result.RefreshToken; XMLManager.export(Settings.Instance, MainForm.FILENAME); return result; } else { return null; } } else { arg.RefreshToken(state, null); result = state; return result; } }
private IAuthorizationState getAuthentication(NativeApplicationClient arg) { log.Debug("Authenticating with Google calendar service..."); // Get the auth URLs: IAuthorizationState state = new AuthorizationState(new[] { CalendarService.Scopes.Calendar.GetStringValue(), "https://www.googleapis.com/auth/userinfo.email" }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); state.RefreshToken = Settings.Instance.RefreshToken; Uri authUri = arg.RequestUserAuthorization(state); IAuthorizationState result = null; if (state.RefreshToken == "") { log.Info("No refresh token available - need user authorisation."); // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); frmGoogleAuthorizationCode eac = new frmGoogleAuthorizationCode(); if (eac.ShowDialog() == DialogResult.OK) { if (string.IsNullOrEmpty(eac.authcode)) log.Debug("User continued but did not provide a code! This isn't going to work..."); else log.Debug("User has provided authentication code."); // Retrieve the access/refresh tokens by using the authorization code: result = arg.ProcessUserAuthorization(eac.authcode, state); //save the refresh token for future use Settings.Instance.RefreshToken = result.RefreshToken; Settings.Instance.Save(); log.Info("Refresh and Access token successfully retrieved."); getGaccountEmail(result.AccessToken, true); } else { log.Info("User declined to provide authorisation code. Sync will not be able to work."); String noAuth = "Sorry, but this application will not work if you don't give it access to your Google Calendar :("; MessageBox.Show(noAuth, "Authorisation not given", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); throw new System.ApplicationException(noAuth); } } else { try { arg.RefreshToken(state, null); if (string.IsNullOrEmpty(state.AccessToken)) log.Error("Failed to retrieve Access token."); else log.Debug("Access token refreshed - expires " + ((DateTime)state.AccessTokenExpirationUtc).ToLocalTime().ToString()); } catch (System.Exception ex) { log.Error(ex.GetType().ToString() + " " + ex.Message); log.Error(ex.StackTrace); MainForm.Instance.Logboxout("Failed to obtain Calendar access from Google - it's possible your access has been revoked." + "\r\nTry disconnecting your Google account and reauthenticating."); } result = state; getGaccountEmail(result.AccessToken, false); } return result; }
private static IAuthorizationState GetAuthentication(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. LoadStorageKey(); // Check if there is a cached refresh token available. IAuthorizationState state = GetCachedRefreshToken(Storage, Key); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase); if (!File.Exists(path.Replace("file:\\", "") + "\\tokenrefreshlog.xml")) { System.IO.File.AppendAllText(path.Replace("file:\\", "") + "\\tokenrefreshlog.xml", "<logs></logs>"); } else { try { XmlDocument xmldoc = new XmlDocument(); xmldoc.Load(path.Replace("file:\\", "") + "\\tokenrefreshlog.xml"); XmlElement root = xmldoc["logs"]; if (root != null) { XmlElement log = xmldoc.CreateElement("log"); XmlAttribute att = xmldoc.CreateAttribute("datetime"); att.Value = SyncManager.ExecutingDate.ToString("dd.MM.yyyy HH:mm:ss"); log.InnerText = ex.Message; root.AppendChild(log); xmldoc.Save(path.Replace("file:\\", "") + "\\tokenrefreshlog.xml"); } } catch { } } //CommandLine.WriteError("Using existing refresh token failed: " + ex.Message); state = null; } } return state; string[] scopes = new string[] { "https://www.google.com/analytics/feeds/", "https://www.googleapis.com/auth/analytics.readonly" }; // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, scopes); SetCachedRefreshToken(Storage, Key, state); return state; }
/// <summary> /// Method to get the authorization from the user to access their Google Drive from the application /// </summary> /// <param name="client"></param> /// <returns></returns> private static IAuthorizationState GetAuthorization(NativeApplicationClient client) { // You should use a more secure way of storing the key here as // .NET applications can be disassembled using a reflection tool. const string KEY = "z},drdzf11x9;87"; string scope = DriveService.Scopes.Drive.GetStringValue(); // Check if there is a cached refresh token available. IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); if (state != null) { try { client.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { Debug.WriteLine("Using existing refresh token failed: " + ex.Message); } } // If we get here, there is no stored token. Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(client, scope); AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); return state; }
private static IAuthorizationState googledrive_getauthorization(NativeApplicationClient client) { string[] scopes = new string[1] { "" }; IAuthorizationState state = new AuthorizationState(scopes) { RefreshToken = configurations.googledrive_refresh_token }; if (state != null) { client.RefreshToken(state); } return state; }
private static IAuthorizationState GetAuthorization(NativeApplicationClient arg) { IAuthorizationState state = new AuthorizationState(new[] { CalendarService.Scopes.Calendar.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); string path = "auth.txt"; if (File.Exists(path)) { state.RefreshToken = File.ReadAllText(path); arg.RefreshToken(state); //state = arg.ProcessUserAuthorization(state.AccessToken, state); } else { Uri authUri = arg.RequestUserAuthorization(state); // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); Console.Write(" Authorization Code: "); string authCode = string.Empty; int count = 0; while (string.IsNullOrEmpty(authCode) && count < 500) { foreach (Process proc in Process.GetProcesses()) { if (proc.MainWindowTitle.StartsWith("Success code=")) { authCode = proc.MainWindowTitle.Split('=').Last().Split(' ').First(); } } Thread.Sleep(50); Application.DoEvents(); count++; } Console.WriteLine(); // Retrieve the access token by using the authorization code: state = arg.ProcessUserAuthorization(authCode, state); } File.WriteAllText(path, state.RefreshToken); return state; }
private IAuthorizationState GetAuthorization(NativeApplicationClient arg) { // Get the auth URL: IAuthorizationState state = new AuthorizationState(new[] { DriveService.Scopes.Drive.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); IAuthorizationState result = null; string refreshToken = LoadRefreshToken(); if (!String.IsNullOrEmpty(refreshToken)) { state.RefreshToken = refreshToken; if (arg.RefreshToken(state)) return state; } frmAuthorizationCode ac = new frmAuthorizationCode(); Uri authUri = arg.RequestUserAuthorization(state); // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); if (ac.ShowDialog() == DialogResult.OK) { result = arg.ProcessUserAuthorization(ac.txtAC.Text, state); StoreRefreshToken(state); } return result; }
private static IAuthorizationState GetAuthorization(NativeApplicationClient arg) { // Get the auth URL: IAuthorizationState state = new AuthorizationState( new[] { Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryUser.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryUserAlias.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryOrgunit.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryGroupMember.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryDeviceChromeos.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryDeviceMobile.GetStringValue(), Google.Apis.Admin.Directory.directory_v1.DirectoryService.Scopes.AdminDirectoryDeviceMobileAction.GetStringValue(), GroupssettingsService.Scopes.AppsGroupsSettings.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); if (!String.IsNullOrWhiteSpace(_refreshToken)) { state.RefreshToken = _refreshToken; if (arg.RefreshToken(state)) return state; } var authUri = arg.RequestUserAuthorization(state); // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); Console.Write(" Authorization Code: "); var authCode = Console.ReadLine(); Console.WriteLine(); // Retrieve the access token by using the authorization code: var result = arg.ProcessUserAuthorization(authCode, state); Console.WriteLine("Refresh Token: " + result.RefreshToken); return result; }
private IAuthorizationState GetAuthorization(NativeApplicationClient arg) { // Check if there is a cached refresh token available. String[] scopes = new String[] { "https://www.googleapis.com/auth/drive", "https://docs.google.com/feeds", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile" }; //const string STORAGE = "eCubeDMS"; //const string KEY = "4/BgrfOgMaqaH6duTF-ZK7yBeoxiYn.8tlx19KH7tAeXE-sT2ZLcbQJoY-TdAI"; //IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(STORAGE, KEY); IAuthorizationState state = AuthorizationMgr.GetCachedRefreshToken(ConnectionString); if (state != null) { try { arg.RefreshToken(state); return state; // Yes - we are done. } catch (DotNetOpenAuth.Messaging.ProtocolException ex) { throw new Exception("Using existing refresh token failed: " + ex.Message); } } // Retrieve the authorization from the user. state = AuthorizationMgr.RequestNativeAuthorization(arg, scopes); //AuthorizationMgr.SetCachedRefreshToken(STORAGE, KEY, state); AuthorizationMgr.SetCachedRefreshToken(state, ConnectionString); return state; }
private IAuthorizationState GetAuthorization(NativeApplicationClient appClient) { var state = new AuthorizationState(new[] {"https://www.googleapis.com/auth/drive"}) {Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl), RefreshToken = mRefreshToken.Token}; appClient.RefreshToken(state); return state; }
private static IAuthorizationState getAuthentication(NativeApplicationClient arg) { log.Debug("Authenticating with Google calendar service..."); // Get the auth URL: IAuthorizationState state = new AuthorizationState(new[] { CalendarService.Scopes.Calendar.GetStringValue() }); state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl); state.RefreshToken = Settings.Instance.RefreshToken; Uri authUri = arg.RequestUserAuthorization(state); IAuthorizationState result = null; if (state.RefreshToken == "") { log.Info("No refresh token available - need user authorisation."); // Request authorization from the user (by opening a browser window): Process.Start(authUri.ToString()); frmGoogleAuthorizationCode eac = new frmGoogleAuthorizationCode(); if (eac.ShowDialog() == DialogResult.OK) { if (string.IsNullOrEmpty(eac.authcode)) log.Debug("User continued but did not provide a code! This isn't going to work..."); else log.Debug("User has provided authentication code."); // Retrieve the access/refresh tokens by using the authorization code: result = arg.ProcessUserAuthorization(eac.authcode, state); //save the refresh token for future use Settings.Instance.RefreshToken = result.RefreshToken; Settings.Instance.Save(); log.Info("Refresh and Access token successfully retrieved."); return result; } else { log.Info("User declined to provide authorisation code. Sync will not be able to work."); String noAuth = "Sorry, but this application will not work if you don't give it access to your Google Calendar :("; MessageBox.Show(noAuth, "Authorisation not given", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); throw new System.ApplicationException(noAuth); } } else { arg.RefreshToken(state, null); if (string.IsNullOrEmpty(state.AccessToken)) log.Error("Failed to retrieve Access token."); else log.Debug("Access token refreshed - expires " + ((DateTime)state.AccessTokenExpirationUtc).ToLocalTime().ToString()); result = state; return result; } }