public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); if (ApplicationData.Current.LocalSettings.Values.ContainsKey("RefreshToken")) { string refreshToken = ApplicationData.Current.LocalSettings.Values["RefreshToken"].ToString(); string returnUrl = WebAuthenticationBroker.GetCurrentApplicationCallbackUri().ToString(); IOneDriveClient client = await OneDriveClient.GetSilentlyAuthenticatedMicrosoftAccountClient(ClientId, returnUrl, Scopes, refreshToken); bool isFolderExisting = true; try { await client.Drive.Root.ItemWithPath("OneDrive Sample").Request().GetAsync(); } catch (OneDriveException exc) { isFolderExisting = false; } if (isFolderExisting) { StorageFile file = await Package.Current.InstalledLocation.GetFileAsync("BackgroundWallpaper.jpg"); using (Stream stream = await file.OpenStreamForReadAsync()) { await client.Drive.Root.ItemWithPath("OneDrive Sample/BackgroundWallpaper.png").Content.Request().PutAsync <Item>(stream); } } } deferral.Complete(); }
internal static OneDriveItem CreateFromRawJson(string rawJsonData, OneDriveClient sourceClient) { OneDriveItem item = JsonConvert.DeserializeObject<OneDriveItem>(rawJsonData); item.Client = sourceClient; return item; }
public async Task GetSilentlyAuthenticatedMicrosoftAccountClient_WithSecret() { var appId = "appId"; var clientSecret = "secret"; var refreshToken = "refresh"; var returnUrl = "returnUrl"; var scopes = new string[] { "scope" }; this.authenticationProvider.SetupSet(provider => provider.CurrentAccountSession = It.IsAny <AccountSession>()).Verifiable(); this.SetupServiceInfoProviderForMicrosoftAccount(appId, clientSecret, returnUrl, scopes); var client = await OneDriveClient.GetSilentlyAuthenticatedMicrosoftAccountClient( appId, returnUrl, scopes, clientSecret, refreshToken, this.serviceInfoProvider.Object, this.credentialCache.Object, this.httpProvider.Object); this.authenticationProvider.VerifySet( provider => provider.CurrentAccountSession = It.Is <AccountSession>(session => refreshToken.Equals(session.RefreshToken)), Times.Once); this.authenticationProvider.Verify(provider => provider.AuthenticateAsync(), Times.Once); }
/// <summary> /// Gets the universal client (Windows 10) and attempts to authenticate with OneDrive. /// </summary> /// <returns>True if the authentication was successful, otherwise false.</returns> public async Task <bool> InitializeAsync() { var scopes = new[] { "wl.offline_access", "wl.signin", "office.onenote_update", "onedrive.readwrite" }; var redirect = "urn:ietf:wg:oauth:2.0:oob"; OneDriveClient = OneDriveClientExtensions.GetUniversalClient(scopes, redirect) as OneDriveClient; if (OneDriveClient == null) { return(false); } try { await OneDriveClient.AuthenticateAsync(); Debug.WriteLine("Successfully authenticated with OneDrive"); } catch (OneDriveException ex) { Debug.WriteLine("error authenticating" + ex); OneDriveClient.Dispose(); return(false); } return(OneDriveClient.IsAuthenticated); }
public void GetMicrosoftAccountClient_NoSecret_InitializeDefaults() { var appId = "appId"; var returnUrl = "returnUrl"; var scopes = new string[] { "scope" }; var client = OneDriveClient.GetMicrosoftAccountClient( appId, returnUrl, scopes) as OneDriveClient; Assert.IsNotNull(client.credentialCache, "Cache not initialized."); var initializedServiceInfoProvider = client.serviceInfoProvider as ServiceInfoProvider; Assert.IsNotNull(initializedServiceInfoProvider, "Service info provider not correctly initialized."); var initializedHttpProvider = client.HttpProvider as HttpProvider; Assert.IsNotNull(initializedHttpProvider, "HTTP provider not correctly initialized."); Assert.AreEqual(appId, client.appConfig.MicrosoftAccountAppId, "Incorrect app ID set."); Assert.IsNull(client.appConfig.MicrosoftAccountClientSecret, "Client secret set."); Assert.AreEqual(returnUrl, client.appConfig.MicrosoftAccountReturnUrl, "Incorrect return URL set."); Assert.AreEqual(scopes, client.appConfig.MicrosoftAccountScopes, "Incorrect scopes set."); }
private async Task loggin() { msaProvider = new OnlineIdAuthenticationProvider(scopes); await msaProvider.RestoreMostRecentFromCacheOrAuthenticateUserAsync(); this.client = new OneDriveClient(msaProvider); }
public async Task SyncMediaToOneDrive(string trackingNumber) { OneDriveClient oneDriveClient = new OneDriveClient(); var documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); documentsPath = documentsPath + "/" + trackingNumber; //Pictures captured by camera string[] jpgFileList = Directory.Exists(documentsPath) ? Directory.GetFiles(documentsPath, "*.jpg") : null; foreach (string filePathAndName in jpgFileList) { FileInfo info = new FileInfo(filePathAndName); string fileName = info.Name; //var imagePath = "/Users/rei/Library/" + "693_CellCultureandFermentation_A1_CellCultureandFermentation_A_Question1Camera.jpg"; //documentsPath + "/" + fileName; await oneDriveClient.PostMediaToOneDrive(filePathAndName, fileName, trackingNumber); } //videos captured by camera string[] mp4FileList = Directory.Exists(documentsPath) ? Directory.GetFiles(documentsPath, "*.mp4") : null; foreach (string filePathAndName in mp4FileList) { FileInfo info = new FileInfo(filePathAndName); string fileName = info.Name; //var imagePath = "/Users/rei/Library/" + "693_CellCultureandFermentation_A1_CellCultureandFermentation_A_Question1Camera.jpg"; //documentsPath + "/" + fileName; await oneDriveClient.PostMediaToOneDrive(filePathAndName, fileName, trackingNumber); } //signature captured by scratch pad string[] pngFileList = Directory.Exists(documentsPath) ? Directory.GetFiles(documentsPath, "*.png") : null; foreach (string filePathAndName in pngFileList) { FileInfo info = new FileInfo(filePathAndName); string fileName = info.Name; //var imagePath = "/Users/rei/Library/" + "693_CellCultureandFermentation_A1_CellCultureandFermentation_A_Question1Camera.jpg"; //documentsPath + "/" + fileName; await oneDriveClient.PostMediaToOneDrive(filePathAndName, fileName, trackingNumber); } //voice string[] wavFileList = Directory.Exists(documentsPath) ? Directory.GetFiles(documentsPath, "*.wav") : null; foreach (string filePathAndName in wavFileList) { FileInfo info = new FileInfo(filePathAndName); string fileName = info.Name; //var imagePath = "/Users/rei/Library/" + "693_CellCultureandFermentation_A1_CellCultureandFermentation_A_Question1Camera.jpg"; //documentsPath + "/" + fileName; await oneDriveClient.PostMediaToOneDrive(filePathAndName, fileName, trackingNumber); } }
public void OneDriveFileUploadNotEnoughData() { if (!GlobalTestSettings.RunNetworkTests) { Assert.Inconclusive(GlobalTestSettings.NetworkTestsDisabledMessage); } int payloadSize = 262144; // 256k TokenResponse currentToken = GetCurrentToken(); Guid remoteTestFolderName = Guid.NewGuid(); Item remoteTestFolder = CreateOneDriveTestDirectory(currentToken, remoteTestFolderName.ToString("D")).Result; using (OneDriveClient client = new OneDriveClient(currentToken)) { // Specify the upload size as 16 bytes larger than we are actually going to send. OneDriveUploadSession session = client.CreateUploadSession(remoteTestFolder.Id, "uploadTest.txt", payloadSize + 16).Result; using (OneDriveFileUploadStream stream = new OneDriveFileUploadStream(client, session)) { byte[] data = CreateUploadBuffer(payloadSize); // Write the data in 1k chunks int writeSize = 1024; for (int j = 0; j < payloadSize; j += writeSize) { stream.Write(data, j, writeSize); } } Assert.AreEqual(OneDriveFileUploadState.Cancelled, session.State); } }
public void OneDrive1ByteFileUploadTest() { if (!GlobalTestSettings.RunNetworkTests) { Assert.Inconclusive(GlobalTestSettings.NetworkTestsDisabledMessage); } int fragmentSize = 327680; // 320k int payloadSize = 1; TokenResponse currentToken = GetCurrentToken(); Guid remoteTestFolderName = Guid.NewGuid(); Item remoteTestFolder = CreateOneDriveTestDirectory(currentToken, remoteTestFolderName.ToString("D")).Result; using (OneDriveClient client = new OneDriveClient(currentToken)) { OneDriveUploadSession session = client.CreateUploadSession(remoteTestFolder.Id, "uploadTest.txt", payloadSize).Result; using (OneDriveFileUploadStream stream = new OneDriveFileUploadStream(client, session, fragmentSize)) { // Create a buffer for the data we want to send, and fill it with ASCII text stream.Write(new byte[] { 0xAB }, 0, 1); } Assert.AreEqual(OneDriveFileUploadState.Completed, session.State); } }
public void OneDriveFileUploadSingleFragment() { if (!GlobalTestSettings.RunNetworkTests) { Assert.Inconclusive(GlobalTestSettings.NetworkTestsDisabledMessage); } int fragmentSize = OneDriveFileUploadStream.DefaultFragmentSize; // 10M int payloadSize = 524288; // < 1 fragments TokenResponse currentToken = GetCurrentToken(); Guid remoteTestFolderName = Guid.NewGuid(); Item remoteTestFolder = CreateOneDriveTestDirectory(currentToken, remoteTestFolderName.ToString("D")).Result; using (OneDriveClient client = new OneDriveClient(currentToken)) { OneDriveUploadSession session = client.CreateUploadSession(remoteTestFolder.Id, "uploadTest.txt", payloadSize).Result; using (OneDriveFileUploadStream stream = new OneDriveFileUploadStream(client, session, fragmentSize)) { byte[] data = CreateUploadBuffer(payloadSize); stream.Write(data, 0, data.Length); } Assert.AreEqual(OneDriveFileUploadState.Completed, session.State); Assert.IsNotNull(session.Item); } }
private async Task InitOneDrive() { string[] scopes = { "onedrive.readonly", "wl.signin" }; try { // get provider authenticationProvider = new OnlineIdAuthenticationProvider(scopes); await authenticationProvider.RestoreMostRecentFromCacheOrAuthenticateUserAsync(); // init client oneDriveClient = new OneDriveClient(BaseUrl, authenticationProvider); } catch (Exception e) { Analytics.TrackEvent("Exception when initializing OneDrive", new Dictionary <string, string> { { "Error", e.Message }, { "InnerError", e.InnerException != null ? e.InnerException.Message : "" }, { "Where", "MainPage.xaml:InitOneDrive" } }); authenticationProvider = null; oneDriveClient = null; throw; } }
/// <summary> /// OneDriveとの接続が確立された時 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public async void OnOneDriveConnectionEstablished(object sender, OneDriveConnectionEstablishedEventArgs e) { this.client = e.Client; // ルートディレクトリのファイル・フォルダリストを作成する await this.UpdateDirectoryAsync(); }
public async Task Authenticate() { var msaAuthenticationProvider = new OnlineIdAuthenticationProvider(new string[] { "onedrive.readwrite" }); await msaAuthenticationProvider.AuthenticateUserAsync(); client = new OneDriveClient("https://api.onedrive.com/v1.0", msaAuthenticationProvider); }
protected override void OnNavigatedTo(NavigationEventArgs e) { var parameters = (VideoNavigationParameter)e.Parameter; oneDriveClient = parameters.oneDriveClient; pathComponents = parameters.PathComponents; _ = SetVideoSourceKeepingPlaytime(true); }
private async void ConnectOneDriveServer() { //이미 연결중이면 수행하지 않음. if (IsConnecting) { return; } //현재 연결이 되어 있다면 연결 해제 await DisconnectOneDriveServer(false); //연결중... IsConnecting = true; ShowErrorMessage = false; var resource = ResourceLoader.GetForCurrentView(); string errMsg = resource.GetString("Message/Error/FailServerAuthentication"); //"인증에 실패하였습니다. 아이디/패스워드를 확인하세요. "; var isOrderByName = _Sort == SortType.Name || _Sort == SortType.NameDescending; Task authTask = null; var msaAuthProvider = new MsaAuthenticationProvider( this.oneDriveConsumerClientId, this.oneDriveConsumerReturnUrl, this.scopes, new CredentialVault(this.oneDriveConsumerClientId)); await msaAuthProvider.SignOutAsync(); authTask = msaAuthProvider.RestoreMostRecentFromCacheOrAuthenticateUserAsync(); OneDriveClient = new OneDriveClient(this.oneDriveConsumerBaseUrl, msaAuthProvider); AuthProvider = msaAuthProvider; try { await authTask; //서버타입 설정 ConnectedServerType = ServerTypes.OneDrive; await LoadOneDriveFoldersAsync(); //인증 성공 IsConnecting = false; IsDisconnected = false; } catch (ServiceException exception) { // Swallow the auth exception but write message for debugging. Debug.WriteLine(exception.Error.Message); pathStack.Clear(); IsConnecting = false; IsDisconnected = true; ShowOrderBy = false; } }
static private void scanRemoteFolder(OneDriveClient odc, Item dirItem, string relRemoteFolder) { FileHistory fh; if (!testFilePattern(relRemoteFolder, false)) { return; } fh = setRemoteFileEntry(relRemoteFolder, dirItem); addLog(!fh.remoteChanged, string.Format("r\tVerzeichnis \"{0}\" ({1}, {2})", relRemoteFolder.Substring(config.Options.RemoteBaseDir.Length - 1), fh.remoteChanged ? "1" : "0", fh.remoteWriteTime.ToString())); IItemChildrenCollectionPage childs = odc.Drive.Items[dirItem.Id].Children.Request().GetAsync().Result; while (true) { foreach (Item remoteItem in childs) { string relFullItemName = relRemoteFolder + remoteItem.Name; if (remoteItem.Folder != null) { relFullItemName += "/"; scanRemoteFolder(odc, remoteItem, relFullItemName); } else if (remoteItem.File != null) { if (!testFilePattern(relFullItemName, false)) { continue; } fh = setRemoteFileEntry(relFullItemName, remoteItem); addLog(!fh.remoteChanged, string.Format("r\tDatei: \"{0}\" ({1}, {2}, {3})", remoteItem.Name, fh.remoteChanged ? "1" : "0", fh.remoteWriteTime.ToString(), fh.remote_cTag)); } else { if (!testFilePattern(relFullItemName, false)) { continue; } bool isOneNote = remoteItem.AdditionalData != null && remoteItem.AdditionalData["package"] != null && remoteItem.AdditionalData["package"] is Newtonsoft.Json.Linq.JObject && ((Newtonsoft.Json.Linq.JObject)remoteItem.AdditionalData["package"]).GetValue("type").ToString() == "oneNote"; addLog(false, "HINWEIS: Datei wird übersprungen: " + relRemoteFolder + remoteItem.Name + (isOneNote ? " (OneNote Datei kann nicht gesichert werden)" : " (Inhaltstyp unbekannt)")); } } if (childs.NextPageRequest != null) { childs = childs.NextPageRequest.GetAsync().Result; continue; } break; } }
public void Initialize() { var authorization = new AuthenticationProvider(); var oneDriveClient = new OneDriveClient( "https://api.onedrive.com/v1.0", authorization); //, this.httpProvider.Object); }
public static void ClassInitialize(TestContext testContext) { if (!GlobalTestSettings.RunNetworkTests) { return; } string tokenFilePath = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "SyncProTesting", "OneDriveTestingToken.json"); if (!File.Exists(tokenFilePath)) { string tokenHelperPath = "OneDriveTokenHelper.exe"; Process p = Process.Start(tokenHelperPath, "/getToken /path \"" + tokenFilePath + "\""); Pre.Assert(p != null, "p != null"); p.WaitForExit(); if (p.ExitCode != 1) { throw new Exception("Failed to get token using OneDriveTokenHelper"); } //throw new FileNotFoundException("Token file was not present at path " + tokenFilePath); } string tokenContent = File.ReadAllText(tokenFilePath); var token = JsonConvert.DeserializeObject <TokenResponse>(tokenContent); if (!token.IsEncrypted) { // The token file is NOT encrypted. Immediately encrypt and save the file back to disk // for security before using it. token.Protect(); tokenContent = JsonConvert.SerializeObject(token, Formatting.Indented); File.WriteAllText(tokenFilePath, tokenContent); } // The token file on disk is encrypted. Decrypt the values for in-memory use. token.Unprotect(); using (OneDriveClient client = new OneDriveClient(token)) { client.TokenRefreshed += (sender, args) => { // The token was refreshed, so save a protected copy of the token to the token file. token = args.NewToken; token.SaveProtectedToken(tokenFilePath); }; client.GetUserProfileAsync().Wait(); } classCurrentToken = token; }
public void Constructor_BaseAddress_MustBeAsSpected() { var client = new OneDriveClient(TokenBuilder.Create().Build()); var expected = "https://graph.microsoft.com/v1.0/"; var value = client._HttpClient.BaseAddress.AbsoluteUri; Assert.Equal(expected, value); }
private void SignIn(object obj) { string logoutUri = OneDriveClient.GetDefaultLogoutUri(); string authorizationUri = OneDriveClient.GetDefaultAuthorizationUri(); AuthenticationResult authenticationResult = null; BrowserAuthenticationWindow authWindow = new BrowserAuthenticationWindow(); authWindow.Browser.Navigated += (sender, args) => { if (string.Equals(args.Uri.AbsolutePath, "/oauth20_logout.srf", StringComparison.OrdinalIgnoreCase)) { // The logout page has finished loading, so we can now load the login page. authWindow.Browser.Navigate(authorizationUri); } // If the browser is directed to the redirect URI, the new URI will contain the access code that we can use to // get a token for OneDrive. if (string.Equals(args.Uri.AbsolutePath, "ietf:wg:oauth:2.0:oob", StringComparison.OrdinalIgnoreCase)) { // We were directed back to the redirect URI. Extract the code from the query string Dictionary <string, string> queryParametes = args.Uri.GetQueryParameters(); if (queryParametes.ContainsKey("code")) { authenticationResult = new AuthenticationResult() { Code = queryParametes["code"] }; } // All done. Close the window. authWindow.Close(); } }; authWindow.Closed += (sender, args) => { if (authenticationResult == null) { return; } this.CanSignIn = false; this.SignInMessage = "Working..."; this.Adapter.SignIn(authenticationResult).ContinueWith(t => this.SetSignInStatus()); }; authWindow.Loaded += (sender, args) => { authWindow.Browser.Navigate(logoutUri); NativeMethods.User32.SetForegroundWindow(new WindowInteropHelper(authWindow).Handle); }; authWindow.ShowDialog(); }
private async Task SignIn(ClientType clientType) { if (this.oneDriveClient == null) { this.oneDriveClient = clientType == ClientType.Consumer ? OneDriveClient.GetMicrosoftAccountClient( FormBrowser.MsaClientId, FormBrowser.MsaReturnUrl, FormBrowser.Scopes, webAuthenticationUi: new FormsWebAuthenticationUi()) : BusinessClientExtensions.GetClient( new BusinessAppConfig { ActiveDirectoryAppId = FormBrowser.AadClientId, ActiveDirectoryReturnUrl = FormBrowser.AadReturnUrl, }); } try { if (!this.oneDriveClient.IsAuthenticated) { await this.oneDriveClient.AuthenticateAsync(); } await LoadFolderFromPath(); UpdateConnectedStateUx(true); } catch (OneDriveException exception) { // Swallow authentication cancelled exceptions, but reset the client if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString())) { if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString())) { MessageBox.Show( "Authentication failed", "Authentication failed", MessageBoxButtons.OK); ((OneDriveClient)this.oneDriveClient).Dispose(); this.oneDriveClient = null; } else { PresentOneDriveException(exception); } } else { ((OneDriveClient)this.oneDriveClient).Dispose(); this.oneDriveClient = null; } } }
internal async void Authenticate() { MsaAuthenticationProvider msaAuthProvider = new MsaAuthenticationProvider(clientID, "https://login.live.com/oauth20_desktop.srf", scopes); await msaAuthProvider.AuthenticateUserAsync(); OneDriveClient oneDriveClient = new OneDriveClient("https://api.onedrive.com/v1.0", msaAuthProvider); OneDriveClient = oneDriveClient; }
private async Task SilentAuthenticate() { if (authenticator == null) { InitAuthenticator(); } await authenticator.RestoreMostRecentFromCacheAsync(); client = new OneDriveClient("https://api.onedrive.com/v1.0", authenticator); }
public OneDriveFileSystem() { var client = new OneDriveClient(); client.ApplicationId = "000000004418B915"; client.AuthorizationProvider = new AuthorizationCodeProvider(); client.RefreshTokenHandler = new MemoryRefreshTokenHandler(); Client = client; }
/* * One Drive Initialization - Uses the Web Forms Authenticator */ public async void initOneDriveAPI() { oneDriveClient = OneDriveClient.GetMicrosoftAccountClient( onedrive_client_id, onedrive_redirect_uri, onedrive_scope, webAuthenticationUi: new FormsWebAuthenticationUi() ); Console.WriteLine("OneDrive auth? " + oneDriveClient.IsAuthenticated); }
public async void Starter(string accessToken) { string[] scopes = new string[] { "onedrive.readonly", "wl.signin" }; var msaAuthenticationProvider = new MsaAuthenticationProvider(accessToken, "https://login.live.com/oauth20_desktop.srf", scopes); await msaAuthenticationProvider.AuthenticateUserAsync(); oneDriveClient = new OneDriveClient(msaAuthenticationProvider); Getroot(); }
// public OneDriveService inse = Microsoft.Toolkit.Services.OneDrive.OneDriveService.Instance.Initialize( appClientId:OneDriveService., scopes, null, null); private async void btn_Login_Click(object sender, RoutedEventArgs e) { if (this.oneDriveClient == null) { try { // Setting up the client here, passing in our Client Id, Return Url, // Scopes that we want permission to, and building a Web Broker to // go do our authentication. this.oneDriveClient = await OneDriveClient.GetAuthenticatedMicrosoftAccountClient( clientId, returnUrl, scopes, webAuthenticationUi : new WebAuthenticationBrokerWebAuthenticationUi()); // Show in text box that we are connected. txtBox_Response.Text = "We are now connected"; // We are either just autheticated and connected or we already connected, // either way we need the drive button now. btn_GetDriveId.Visibility = Visibility.Visible; } catch (OneDriveException exception) { // Eating the authentication cancelled exceptions and resetting our client. if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString())) { if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString())) { txtBox_Response.Text = "Authentication failed/cancelled, disposing of the client..."; ((OneDriveClient)this.oneDriveClient).Dispose(); this.oneDriveClient = null; } else { // Or we failed due to someother reason, let get that exception printed out. txtBox_Response.Text = exception.Error.ToString(); } } else { ((OneDriveClient)this.oneDriveClient).Dispose(); this.oneDriveClient = null; } } } }
public static async Task <IOneDriveClient> GetOneDriveClientForAccountAsync(Account account) { try { return(await OneDriveClient.GetSilentlyAuthenticatedMicrosoftAccountClient(AppClientID, RedirectUri, Scopes, AppClientSecret, account.RefreshToken)); } catch (OneDriveException ex) { System.Diagnostics.Debug.WriteLine(ex.ToString()); } return(null); }
private async void ExecuteSingIn() { if (this._OneDriveClient == null) { this._OneDriveClient = OneDriveClient.GetMicrosoftAccountClient( ClientId, ReturnUrl, Scopes, webAuthenticationUi: new FormsWebAuthenticationUi()); } try { if (!this._OneDriveClient.IsAuthenticated) { await this._OneDriveClient.AuthenticateAsync(); } if (this._OneDriveClient.IsAuthenticated) { MessageBox.Show( "Authentication was successful", "Authentication was successful", MessageBoxButton.OK); } } catch (OneDriveException exception) { if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString())) { if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString())) { MessageBox.Show( "Authentication failed", "Authentication failed", MessageBoxButton.OK); var httpProvider = this._OneDriveClient.HttpProvider as HttpProvider; if (httpProvider != null) { httpProvider.Dispose(); } this._OneDriveClient = null; } else { throw; } } } }
/// <summary> /// 認証が完了した時 /// </summary> /// <param name="sender">送信者</param> /// <param name="e">イベント</param> public async void OnAuthenticationFinished(object sender, OneDriveAuthFinishedEventArgs e) { this.client = new OneDriveClient(e.Provider); this.OneDriveConnectionEstablished?.Invoke(this, new OneDriveConnectionEstablishedEventArgs(this.client)); //var status = "ログインに成功しました\nRoot直下:\n"; //var rootChildren = await this.client.Drive.Root.Children.Request().GetAsync(); //foreach (var c in rootChildren) //{ // status += " " + c.Name + "\n"; //} //this.Status = status; }
/// <summary> /// Signs user out of OneDrive. /// </summary> public async Task SignOutAsync() { try { await authProvider.SignOutAsync(); drive = null; } finally { oneDriveClient = null; } }
private static async Task<OneDriveClient> OnAuthComplete(LiveAuthClient authClient, AuthResult result) { if (null != result.AuthorizeCode) { try { LiveConnectSession session = await authClient.ExchangeAuthCodeAsync(result.AuthorizeCode); var OneDrive = new OneDriveClient(new LiveConnectClient(session)); return OneDrive; } catch (LiveAuthException aex) { throw; } catch (LiveConnectException cex) { throw; } } return null; ; }