public void Execute_UnicodeCharacters() { var handler = new TestBodyMessageHnalder() { GZipEnabled = false, ResponseObject = new MockResponse { Id = 100, Name = @"مرحبا العالم" }, ExpectedRequestObject = new MockRequest { Name = @"مرحبا العالم! 您好,世界!" } }; var initializer = new BaseClientService.Initializer() { GZipEnabled = false, HttpClientFactory = new MockHttpClientFactory(handler) }; using (var service = new MockClientService(initializer)) { handler.Serializer = service.Serializer; var request = new TestClientServiceRequest(service, "GET", handler.ExpectedRequestObject); var response = request.Execute(); Assert.That(handler.Calls, Is.EqualTo(1)); // the returned response should contain ETag, check that the service add the right ETag property on // the response handler.ResponseObject.ETag = handler.ResponseETag; Assert.That(response, Is.EqualTo(handler.ResponseObject)); } }
public static void Resolve() { RefreshSettings(); UserCredential credential; using (var stream = new FileStream(settings.AuthPath, FileMode.Open, FileAccess.Read)) { string credPath = "token.json"; credential = GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, Scopes, "user", CancellationToken.None, new FileDataStore(credPath, true)).Result; } var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = ApplicationName }; ClassroomData.Service = new ClassroomService(initializer); DriveHandler.driveService = new DriveService(initializer); ClassroomData.Update(settings.DefaultNotificatons); }
private async Task<string> ResizeDisk() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { Scopes = new[] { ComputeService.Scope.Compute, ComputeService.Scope.CloudPlatform } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GCloud Resize Disk" }; var t = new ComputeService(cs); var drr = new DisksResizeRequest { SizeGb = long.Parse(NewSize) }; var request = t.Disks.Resize(drr, Project, Region + "-" + Zone, DiskName); var response = request.Execute(); if (response.HttpErrorStatusCode != null) { var errorStr = new StringBuilder(); foreach (var error in response.Error.Errors) errorStr.AppendLine(error.Code + " - " + error.Message); return errorStr.ToString(); } else return "Success"; }
public void ExecuteAsync_NoCallback_Test() { var handler = new BatchMessageHandler(true); var initializer = new BaseClientService.Initializer() { HttpClientFactory = new MockHttpClientFactory(handler) }; using (var service = new MockClientService(initializer, "http://sample.com")) { var responses = new List <Tuple <MockResponse, RequestError, HttpResponseMessage> >(); var batch = new BatchRequest(service); var request1 = new TestClientServiceRequest(service, new MockRequest { ETag = "\"100\"", Name = "Name1" }); var request2 = new TestClientServiceRequest(service, new MockRequest { ETag = "\"200\"", Name = "Name1-1" }); batch.Queue <MockResponse>(request1, null); batch.Queue <MockResponse>(request2, null); batch.ExecuteAsync().Wait(); } }
/// <summary> /// A subtest for testing async execute when an exception is thrown during sending the request, with or without /// back-off handler. If back-off handler is attached to the service's message handler, there are going to be /// several retries (up to 2 minutes). /// </summary> /// <param name="backOff">Indicates if back-off handler is attached to the service.</param> private void SubtestExecuteAsync_ThrowException(bool backOff) { var handler = new MockMessageHandler(true); var initializer = new BaseClientService.Initializer() { HttpClientFactory = new MockHttpClientFactory(handler) }; // by default back-off is used, so disable it in case backOff is false if (!backOff) { initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None; } using (var service = new MockClientService(initializer)) { var request = new TestClientServiceRequest(service, "GET", null); var task = request.ExecuteAsync(); try { var result = task.Result; Assert.Fail("Exception should be thrown"); } catch (AggregateException ex) { Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException))); } // if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120) // + 1 calls int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1; Assert.That(handler.Calls, Is.EqualTo(calls)); } }
// // GET: /oauth2callback public ActionResult OAuth2Callback(String code) { var provider = GetProvider(); try { var state = provider.ProcessUserAuthorization(code, GetAuthorizationState()); var initializer = new BaseClientService.Initializer() { Authenticator = Utils.GetAuthenticatorFromState(state) }; Oauth2Service userService = new Oauth2Service(initializer); String userId = userService.Userinfo.Get().Fetch().Id; Utils.StoreCredentials(userId, state); Session["userId"] = userId; BootstrapUser(new MirrorService(initializer), userId); } catch (ProtocolException) { // TODO(alainv): handle error. } return Redirect(Url.Action("Index", "Main")); }
public async Task <IActionResult> GoogleAuthentication(string code) { var request = new AuthorizationCodeTokenRequest { Code = code, ClientSecret = _googleAuthOptions.ClientSecret, ClientId = _googleAuthOptions.ClientId, GrantType = "authorization_code", RedirectUri = "http://localhost:3000" }; var httpClient = new HttpClient { BaseAddress = new Uri("https://www.googleapis.com/oauth2/v4/") }; var tokenResponse = await request.ExecuteAsync(httpClient, "token", CancellationToken.None, SystemClock.Default); var credentials = GoogleCredential.FromAccessToken(tokenResponse.AccessToken); var initializer = new BaseClientService.Initializer { HttpClientInitializer = credentials }; var userInfoService = new Oauth2Service(initializer); var userInfo = await userInfoService.Userinfo.Get().ExecuteAsync(); await _usersService.CreateUserAsync(new UserCreationDto { Email = userInfo.Email, Password = "******", //TODO: Add password generator IsFromExternalService = true, Name = userInfo.Email }); return(Ok()); }
internal static void AddGoogleServices(this IServiceCollection services, BaseClientService.Initializer googleInitializer) { services.AddSingleton(new SheetsService(googleInitializer)); services.AddSingleton(new GmailService(googleInitializer)); services.AddSingleton<GoogleSheetsService>(); }
private DriveService CreateDriveService(GoogleCredentials googleCredentials) { var authorizationCodeFlowInitializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = new ClientSecrets { ClientId = googleCredentials.ClientId, ClientSecret = googleCredentials.ClientSecret } }; var googleAuthorizationCodeFlow = new GoogleAuthorizationCodeFlow(authorizationCodeFlowInitializer); var token = new TokenResponse { RefreshToken = googleCredentials.RefreshToken }; var credentials = new UserCredential(googleAuthorizationCodeFlow, "user", token); var initializer = new BaseClientService.Initializer { ApplicationName = "Emby", HttpClientInitializer = credentials }; return(new DriveService(initializer) { HttpClient = { Timeout = TimeSpan.FromHours(1) } }); }
private string AddUser() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { User = AdminUser, Scopes = new[] { DirectoryService.Scope.AdminDirectoryUser, DirectoryService.Scope.AdminDirectoryGroup } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GSuiteAddUser" }; var t = new DirectoryService(cs); var request = t.Users.Insert(new User { PrimaryEmail = UserEmail, Password = Password, Name = new UserName { GivenName = GivenName, FamilyName = FamilyName }, Emails = new List <UserEmail> { new UserEmail { Primary = true, Address = SecondaryEmail } } }); var user = request.Execute(); return(user.Id); }
private string CopyFile() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { User = UserId, Scopes = new[] { DriveService.Scope.Drive } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GDriveUploadFile" }; var t = new DriveService(cs); var request = t.Files.Copy(new Google.Apis.Drive.v3.Data.File() { Name = Name, Parents = new List <string> { ParentID } }, FileId); var prog = request.Execute(); return("Success"); }
// // GET: /oauth2callback public ActionResult OAuth2Callback(String code) { var provider = GetProvider(); try { var state = provider.ProcessUserAuthorization(code, GetAuthorizationState()); var initializer = new BaseClientService.Initializer() { Authenticator = Utils.GetAuthenticatorFromState(state) }; Oauth2Service userService = new Oauth2Service(initializer); String userId = userService.Userinfo.Get().Fetch().Id; Utils.StoreCredentials(userId, state); Session["userId"] = userId; BootstrapUser(new MirrorService(initializer), userId); } catch (ProtocolException) { // TODO(alainv): handle error. } return(Redirect(Url.Action("Index", "Main"))); }
private string ResetPassword() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { User = AdminUser, Scopes = new[] { DirectoryService.Scope.AdminDirectoryUser, DirectoryService.Scope.AdminDirectoryGroup } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GSuiteUpdatePassword" }; var t = new DirectoryService(cs); var request = t.Users.Update(new User { Password = NewPassword }, UserEmail); var res = request.Execute(); return("Success"); }
/// <summary> /// Send a request to the UserInfo API to retrieve the user's information. /// </summary> /// <param name="credentials">OAuth 2.0 credentials to authorize the request.</param> /// <returns>User's information.</returns> /// <exception cref="NoUserIdException">An error occurred.</exception> static Userinfo GetUserInfo(IAuthorizationState credentials) { // create base client service initializer BaseClientService.Initializer baseClientService = new BaseClientService.Initializer() { Authenticator = GetAuthenticatorFromState(credentials) }; Oauth2Service userInfoService = new Oauth2Service(baseClientService); Userinfo userInfo = null; try { userInfo = userInfoService.Userinfo.Get().Fetch(); } catch (GoogleApiRequestException e) { Console.WriteLine("An error occurred: " + e.Message); } if (userInfo != null && !String.IsNullOrEmpty(userInfo.Id)) { return(userInfo); } else { throw new NoUserIdException(); } }
public string[] NewsFocus(string[] topics) { for (int j = 0; j < topics.Length; j++) { if (String.IsNullOrEmpty(query)) { query = topics[j] + " "; } else { query += topics[j] + " "; } } string apiKey = "AIzaSyAdGYEvLJhlTZQ-Uxo_9IcoPuxwvbOcKV4"; string cseKey = "018422199925324649720:fcnzsnkhzhu"; var bcsi = new BaseClientService.Initializer { ApiKey = apiKey }; var css = new Google.Apis.Customsearch.v1.CustomsearchService(bcsi); var listRequest = css.Cse.List(query); listRequest.Cx = cseKey; var search = listRequest.Execute(); for (int k = 0; k < 10; k++) { i[k] = search.Items[k].Link; } return(i); }
public async Task <bool> Login() { var clientSecretUri = new Uri("ms-appx:///Resources/client_secret.json", UriKind.Absolute); try { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(clientSecretUri, Scopes, "user", CancellationToken.None); await credential.RefreshTokenAsync(CancellationToken.None); } catch (TokenResponseException e) { await credential.GetAccessTokenForRequestAsync(); } catch (Exception e) { return(false); } var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = ApplicationName }; accessToken = credential.Token.AccessToken; Oauth2Service = new Oauth2Service(initializer); DriveService = new DriveService(initializer); return(true); }
/// <summary> /// A subtest for testing execute when an exception is thrown during sending the request, with or without /// back-off. If back-off handler is attached to the service's message handler, there are going to be several /// retries (up to 2 minutes). /// </summary> /// <param name="backOff">Indicates if back-off handler is attached to the service.</param> private void SubtestExecute_ThrowException(bool backOff) { var handler = new MockMessageHandler(true); var initializer = new BaseClientService.Initializer() { HttpClientFactory = new MockHttpClientFactory(handler) }; // by default back-off is used, so disable it in case backOff is false if (!backOff) { initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None; } using (var service = new MockClientService(initializer)) { var request = new TestClientServiceRequest(service, "GET", null); Assert.Throws <InvalidOperationMockException>(() => request.Execute()); // if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120) // + 1 calls int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1; Assert.That(handler.Calls, Is.EqualTo(calls)); } }
public async Task <BaseClientService.Initializer> SetLoginCredencial() { UserCredential cred; using (var stream = new FileStream("../../Resources/GoogleLoginCookie.json", FileMode.Open, FileAccess.Read)) { cred = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.Youtube }, "*****@*****.**", CancellationToken.None); } /* * var UserInfo = await GoogleWebAuthorizationBroker.AuthorizeAsync * (new ClientSecrets { ClientId = LoginID, ClientSecret = LoginPw }, * new[] { YouTubeService.Scope.Youtube }, * "MakiseKurisu", * CancellationToken.None); */ var GoogleYoutube = new BaseClientService.Initializer() { HttpClientInitializer = cred, ApplicationName = "YOUTUBE GUI", ApiKey = "AIzaSyDBDHd7KZ3hkzARnkrxAFHZzw6vDMLX72Q", }; if (GoogleYoutube == null) { throw new Exception("youtube API Login Failed!!\n"); } return(GoogleYoutube); }
public ShoppingContentServiceWithBaseUri( BaseClientService.Initializer init, Uri u) : base(init) { this.baseUri = u.AbsoluteUri; this.basePath = u.AbsolutePath; }
private async Task Run() { UserCredential credential; string clientSecretsPath = CredentialsManager.GetClientSecretsLocation(); using (FileStream stream = new FileStream(clientSecretsPath, FileMode.Open, FileAccess.Read)) { // This OAuth 2.0 access scope allows for read-only access to the authenticated // user's account, but not other types of account access. credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { YouTubeService.Scope.YoutubeReadonly }, "user", CancellationToken.None, new FileDataStore(GetType().ToString()) ); } BaseClientService.Initializer baseClientServiceInitializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = GetType().ToString() }; YouTubeService youtubeService = new YouTubeService(baseClientServiceInitializer); ChannelsResource.ListRequest channelsListRequest = youtubeService.Channels.List("contentDetails"); channelsListRequest.Mine = true; // Retrieve the contentDetails part of the channel resource for the authenticated user's channel. ChannelListResponse channelsListResponse = await channelsListRequest.ExecuteAsync(); foreach (Channel channel in channelsListResponse.Items) { // From the API response, extract the playlist ID that identifies the list // of videos uploaded to the authenticated user's channel. string uploadsListId = channel.ContentDetails.RelatedPlaylists.Uploads; Console.WriteLine("Videos in list {0}", uploadsListId); string nextPageToken = ""; while (nextPageToken != null) { PlaylistItemsResource.ListRequest playlistItemsListRequest = youtubeService.PlaylistItems.List("snippet"); playlistItemsListRequest.PlaylistId = uploadsListId; playlistItemsListRequest.MaxResults = 50; playlistItemsListRequest.PageToken = nextPageToken; // Retrieve the list of videos uploaded to the authenticated user's channel. PlaylistItemListResponse playlistItemsListResponse = await playlistItemsListRequest.ExecuteAsync(); foreach (PlaylistItem playlistItem in playlistItemsListResponse.Items) { // Print information about each video. Console.WriteLine("{0} ({1})", playlistItem.Snippet.Title, playlistItem.Snippet.ResourceId.VideoId); } nextPageToken = playlistItemsListResponse.NextPageToken; } } }
public static BaseClientService.Initializer ForMtlsEndpoint( ICredential credential, IDeviceEnrollment enrollment, string baseUri) { var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = Globals.UserAgent.ToApplicationName() }; if (enrollment?.Certificate != null && HttpClientHandlerExtensions.IsClientCertificateSupported) { TraceSources.IapDesktop.TraceInformation( "Enabling MTLS for {0}", baseUri); // Switch to mTLS endpoint. initializer.BaseUri = baseUri; // Add client certificate. initializer.HttpClientFactory = new MtlsHttpClientFactory(enrollment.Certificate); } return(initializer); }
private async Task <string> GetInstance() { try { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { Scopes = new[] { ComputeService.Scope.Compute, ComputeService.Scope.CloudPlatform } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GCloud Get Instance" }; var t = new ComputeService(cs); var zoneRegion = Region + "-" + Zone; InstancesResource.GetRequest request = t.Instances.Get(Project, zoneRegion, InstanceName); Google.Apis.Compute.v1.Data.Instance response = await request.ExecuteAsync(); return(JsonConvert.SerializeObject(response)); } catch (Exception ex) { throw new Exception(ex.Message); } }
private string AddGroup() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { User = AdminUser, Scopes = new[] { DirectoryService.Scope.AdminDirectoryUser, DirectoryService.Scope.AdminDirectoryGroup } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GSuiteAddGroup" }; var t = new DirectoryService(cs); var request = t.Groups.Insert(new Group { Email = GroupEmail, Name = GroupName }); var group = request.Execute(); return(group.Id); }
public static async Task <YouTubeService> CreateAsync() { var(clientId, clientSecret) = YouTubeKeyStore.GetApiKey(); var secrets = new ClientSecrets() { ClientId = clientId, ClientSecret = clientSecret }; var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( secrets, // This OAuth 2.0 access scope allows for full read/write access to the // authenticated user's account. new[] { YouTubeService.Scope.Youtube, YouTubeService.Scope.YoutubeForceSsl }, "user", CancellationToken.None ); var initializer = new BaseClientService.Initializer { HttpClientInitializer = credential }; return(new YouTubeService(initializer)); }
private string RemovePermission() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { User = UserId, Scopes = new[] { DriveService.Scope.Drive } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GDriveRemovePermission" }; var t = new DriveService(cs); var listReq = t.Permissions.List(FileId); listReq.Fields = "permissions(id,emailAddress)"; var permissionList = listReq.Execute(); var perm = permissionList.Permissions.First(p => p.EmailAddress == PermissionId); var request = t.Permissions.Delete(FileId, perm.Id); var prog = request.Execute(); return("Success"); }
private async Task AuthenticateAsync() { if (_service != null) { return; } FileStream stream = new FileStream(SecretFileName, FileMode.Open, FileAccess.Read); CancellationTokenSource cts = new CancellationTokenSource(); cts.CancelAfter(TimeSpan.FromSeconds(20)); CancellationToken ct = cts.Token; _credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { BloggerService.Scope.Blogger }, "user", ct ); BaseClientService.Initializer initializer = new BaseClientService.Initializer() { HttpClientInitializer = _credential, ApplicationName = ApplicationName }; _service = new BloggerService(initializer); }
public void Initialize() { //string path = Files.GetFullPath("AsmodatBot.json"); /*using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read)) * { * Credentials = GoogleWebAuthorizationBroker.AuthorizeAsync(GoogleClientSecrets.Load(stream).Secrets, * new[] { GmailService.Scope.GmailReadonly }, * Name, CancellationToken.None).Result; * }*/ X509Certificate2 Certificate = new X509Certificate2(OAuth2ID, OAuth2Secret, X509KeyStorageFlags.Exportable); ServiceAccountCredential.Initializer SACInitializer = new ServiceAccountCredential.Initializer(OAuth2ID); SACInitializer.Scopes = new[] { GmailService.Scope.GmailReadonly, GmailService.Scope.GmailSend }; SACInitializer.User = this.User; ServiceAccountCredential SACCredentials = new ServiceAccountCredential(SACInitializer.FromCertificate(Certificate)); //ServiceAccountCredential SACredentials = new ServiceAccountCredential(new ServiceAccountCredential.Initializer) //GmailService.Scope.GmailSend, Initializer = new BaseClientService.Initializer(); Initializer.HttpClientInitializer = Credentials; Initializer.ApplicationName = Name; Service = new GmailService(Initializer); }
private async Task <string> DeleteNetwork() { ServiceAccountCredential credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(ServiceAccountEmail) { Scopes = new[] { ComputeService.Scope.Compute, ComputeService.Scope.CloudPlatform } }.FromPrivateKey(PrivateKey)); var cs = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "GCloud Delete Network" }; var t = new ComputeService(cs); var request = t.Networks.Delete(Project, NetworkName); var response = request.Execute(); if (response.HttpErrorStatusCode != null) { var errorStr = new StringBuilder(); foreach (var error in response.Error.Errors) { errorStr.AppendLine(error.Code + " - " + error.Message); } return(errorStr.ToString()); } else { return("Success"); } }
public ManufacturerCenterServiceWithBaseUri( BaseClientService.Initializer init, Uri u) : base(init) { this.baseUri = u.AbsoluteUri; this.basePath = u.AbsolutePath; }
public void ExecuteAsync_Error() { var handler = new ErrorMessageHanlder(); var initializer = new BaseClientService.Initializer { HttpClientFactory = new MockHttpClientFactory(handler) }; using (var service = new MockClientService(initializer)) { var request = new TestClientServiceRequest(service, "GET", null); AutoResetEvent resetEvent = new AutoResetEvent(false); var task = request.ExecuteAsync(); var error = string.Empty; task.ContinueWith(t => { // should not ENTER this code, the task should fail resetEvent.Set(); }, TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith(t => { // catch the error error = t.Exception.InnerException.ToString(); resetEvent.Set(); }, TaskContinuationOptions.NotOnRanToCompletion); resetEvent.WaitOne(); Assert.True(error.Contains(handler.ExpectedError), "Error message is invalid"); Assert.That(handler.Calls, Is.EqualTo(1)); } }
/// <summary> /// Creates the google client service implementation for the given google user ID asynchronous. /// </summary> /// <param name="authCode">The authentication code.</param> /// <returns> /// A Google Client Service instance. /// </returns> public async Task <IGoogleClientService> CreateGoogleClientServiceForUserAsync(string authCode) { // TODO make use of data store after testing var dataStore = new GoogleEntityDataStore(_context); using IAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow( new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = new ClientSecrets { ClientId = _options.ClientId, ClientSecret = _options.ClientSecret }, Scopes = _options.Scopes, // TODO use entityDataStore DataStore = new FileDataStore("GoogleTokens") }); TokenResponse token = await flow.ExchangeCodeForTokenAsync("USER_ID", authCode, _options.RedirectUri, CancellationToken.None); UserCredential credential = new UserCredential(flow, Environment.UserName, token); // Create service initializer BaseClientService.Initializer initializer = new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = _options.ApplicationName }; return(new GoogleClientService(_logger, initializer)); }
// GET: /Calendar/UpcomingEvents public async Task<ActionResult> UpcomingEvents() { const int MaxEventsPerCalendar = 20; const int MaxEventsOverall = 50; var model = new UpcomingEventsViewModel(); var credential = await GetCredentialForApiAsync(); var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "ASP.NET MVC5 Calendar Sample", }; var service = new CalendarService(initializer); // Fetch the list of calendars. var calendars = await service.CalendarList.List().ExecuteAsync(); // Fetch some events from each calendar. var fetchTasks = new List<Task<Google.Apis.Calendar.v3.Data.Events>>(calendars.Items.Count); foreach (var calendar in calendars.Items) { var request = service.Events.List(calendar.Id); request.MaxResults = MaxEventsPerCalendar; request.SingleEvents = true; request.TimeMin = DateTime.Now; fetchTasks.Add(request.ExecuteAsync()); } var fetchResults = await Task.WhenAll(fetchTasks); // Sort the events and put them in the model. var upcomingEvents = from result in fetchResults from evt in result.Items where evt.Start != null let date = evt.Start.DateTime.HasValue ? evt.Start.DateTime.Value.Date : DateTime.ParseExact(evt.Start.Date, "yyyy-MM-dd", null) let sortKey = evt.Start.DateTimeRaw ?? evt.Start.Date orderby sortKey select new { evt, date }; var eventsByDate = from result in upcomingEvents.Take(MaxEventsOverall) group result.evt by result.date into g orderby g.Key select g; var eventGroups = new List<CalendarEventGroup>(); foreach (var grouping in eventsByDate) { eventGroups.Add(new CalendarEventGroup { GroupTitle = grouping.Key.ToLongDateString(), Events = grouping, }); } model.EventGroups = eventGroups; return View(model); }
public void Custom_initializer_returns_project_id_and_initializer() { var initializer = new BaseClientService.Initializer(); var customInitializer = new CustomInitializer("ProjectId", initializer); Assert.Equal("ProjectId", customInitializer.GetProjectId()); Assert.Equal(initializer, customInitializer.GetInitializer()); }
private async Task<StorageService> CreateServiceAsync() { GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync(); var serviceInitializer = new BaseClientService.Initializer() { ApplicationName = "Storage Sample", HttpClientInitializer = credential }; service = new StorageService(serviceInitializer); return service; }
private async Task Run() { var ics = new BaseClientService.Initializer { ApiKey = "AIzaSyD9pT1ig_V3DrzF-9xTUENXyS3Nf7reWAk", ApplicationName = "Test", }; var youtubeService = new YouTubeService(ics); /* var youtubeService = new YouTubeService(new BaseClientService.Initializer() { ApiKey = "AIzaSyB5VEzoWa9suKGKl6NNW6Hc_M-og0Wn2Xw", ApplicationName = this.GetType().ToString() }); * */ var searchListRequest = youtubeService.Search.List("snippet"); searchListRequest.Q = "Jurasic Park"; // Replace with your search term. searchListRequest.MaxResults = 5; // Call the search.list method to retrieve results matching the specified query term. var searchListResponse = await searchListRequest.ExecuteAsync(); List<string> videos = new List<string>(); List<string> channels = new List<string>(); List<string> playlists = new List<string>(); // Add each result to the appropriate list, and then display the lists of // matching videos, channels, and playlists. foreach (var searchResult in searchListResponse.Items) { switch (searchResult.Id.Kind) { case "youtube#video": videos.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.VideoId)); break; case "youtube#channel": channels.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.ChannelId)); break; case "youtube#playlist": playlists.Add(String.Format("{0} ({1})", searchResult.Snippet.Title, searchResult.Id.PlaylistId)); break; } } Console.WriteLine(String.Format("Videos:\n{0}\n", string.Join("\n", videos))); Console.WriteLine(String.Format("Channels:\n{0}\n", string.Join("\n", channels))); Console.WriteLine(String.Format("Playlists:\n{0}\n", string.Join("\n", playlists))); }
public void Cloud_auth_object_returns_initializer() { var initializer = new BaseClientService.Initializer(); var mockContext = new MockContext<CloudAuthenticator>(); mockContext.Arrange(f => f.GetInitializer()).Returns(initializer); var cloudAuthMock = new CloudAuthenticatorMock(mockContext); var result = cloudAuthMock.GetInitializer(); mockContext.Assert(f => f.GetInitializer(), Invoked.Once); Assert.Equal(initializer, result); }
protected void Page_Load(object sender, EventArgs e) { // If we did not construct the service so far, do it now. if (service == null) { BaseClientService.Initializer initializer = new BaseClientService.Initializer(); // You can enter your developer key for services requiring a developer key. /* initializer.ApiKey = "<Insert Developer Key here>"; */ service = new UrlshortenerService(initializer); } }
public GoogleApiService() { var bcs = new BaseClientService.Initializer { ApplicationName = "Nadeko Bot", ApiKey = NadekoBot.Credentials.GoogleApiKey }; _log = LogManager.GetCurrentClassLogger(); yt = new YouTubeService(bcs); sh = new UrlshortenerService(bcs); }
private static YouTubeService CreateYouTubeService(IKernel kernel) { var configRetriever = kernel.Resolve<IGetEnvironmentConfiguration>(); string apiKey = configRetriever.GetSetting(YouTubeApiKey); kernel.ReleaseComponent(configRetriever); // Create client for YouTube API var youTubeInit = new BaseClientService.Initializer { ApiKey = apiKey, ApplicationName = "KillrVideo.SampleData.Worker" }; return new YouTubeService(youTubeInit); }
public void Authenticate() { // here is where we Request the user to give us access, or use the Refresh Token that was previously stored in %AppData% credential = GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets { ClientId = clientId, ClientSecret = clientSecret }, scopes, userName, CancellationToken.None).Result; var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "BloggerApp", }; service = new BloggerService(initializer); }
public void CreatePredictionService(string authJsonFile) { Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", authJsonFile); var credentials = Google.Apis.Auth.OAuth2.GoogleCredential.GetApplicationDefaultAsync().Result; if (credentials.IsCreateScopedRequired) { credentials = credentials.CreateScoped(PredictionService.Scope.DevstorageFullControl, PredictionService.Scope.Prediction); } var serviceInitializer = new BaseClientService.Initializer() { ApplicationName = "Prediction Sample", HttpClientInitializer = credentials }; PredictionService = new PredictionService(serviceInitializer); }
// [START create_storage_client] public StorageService CreateStorageClient() { var credentials = Google.Apis.Auth.OAuth2.GoogleCredential.GetApplicationDefaultAsync().Result; if (credentials.IsCreateScopedRequired) { credentials = credentials.CreateScoped(new[] { StorageService.Scope.DevstorageFullControl }); } var serviceInitializer = new BaseClientService.Initializer() { ApplicationName = "Storage Sample", HttpClientInitializer = credentials }; return new StorageService(serviceInitializer); }
public string CreateEvent(string Title, string Location, string SalesContact, string StartDate, string EndDate, string Comments, string ProductDescription, string OrderId, string RequiredDate, string ColorId) { // Add the calendar specific scope to the scopes list. scopes.Add(CalendarService.Scope.Calendar); UserCredential credential = default(UserCredential); using (FileStream stream = new FileStream(System.Configuration.ConfigurationSettings.AppSettings["Json"] + "client_secrets.json", FileMode.Open, FileAccess.Read)) { credential = GoogleWebAuthorizationBroker.AuthorizeAsync(GoogleClientSecrets.Load(stream).Secrets, scopes, "ZZZZZZZZZZZZ", CancellationToken.None, null).Result; } String token = credential.Token.AccessToken; credential.Token.RefreshToken = token; // Create the calendar service using an initializer instance BaseClientService.Initializer initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "DPI Google Calendar"; service = new CalendarService(initializer); Event evnt = new Event(); if (ColorId == "") { evnt.ColorId = "5"; } if (ColorId != "") { evnt.ColorId = ColorId; } evnt.Start = new EventDateTime { DateTime = Convert.ToDateTime(StartDate), TimeZone = "Australia/Melbourne" }; evnt.End = new EventDateTime { DateTime = Convert.ToDateTime(EndDate), TimeZone = "Australia/Melbourne" }; evnt.Description = "SalesContact : " + SalesContact + Environment.NewLine + Environment.NewLine + "Required On :" + Convert.ToDateTime(RequiredDate).ToShortDateString() + Environment.NewLine + Environment.NewLine + "Product Description :" + ProductDescription + Environment.NewLine + Environment.NewLine + "Supplier Instructions :" + Comments + Environment.NewLine + Environment.NewLine + "Order Item :" + OrderId; evnt.Summary = Title; evnt.Location = Location; service.Events.Insert(evnt, "*****@*****.**").Execute(); //service.Events.Insert(evnt, "*****@*****.**").Execute(); // service.Events.Insert(evnt, "*****@*****.**").Execute(); return ""; }
public static async Task<DriveService> GetClient(TokenResponse token) { var credentials = new UserCredential( AuthFlow, null, token); var driveInitializer = new BaseClientService.Initializer { HttpClientInitializer = credentials, HttpClientFactory = new GoogleDriveHttpClientFactory(), ApplicationName = "KeeAnywhere", }; var client = new DriveService(driveInitializer); return client; }
public void SetCalendar(string clientKey, string secretKey,int orgId) { string refreshToken = string.Empty; try { scopes.Add(CalendarService.Scope.Calendar); UserCredential credential = default(UserCredential); DatabaseDataStore _fdsToken; if (!string.IsNullOrEmpty(refreshToken)) { StoredResponse storedResponse = new StoredResponse(refreshToken); _fdsToken = new DatabaseDataStore(storedResponse, orgId); } else { _fdsToken = new DatabaseDataStore(orgId,clientKey,secretKey); } credential = GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = clientKey, ClientSecret = secretKey, }, scopes, "Z", CancellationToken.None, _fdsToken).Result; credential.Token.ExpiresInSeconds = 500000; String token = credential.Token.RefreshToken; credential.Token.RefreshToken = refreshToken; //credential.Token.ExpiresInSeconds = 500000; // Create the calendar service using an initializer instance BaseClientService.Initializer initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "DPI Google Calendar"; service = new CalendarService(initializer); } catch (Exception ex) { //string text = File.ReadAllText("C://Google.txt"); //text = text + Environment.NewLine + ex.Message; //File.WriteAllText("C://Google.txt", text); } }
private async Task AuthenticateAsync() { if (service != null) return; credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( new Uri("ms-appx:///Assets/client_secrets.json"), new[] { BloggerService.Scope.BloggerReadonly }, "user", CancellationToken.None); var initializer = new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = "BloggerApp", }; service = new BloggerService(initializer); }
public GoogleApiHelper( string p12Path, string serviceAccountEmail, string applicationName, string calendarId, DateTime startCalendarQuery, DateTime endCalendarQuery) { try { var certificate = new X509Certificate2(p12Path, "notasecret", X509KeyStorageFlags.Exportable); var credential = new ServiceAccountCredential( new ServiceAccountCredential.Initializer(serviceAccountEmail) { Scopes = new[] { CalendarService.Scope.Calendar } }.FromCertificate (certificate)); var initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = applicationName; var service = new CalendarService(initializer); var queryStart = startCalendarQuery; var queryEnd = endCalendarQuery; var query = service.Events.List(calendarId); query.TimeMin = queryStart; query.TimeMax = queryEnd; var events = query.Execute().Items; _mEventList = events.Select(e => new GoogleCalendarEvent(DateTime.Parse(e.Start.Date), e.Summary)).ToList(); _mEventList.Sort((e1, e2) => e1.Date.CompareTo(e2.Date)); } catch (Exception e) { throw new Exception(string.Format("Exception in GoogleAPIHelper constructor: {0}", e.Message)); } }
private async Task AuthenticateAsync() { if (_service != null) return; _credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( new Uri("ms-appx:///Assets/client_secrets.json"), new[] { Oauth2Service.Scope.UserinfoEmail }, "user", CancellationToken.None); var initializer = new BaseClientService.Initializer() { HttpClientInitializer = _credential, ApplicationName = "GoogleLogin", }; _service = new Oauth2Service(initializer); }
private async Task Run() { IDataStore credentialPersistanceStore = getPersistentCredentialStore(); UserCredential credential; using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read)) { credential = await GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, new[] { "email" }, getUserId(), CancellationToken.None, getPersistentCredentialStore()); } BaseClientService.Initializer initializer = new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = "OutlookAddin" }; }
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; }
public ServiceAccountAuthenticator(string projectId, string serviceAccountEmail, string certificatePath, string secretKey) { if (string.IsNullOrWhiteSpace(serviceAccountEmail)) throw new ArgumentException(nameof(serviceAccountEmail)); if (string.IsNullOrWhiteSpace(certificatePath)) throw new ArgumentException(nameof(certificatePath)); if (string.IsNullOrWhiteSpace(secretKey)) throw new ArgumentException(nameof(secretKey)); if (string.IsNullOrWhiteSpace(projectId)) throw new ArgumentException(nameof(projectId)); // Service account email must be an email address. A lot of people use the client Id instead of email by accident, // so this simple check should save them some time. if (!serviceAccountEmail.Contains("@")) throw new InvalidOperationException("The `serviceAccountEmail` parameter must be an email address. (Did you use a client Id by accident?)"); _projectId = projectId; var fullpath = UriExtensions.GetAbsoluteUri(certificatePath); var certificate = new X509Certificate2(fullpath, secretKey, X509KeyStorageFlags.Exportable); var credential = new Google.Apis.Auth.OAuth2.ServiceAccountCredential( new Google.Apis.Auth.OAuth2.ServiceAccountCredential.Initializer(serviceAccountEmail) { Scopes = new[] { DatastoreService.Scope.Datastore, DatastoreService.Scope.UserinfoEmail, StorageService.Scope.DevstorageReadWrite } }.FromCertificate(certificate)); _initializer = new BaseClientService.Initializer { HttpClientInitializer = credential, ApplicationName = projectId }; }
private async Task GetCalendars(string accessToken) { var initializer = new BaseClientService.Initializer(); var interceptor = new WinRTMessageAuthenticationInterceptor(accessToken); initializer.HttpClientInitializer = interceptor; //var handler = new HttpClientHandler(); //var httpClient = new ConfigurableHttpClient(new ConfigurableMessageHandler(handler)); //interceptor.Initialize(httpClient); var calendarService = new CalendarService(initializer); var calendarsResource = calendarService.CalendarList.List().Execute(); var entries = calendarsResource.Items; foreach (var entry in entries) { Debug.WriteLine(entry.Description); } //string address = "https://www.googleapis.com/oauth2/v1/use%rinfo?access_token=" + accessToken; ////var response = await httpClient.GetAsync(new Uri(address)); ////var content = await response.Content.ReadAsStringAsync(); ////return content; //return null; }
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; }
void SetupCalendarForSubsription() { try { string CTFolderPath = AppDomain.CurrentDomain.BaseDirectory + @"CT"; string refreshToken = string.Empty; DirectoryInfo directory = new DirectoryInfo(CTFolderPath); if (directory.GetFiles().Count() > 0) { string filename = directory.GetFiles().OrderByDescending(f => f.LastWriteTime).FirstOrDefault().FullName; string jsonText = File.ReadAllText(filename); var googleToken = (GoogleToken)Newtonsoft.Json.JsonConvert.DeserializeObject(jsonText, typeof(GoogleToken)); //Dictionary<string, object> tokenOjbect = test.refresh_token;//(Dictionary<string, object>)Newtonsoft.Json.JsonConvert.DeserializeObject(jsonText);////new JavaScriptSerializer().DeserializeObject(jsonText); refreshToken = googleToken.refresh_token;//tokenOjbect["refresh_token"].ToString(); } scopes.Add(CalendarService.Scope.Calendar); UserCredential credential = default(UserCredential); FileDataStore _fdsToken = new FileDataStore(CTFolderPath); credential = GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = "532982290458-u189keaaki44sskvtki6p28rq5crjl6d.apps.googleusercontent.com", ClientSecret = "DDO62gcKn5nYWm4XCXlJkngo", }, scopes, "Z", CancellationToken.None, _fdsToken).Result; credential.Token.ExpiresInSeconds = 500000; String token = credential.Token.RefreshToken; credential.Token.RefreshToken = refreshToken;// "1/wU76ItFh-n64iqZLjIiXER0Vx4u-MxEnHtHFLgQpa7E"; credential.Token.ExpiresInSeconds = 500000; // Create the calendar service using an initializer instance BaseClientService.Initializer initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "DPI Google Calendar"; service = new CalendarService(initializer); } catch (Exception ex) { } }
public static void SetCalendar() { try { scopes.Add(CalendarService.Scope.Calendar); UserCredential credential = default(UserCredential); FileDataStore _fdsToken = new FileDataStore("CT"); credential = GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = "532982290458-u189keaaki44sskvtki6p28rq5crjl6d.apps.googleusercontent.com", ClientSecret = "DDO62gcKn5nYWm4XCXlJkngo", }, scopes, "Z", CancellationToken.None, _fdsToken).Result; credential.Token.ExpiresInSeconds = 500000; String token = credential.Token.RefreshToken; credential.Token.RefreshToken = "1/wU76ItFh-n64iqZLjIiXER0Vx4u-MxEnHtHFLgQpa7E"; credential.Token.ExpiresInSeconds = 500000; // Create the calendar service using an initializer instance BaseClientService.Initializer initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "DPI Google Calendar"; service = new CalendarService(initializer); } catch (Exception ex) { } }
public Google.Apis.Drive.v2.DriveService Init(string applicationName, string clientIdentifier, string clientSecret, string[] scope, bool logout, string refreshTokenFolder) { StatusForm.ShowDialog(); try { _refreshTokenFilePath = refreshTokenFolder; string fileDataStorePath = _refreshTokenFilePath; if (FileExists(fileDataStorePath)) { DateTime lastFileWriteTime = GetFileLastWriteTime(fileDataStorePath); if (lastFileWriteTime < new DateTime(2014, 8, 22)) { DeleteFile(fileDataStorePath); } } if (logout) { try { if (DirectoryExists(fileDataStorePath)) { string[] fileDataStoreFiles = System.IO.Directory.GetFiles(fileDataStorePath, "Google.Apis.Auth.OAuth2.Responses.*"); foreach (string fileDataStoreFile in fileDataStoreFiles) { DeleteFile(fileDataStoreFile); } } LoginForm.Logout(); } catch (Exception exception) { Log.Error(String.Format("Authenticator.Logout - Deleting token file. {0}",exception.Message)); } } var clientSecrets = new Google.Apis.Auth.OAuth2.ClientSecrets { ClientId = clientIdentifier, ClientSecret = clientSecret }; _fileDataStore = new EncryptedFileDataStore(refreshTokenFolder); System.Threading.Tasks.Task<Google.Apis.Auth.OAuth2.UserCredential> task = null; try { task = Google.Apis.Auth.OAuth2.GoogleWebAuthorizationBroker.AuthorizeAsync( clientSecrets, scope, System.Environment.UserName, System.Threading.CancellationToken.None, _fileDataStore); task.Wait(); } catch (Exception exception) { throw new LogException("GoogleWebAuthorizationBroker.AuthorizeAsync - " + exception.Message, false, false); } _userCredential = task.Result; var initializer = new BaseClientService.Initializer { HttpClientInitializer = _userCredential, ApplicationName = applicationName }; _driveService = new Google.Apis.Drive.v2.DriveService(initializer); UpdateAboutData(_driveService); return _driveService; } catch (Exception exception) { Log.Error(exception); return null; } finally { StatusForm.CloseDialog(); } }
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; }
/// <summary> /// Gets the client. /// </summary> /// <returns></returns> private static async Task<CalendarService> GetClient() { if ((s_credential == null) || !HasCredentialsStored()) { GetCredentialsPath(true); await LogOn(true); } var initializer = new BaseClientService.Initializer { HttpClientInitializer = s_credential, ApplicationName = EveMonClient.FileVersionInfo.ProductName, }; return new CalendarService(initializer); }
//Dev SetCalendar public void SetCalendar(int orgId, bool isSubscription = false) { string clientKey = string.Empty; string secretKey = string.Empty; string refreshToken = string.Empty; string name = "GoogleCalendar"; if (isSubscription) { name = "SubscribeGoogleCalendar"; } try { var dt = SelectClientCredentials(name, orgId); if (dt != null) { if (dt.Rows[0][0] != null) clientKey = dt.Rows[0][0].ToString(); if (dt.Rows[0][1] != null) secretKey = dt.Rows[0][1].ToString(); if (dt.Rows[0][2] != null) refreshToken = dt.Rows[0][2].ToString(); } scopes.Add(CalendarService.Scope.Calendar); UserCredential credential = default(UserCredential); DatabaseDataStore _fdsToken; if (!string.IsNullOrEmpty(refreshToken)) { StoredResponse storedResponse = new StoredResponse(refreshToken); _fdsToken = new DatabaseDataStore(storedResponse, orgId); } else { _fdsToken = new DatabaseDataStore(orgId); } credential = GoogleWebAuthorizationBroker.AuthorizeAsync( new ClientSecrets { ClientId = clientKey,// "532982290458-u189keaaki44sskvtki6p28rq5crjl6d.apps.googleusercontent.com", ClientSecret = secretKey,//"DDO62gcKn5nYWm4XCXlJkngo", }, scopes, "Z", CancellationToken.None, _fdsToken).Result; credential.Token.ExpiresInSeconds = 500000; String token = credential.Token.RefreshToken; credential.Token.RefreshToken = refreshToken; //credential.Token.ExpiresInSeconds = 500000; // Create the calendar service using an initializer instance BaseClientService.Initializer initializer = new BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; initializer.ApplicationName = "DPI Google Calendar"; service = new CalendarService(initializer); } catch (Exception ex) { string text = File.ReadAllText("C://Google.txt"); text = text + Environment.NewLine + ex.Message; File.WriteAllText("C://Google.txt", text); } }
private DriveService CreateDriveService(GoogleCredentials googleCredentials) { var authorizationCodeFlowInitializer = new GoogleAuthorizationCodeFlow.Initializer { ClientSecrets = new ClientSecrets { ClientId = googleCredentials.ClientId, ClientSecret = googleCredentials.ClientSecret } }; var googleAuthorizationCodeFlow = new GoogleAuthorizationCodeFlow(authorizationCodeFlowInitializer); var token = new TokenResponse { RefreshToken = googleCredentials.RefreshToken }; var credentials = new UserCredential(googleAuthorizationCodeFlow, "user", token); var initializer = new BaseClientService.Initializer { ApplicationName = "Emby", HttpClientInitializer = credentials }; return new DriveService(initializer) { HttpClient = { Timeout = TimeSpan.FromHours(1) } }; }