public static async Task<GoogleDrive> CreateInstance(Account account, string id, ClientSecrets secrets, string rootPath, string credentialPath, CancellationToken token) { var ret = new GoogleDrive(account, id, secrets, credentialPath); var rootFolder = await ret.GetFolderByPathAsync(rootPath, token, true); ret.rootFolder = rootFolder; return ret; }
async public void Authorize() { var secrets = new ClientSecrets { ClientId = "285737664603-8l6kprl3ahtanud9o8jqb7il4mckiegh.apps.googleusercontent.com", ClientSecret = "xtyxhDwzKRkzDZOHcME3WMtU" }; var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(secrets, new[] { DriveService.Scope.Drive }, "user", CancellationToken.None); var service = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "Bloop Drive Plugin" }); var files = service.Files.List().Execute(); }
public new static async Task<UserCredential> AuthorizeAsync(ClientSecrets clientSecrets, IEnumerable<string> scopes, string user, CancellationToken taskCancellationToken, IDataStore dataStore = null) { var initializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = clientSecrets, }; return await AuthorizeAsyncCore(initializer, scopes, user, taskCancellationToken, dataStore) .ConfigureAwait(false); }
public BloggerManager(string clientId, string clientSec, string appName) { _csAppSec = new ClientSecrets { ClientId = clientId, ClientSecret = clientSec }; _fdsStore = new FileDataStore(appName); _strAppName = appName; }
public static UserCredential createCredential(ClientSecrets cs, FileDataStore fds) { UserCredential uc = GoogleWebAuthorizationBroker.AuthorizeAsync( cs, new[] { BloggerService.Scope.Blogger }, "user", CancellationToken.None, fds ).Result; return uc; }
/// <summary>Asynchronously authorizes the specified user.</summary> /// <remarks> /// It uses <seealso cref="Google.Apis.Util.Store.StroageDataStore"/> as the flow's data store by default. /// </remarks> /// <param name="clientSecrets">The client secrets URI.</param> /// <param name="scopes"> /// The scopes which indicate the Google API access your application is requesting. /// </param> /// <param name="user">The user to authorize.</param> /// <param name="taskCancellationToken">Cancellation token to cancel an operation.</param> /// <returns>User credential.</returns> private static async Task<UserCredential> AuthorizeAsync(ClientSecrets clientSecrets, IEnumerable<string> scopes, string user, CancellationToken taskCancellationToken) { var initializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = clientSecrets, Scopes = scopes, DataStore = new StroageDataStore() }; var installedApp = new AuthorizationCodeWinRTInstalledApp(initializer); return await installedApp.AuthorizeAsync(user, taskCancellationToken).ConfigureAwait(false); }
public ActionResult Show(string token, string email, string name) { UserCredential credential; var listOfEvents = new List<EventViewModel>(); var json = JsonParser(); ClientSecrets cs = new ClientSecrets() { ClientId = json["installed"]["client_id"].ToString(), ClientSecret = json["installed"]["client_secret"].ToString() }; credential = GoogleWebAuthorizationBroker.AuthorizeAsync(cs, Scopes, "user", CancellationToken.None).Result; credential.Token.AccessToken = token; // Create Google Calendar API service. var service = new CalendarService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = ApplicationName, }); // Define parameters of request. EventsResource.ListRequest request = service.Events.List("primary"); request.TimeMin = DateTime.Now; request.ShowDeleted = false; request.SingleEvents = true; request.MaxResults = 10; request.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime; // List events. Events events = request.Execute(); if (events.Items != null && events.Items.Count > 0) { foreach (var eventItem in events.Items) { var eventName = (string.IsNullOrEmpty(eventItem.Summary)) ? "No Title" : eventItem.Summary; var userEvent = new EventViewModel(eventName, eventItem.Start.DateTime, eventItem.End.DateTime); listOfEvents.Add(userEvent); } } ViewData["Events"] = listOfEvents; ViewData["Email"] = email; ViewData["Name"] = name; return View(); }
private async Task<GDriveContext> RequireContext(RootName root, string apiKey = null) { if (root == null) throw new ArgumentNullException(nameof(root)); var result = default(GDriveContext); if (!contextCache.TryGetValue(root, out result)) { var clientSecret = new ClientSecrets() { ClientId = Secrets.CLIENT_ID, ClientSecret = Secrets.CLIENT_SECRET }; var credentials = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecret, new[] { DriveService.Scope.Drive }, root.UserName, System.Threading.CancellationToken.None); var service = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = credentials, ApplicationName = "GDrvTest" }); contextCache.Add(root, result = new GDriveContext(service)); } return result; }
public IConfigurableHttpClientInitializer GetInstalledApplicationCredentials() { var secrets = new ClientSecrets { // Replace these values with your own to use Installed // Application Credentials. // Pass --askForCredentials on the command line. // See https://developers.google.com/identity/protocols/OAuth2#installed ClientId = "YOUR_CLIENT_ID.apps.googleusercontent.com", ClientSecret = "YOUR_CLIENT_SECRET" }; return GoogleWebAuthorizationBroker.AuthorizeAsync( secrets, new[] { StorageService.Scope.DevstorageFullControl }, Environment.UserName, new CancellationTokenSource().Token) .Result; }
public async Task<Stream> method() { var clientSecrets = new ClientSecrets { ClientId = "1000234763615-sqj7a7rh11vkrqr5p77oplv00lrvki6l.apps.googleusercontent.com", ClientSecret = "uPnqOcWiM2cFPaE1UxYCdh4E" }; var scope = new[] { DriveService.Scope.Drive }; var user = "******"; var cancellationToken = CancellationToken.None; var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecrets, scope, user, cancellationToken, new FileDataStore("bin")); var service = new DriveService(new BaseClientService.Initializer { HttpClientInitializer = credential, }); return await service.Files.List().ExecuteAsStreamAsync(); }
private UserCredential CreateCredential() { ClientSecrets clientSecrets = new ClientSecrets() { ClientId = config.GmailClientId, ClientSecret = config.GmailApiClientSecret }; UserCredential credential; credential = GoogleWebAuthorizationBroker.AuthorizeAsync( clientSecrets, Scopes, config.NotificationAccount, CancellationToken.None, new EFDataStore()).Result; return credential; }
private void _download_Click(object sender, EventArgs e) { try { ClientSecrets cs = new ClientSecrets(); cs.ClientId = "728822159738-252ghnvc1l1kjssq0d6dtrf2h2t48ihp.apps.googleusercontent.com"; cs.ClientSecret = "lO67xySyeUClGRYmwQ1LIyee"; UserCredential uc = GoogleWebAuthorizationBroker.AuthorizeAsync(cs, new string[] { Google.Apis.Coordinate.v1.CoordinateService.Scope.Coordinate }, "user", System.Threading.CancellationToken.None, new FileDataStore("Timelines.MyLibrary")).Result; var coordinateService = new CoordinateService(new BaseClientService.Initializer { HttpClientInitializer = uc, ApplicationName = "Google maps timeline downloader" }); // ここからどうすんだ? /* Google.Apis.Http.ConfigurableHttpClient http = coordinateService.HttpClient; DateTime target = dateTimePicker1.Value; string targetUrl = string.Format("https://www.google.com/maps/timeline/kml?authuser=0&pb=!1m8!1m3!1i{0}!2i{1}!3i{2}!2m3!1i{0}!2i{1}!3i{2}", target.Year, target.Month - 1, target.Day); System.Net.Http.HttpResponseMessage res = http.SendAsync(new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, targetUrl)).Result; string result = res.Content.ReadAsStringAsync().Result; System.Diagnostics.Debug.Print(result); */ } catch (Exception ex) { System.Diagnostics.Debug.Print(ex.Message); throw; } }
public string Main() { string result = ""; CalendarService calendarConnection; ClientSecrets secrets = new ClientSecrets { ClientId = "473177441662-h57ba7mlrtkcgkb15ivd4srfjb4fdps8.apps.googleusercontent.com", ClientSecret = "thRD95BupH7H1UZaqoZUHFk3", }; try { result = "we starting "; UserCredential credential = GoogleWebAuthorizationBroker.AuthorizeAsync( secrets, new string[] { CalendarService.Scope.Calendar }, "user", CancellationToken.None) .Result; result = "we pass 1 thing "; var initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "Jassplan"; calendarConnection = new CalendarService(initializer); result = "we are here after calendar connection"; } catch (Exception ex) { result = result + ex.Message; } return result; }
private static OAuth2Parameters CreateOAuth2Parameters (ClientSecrets clientSecrets, UserCredential credential) { return new OAuth2Parameters { ClientId = clientSecrets.ClientId, ClientSecret = clientSecrets.ClientSecret, AccessToken = credential.Token.AccessToken, RefreshToken = credential.Token.RefreshToken }; }
public object RefreshOauth() { var CLIENT_ID = "570313910467-h8raudku9n9n65118tqndopih9breo53.apps.googleusercontent.com"; var CLIENT_SECRET = "T8vlM82EEb82IAtDSaey-Oet"; ClientSecrets secrets = new ClientSecrets { ClientId = CLIENT_ID, ClientSecret = CLIENT_SECRET }; TokenResponse token = new TokenResponse { AccessToken = "sfd", RefreshToken = "1/RcTEm-ZKEtBZzS2jOVLONQcmhtEpRZ7r2zny2HjWtMY" }; IAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = secrets, Scopes = new string[] { DriveService.Scope.Drive } }); UserCredential credential = new UserCredential(flow, "me", token); bool success = credential.RefreshTokenAsync(CancellationToken.None).Result; token = credential.Token; string access = token.AccessToken; var dbCtx = new CompassDBEntities(); var oauthVal = new DriveOauth(); oauthVal.Id = 1; var DriveAuth = dbCtx.DriveOauths.Find(oauthVal.Id); DriveAuth.AccessToken = token.AccessToken; DriveAuth.ExpireTime = token.ExpiresInSeconds.ToString(); DriveAuth.IssueTime = token.Issued.ToString(); dbCtx.SaveChanges(); return token; }
private async Task CheckGmail() { UserCredential credential; ClientSecrets secrets = new ClientSecrets(); secrets.ClientId = ClientId; secrets.ClientSecret = ClientSecret; credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(secrets, new[] { GmailService.Scope.GmailReadonly }, "user", CancellationToken.None); var service = new GmailService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "Gmail Notifier", }); while (true) { try { var response = service.Users.Labels.Get("me", "INBOX").Execute(); if (response.MessagesUnread > 0) { TrayIcon.Icon = GmailNotifier.Properties.Resources.UnreadGmail32; if (response.MessagesUnread == 1) { TrayIcon.Text = "Du har ett oläst meddelande!"; } else { TrayIcon.Text = String.Format("Du har {0} olästa meddelanden!", response.MessagesUnread); } TrayIcon.Visible = true; var unreadMessages = service.Users.Messages.List("me"); unreadMessages.LabelIds = new[] { "INBOX", "UNREAD" }; var inbox = unreadMessages.Execute(); foreach (Google.Apis.Gmail.v1.Data.Message message in inbox.Messages) { if (!UnreadMessagesNotifications.ContainsKey(message.Id)) { var mess = service.Users.Messages.Get("me", message.Id).Execute(); var subject = mess.Payload.Headers.Where(x => x.Name == "Subject").FirstOrDefault(); TrayIcon.ShowBalloonTip(3000, subject.Value, mess.Snippet, ToolTipIcon.Info); TrayIcon.Icon = GmailNotifier.Properties.Resources.NewGmail32; UnreadMessagesNotifications.Add(message.Id, message); System.Threading.Thread.Sleep(5000); } } TrayIcon.Icon = GmailNotifier.Properties.Resources.UnreadGmail32; } else { TrayIcon.Icon = GmailNotifier.Properties.Resources.ReadGmail32; TrayIcon.Text = "Inga olästa meddelande!"; } System.Threading.Thread.Sleep(500); } catch (Exception e) { Console.WriteLine("An error occurred: " + e.Message); } } }
/// <summary> /// Logon to Google. /// </summary> /// <param name="checkAuth">if set to <c>true</c> [check authentication].</param> /// <returns></returns> private static async Task<SerializableAPIResult<SerializableAPICredentials>> LogOn(bool checkAuth = false) { SerializableAPIResult<SerializableAPICredentials> result = new SerializableAPIResult<SerializableAPICredentials>(); if (checkAuth && !HasCredentialsStored()) return result; var clientSecrets = new ClientSecrets { ClientId = Util.Decrypt(GoogleDriveCloudStorageServiceSettings.Default.AppKey, CultureConstants.InvariantCulture.NativeName), ClientSecret = Util.Decrypt(GoogleDriveCloudStorageServiceSettings.Default.AppSecret, CultureConstants.InvariantCulture.NativeName) }; try { s_credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecrets, new[] { CalendarService.Scope.Calendar }, UserId, CancellationToken.None, new FileDataStore(GetCredentialsPath(checkAuth), true)); if (checkAuth) { using (CalendarService client = await GetClient()) await client.Settings.List().ExecuteAsync(); } } catch (GoogleApiException exc) { result.Error = new SerializableAPIError { ErrorMessage = exc.Error.Message }; } catch (TokenResponseException exc) { result.Error = new SerializableAPIError { ErrorMessage = exc.Error.ErrorDescription ?? exc.Error.Error }; } catch (APIException exc) { result.Error = new SerializableAPIError { ErrorCode = exc.ErrorCode, ErrorMessage = exc.Message }; } catch (Exception exc) { result.Error = new SerializableAPIError { ErrorMessage = exc.Message }; } return result; }
public async Task<HttpResponseMessage> SavePost() { Posts post; if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string uploadPath = HttpContext.Current.Server.MapPath("~/") + "UploadFiles"; if (!Directory.Exists(uploadPath)) Directory.CreateDirectory(uploadPath); List<Google.Apis.Drive.v2.Data.File> files = null; try { var provider = new MultipartFormDataStreamProvider(uploadPath); var result = await Request.Content.ReadAsMultipartAsync(provider); if (result.FormData["model"] == null) { throw new HttpResponseException(HttpStatusCode.BadRequest); } //get the files foreach (var file in result.FileData) { //TODO: Do something with each uploaded file } ClientSecrets secrets = new ClientSecrets { ClientId = Constants.CLIENT_ID, ClientSecret = Constants.CLIENT_SECRET }; var fileDataStore = new FileDataStore(HttpContext.Current.Server.MapPath("~/") + "Resources"); UserCredential credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( secrets, new[] { DriveService.Scope.Drive }, "*****@*****.**", CancellationToken.None, fileDataStore ); var service = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = Constants.APP_USER_AGENT }); string Q = "title = 'TinyMarket_Folder' and mimeType = 'application/vnd.google-apps.folder'"; IList<Google.Apis.Drive.v2.Data.File> _Files = GoogleApiHelper.GoogleApiHelper.GetFiles(service, Q); if (_Files.Count == 0) { _Files.Add(GoogleApiHelper.GoogleApiHelper.createDirectory(service, "TinyMarket_Folder", "TinyMarket_Folder", "root")); } if (_Files.Count != 0 && result.FileData.Count > 0) { string directoryId = _Files[0].Id; files = GoogleApiHelper.GoogleApiHelper.UploadFileFromRequest(service, result.FileData, directoryId); var list = service.Files.Get(files[0].Id); } var model = result.FormData["model"]; post = JsonConvert.DeserializeObject<Posts>(model); postService.Add(post); } catch (Exception e) { return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message); } finally { string[] filesToDelete = Directory.GetFiles(uploadPath); foreach (string file in filesToDelete) { if (File.Exists(file)) { GC.Collect(); GC.WaitForPendingFinalizers(); FileInfo f = new FileInfo(file); f.Delete(); } } } return Request.CreateResponse(HttpStatusCode.OK); }
/// <summary> /// Asynchronously gets the credentials. /// </summary> /// <returns></returns> private static async Task GetCredentialsAsync() { var clientSecrets = new ClientSecrets { ClientId = Util.Decrypt(GoogleDriveCloudStorageServiceSettings.Default.AppKey, CultureConstants.InvariantCulture.NativeName), ClientSecret = Util.Decrypt(GoogleDriveCloudStorageServiceSettings.Default.AppSecret, CultureConstants.InvariantCulture.NativeName) }; s_credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecrets, new[] { DriveService.Scope.DriveAppdata }, UserId, CancellationToken.None, new FileDataStore(GetCredentialsPath(), true)).ConfigureAwait(false); }
public bool ConnectCalendar() { var secrets = new ClientSecrets { ClientId = "945058434822-kg3aivhus8fe562j7a1oar208jokclsl.apps.googleusercontent.com", ClientSecret = "i14Tm4YYq2XGXtpyIsk5geAl" }; try { var credential = GoogleWebAuthorizationBroker.AuthorizeAsync( secrets, new [] { CalendarService.Scope.Calendar }, "user", CancellationToken.None) .Result; var initializer = new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = "Discount Work Schedule" }; CalendarConnection = new CalendarService(initializer); } catch (Exception ex) { Console.WriteLine(ex.Message); return false; } return true; }
protected GoogleDrive(Account account, string id, ClientSecrets secrets, string credentialPath) : base(account, id) { Secrets = secrets; CredentialPath = credentialPath; }
private DriveService Initialize() { var secrets = new ClientSecrets { ClientId = ClientId, ClientSecret = ClientSecret }; var scopes = new[] { DriveService.Scope.Drive }; var credential = GoogleWebAuthorizationBroker.AuthorizeAsync(secrets, scopes, "user", CancellationToken.None).Result; // Create the service. var initialiser = new BaseClientService.Initializer(); initialiser.HttpClientInitializer = credential; initialiser.ApplicationName = "PhotoGallery"; var service = new DriveService(initialiser); return service; }
private YouTubeService BuildService() { ClientSecrets secrets = new ClientSecrets() { ClientId = CLIENT_ID, ClientSecret = CLIENT_SECRET }; var token = new TokenResponse { RefreshToken = REFRESH_TOKEN }; var credentials = new UserCredential(new GoogleAuthorizationCodeFlow( new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = secrets }), "user", token); var service = new YouTubeService(new BaseClientService.Initializer() { HttpClientInitializer = credentials, ApplicationName = "TestProject" }); //service.HttpClient.Timeout = TimeSpan.FromSeconds(360); // Choose a timeout to your liking return service; }
async Task<BigqueryService> CreateServiceAsync(CancellationToken cancellationToken) { IConfigurableHttpClientInitializer credential; cancellationToken.ThrowIfCancellationRequested(); if(string.IsNullOrEmpty(PrivateKeyFileName)) { var dataStore = new DataStore(OAuthRefreshToken, OAuthAccessToken); var clientSecrets = new ClientSecrets { ClientId = OAuthClientId, ClientSecret = OAuthClientSecret }; credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecrets, new[] { BigqueryService.Scope.Bigquery }, "user", cancellationToken, dataStore).ConfigureAwait(false); OAuthRefreshToken = dataStore.RefreshToken; OAuthAccessToken = dataStore.AccessToken; } else { X509Certificate2 certificate = new X509Certificate2(PrivateKeyFileName, "notasecret", X509KeyStorageFlags.Exportable); credential = new ServiceAccountCredential(new ServiceAccountCredential.Initializer(ServiceAccountEmail) { Scopes = new[] { BigqueryService.Scope.Bigquery } }.FromCertificate(certificate)); } return new BigqueryService(new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = applicationName }); }
/// <summary> /// 로그인 처리를 위한 초기설정을 도와주는 함수 /// </summary> /// <param name="client">Client_id와 Client_Secret이 담겨있는 클래스(구글 드라이브 콘솔에서 발급받은 id와 비밀번호)</param> /// <param name="scopes">접근 권한에 대한 주소값들이 들어있는 List</param> /// <param name="username">사용자를 구별하기 위한 닉네임</param> /// <param name="taskCancellationToken">작업이 취소되지 않아야 함을 나타내는 값 : None으로 표시</param> /// <param name="store">저장할 위치 (경로로 표시 : 기본 위치 -> C:\Users\bit-user\AppData\Roaming) </param> /// initializer는 클라이언트 id와 클라이언트 시크릿 번호를 설정해준다. /// <returns>반환값은 유저의 정보가 담긴 UserCredential 클래스 반환</returns> /// public static async Task<UserCredential> LoginAuthorizationCodeFlowAsync(ClientSecrets client, IEnumerable<string> scopes, string username, CancellationToken taskCancellationToken, FileDataStore store) { var initializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = client, }; return await AuthorizeAsyncCore(initializer, scopes, username, taskCancellationToken, store) .ConfigureAwait(false); }
/// <summary>Asynchronously authorizes the specified user.</summary> /// <remarks> /// It uses <seealso cref="Google.Apis.Util.Store.StorageDataStore"/> as the flow's data store by default. /// </remarks> /// <param name="clientSecrets">The client secrets.</param> /// <param name="scopes"> /// The scopes which indicate the Google API access your application is requesting. /// </param> /// <param name="user">The user to authorize.</param> /// <param name="taskCancellationToken">Cancellation token to cancel an operation.</param> /// <returns>User credential.</returns> public static async Task<UserCredential> AuthorizeAsync(ClientSecrets clientSecrets, IEnumerable<string> scopes, string user, CancellationToken taskCancellationToken) { var initializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = clientSecrets, }; return await AuthorizeAsyncCore(initializer, scopes, user, taskCancellationToken); }