示例#1
0
        public void Setup()
        {
            this.appConfig = new AppConfig();
            this.authenticationProvider = new MockAuthenticationProvider();
            this.authenticationProvider.Setup(provider => provider.AppendAuthHeaderAsync(It.IsAny <HttpRequestMessage>())).Returns(Task.FromResult(0));
            this.credentialCache     = new MockCredentialCache();
            this.serializer          = new MockSerializer();
            this.httpResponseMessage = new HttpResponseMessage();
            this.httpProvider        = new MockHttpProvider(this.httpResponseMessage, this.serializer.Object);
            this.serviceInfo         = new ServiceInfo
            {
                AuthenticationProvider = this.authenticationProvider.Object,
            };

            this.serviceInfoProvider = new MockServiceInfoProvider(this.serviceInfo);
            this.webUi          = new MockWebUi();
            this.oneDriveClient = new OneDriveClient(
                this.appConfig,
                this.credentialCache.Object,
                this.httpProvider.Object,
                this.serviceInfoProvider.Object)
            {
                BaseUrl     = Constants.Authentication.OneDriveConsumerBaseUrl,
                ServiceInfo = this.serviceInfo,
            };
        }
示例#2
0
        public async Task <bool> AuthenticateAsync()
        {
            try
            {
                oneDriveClient = OneDriveClientExtensions.GetUniversalClient(Scopes);
                await oneDriveClient.AuthenticateAsync();
            }
            catch
            {
                System.Diagnostics.Debug.WriteLine("Fail auth. Make sure app is registered in store.");
            }

            try
            {
                // little hack to make shure the service works
                await oneDriveClient.Drive.Request().GetAsync();

                IsAuthenticated = true;
            }
            catch (Exception)
            {
                IsAuthenticated = false;
            }

            return(IsAuthenticated);
        }
示例#3
0
        public async Task <IOneDriveClient> LoginAsync()
        {
            try {
                if (oneDriveClient == null)
                {
                    oneDriveClient = OneDriveClientExtensions.GetUniversalClient(ServiceConstants.Scopes);
                    await oneDriveClient.AuthenticateAsync();
                }

                if (!oneDriveClient.IsAuthenticated)
                {
                    await oneDriveClient.AuthenticateAsync();
                }

                return(oneDriveClient);
            }
            catch (OneDriveException exception) {
                // Swallow authentication cancelled exceptions
                if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString()))
                {
                    if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString()))
                    {
                        await dialogService.ShowMessage(
                            "Authentication failed",
                            "Authentication failed");
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            return(oneDriveClient);
        }
示例#4
0
        public async Task <bool> AuthenticateNew(CancellationToken cs)
        {
            //msaAuthenticationProvider = new MsaAuthenticationProvider(MicrosoftSecret.ClientId, MicrosoftSecret.ClientSecret, "http://localhost:8000/callback.html", Scopes, null, new CredentialsVault(this, null));
            //await msaAuthenticationProvider.AuthenticateUserAsync().ConfigureAwait(false);

            //oneDriveClient = new OneDriveClient("https://api.onedrive.com/v1.0", msaAuthenticationProvider);

            //return msaAuthenticationProvider.IsAuthenticated;


            Task authTask;
            var  adalAuthProvider = new AdalAuthenticationProvider(
                "053488e0-5bf2-467b-8866-45d00c5b187b",
                "https://boschsg.onmicrosoft.com/OneDriveApi2");

            //oneDriveClient = new OneDriveClient("https://boschsg-my.sharepoint.com" + "/_api/v2.0", adalAuthProvider);
            oneDriveClient = new OneDriveClient("https://boschsg-my.sharepoint.com" + "/_api/v2.0", adalAuthProvider);

            authTask = adalAuthProvider.AuthenticateUserAsync("https://boschsg-my.sharepoint.com");
            try
            {
                await authTask;
            }
            catch (ServiceException exception)
            {
                Console.WriteLine(exception.Error);
            }

            return(true);
        }
 private async void OnOneDriveWebViewLogin(object sender, RoutedEventArgs e)
 {
     _client = OneDriveClientExtensions.GetClientUsingWebAuthenticationBroker(ClientId, Scopes);
     await _client.AuthenticateAsync();
     refreshToken = _client.AuthenticationProvider.CurrentAccountSession.RefreshToken;
     ApplicationData.Current.LocalSettings.Values["RefreshToken"] = refreshToken;
 }
示例#6
0
        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();
        }
示例#7
0
 public async Task Setup()
 {
     // onedrive
     var scopes = new string[] { "wl.basic", "wl.signin", "onedrive.readwrite" };
     client = OneDriveClientExtensions.GetUniversalClient(scopes);
     session = await client.AuthenticateAsync();
 }
 /// <summary>
 /// Constructs a new ThumbnailContentRequest.
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 /// </summary>
 public ThumbnailContentRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList <Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
示例#9
0
        /// <summary>
        /// Constructs a new <see cref="BaseRequest"/>.
        /// </summary>
        /// <param name="requestUrl">The URL for the request.</param>
        /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
        /// <param name="options">The header and query options for the request.</param>
        public BaseRequest(
            string requestUrl,
            IOneDriveClient oneDriveClient = null,
            IEnumerable <Option> options   = null)
        {
            this.Method         = "GET";
            this.OneDriveClient = oneDriveClient;
            this.Headers        = new List <HeaderOption>();
            this.QueryOptions   = new List <QueryOption>();

            this.RequestUrl = this.InitializeUrl(requestUrl);

            if (options != null)
            {
                var headerOptions = options.OfType <HeaderOption>();
                if (headerOptions != null)
                {
                    ((List <HeaderOption>) this.Headers).AddRange(headerOptions);
                }

                var queryOptions = options.OfType <QueryOption>();
                if (queryOptions != null)
                {
                    ((List <QueryOption>) this.QueryOptions).AddRange(queryOptions);
                }
            }

            this.requestStatsHeaderValue = string.Format(
                Constants.Headers.RequestStatsFormatString,
                this.GetType().GetTypeInfo().Assembly.GetName().Version);
        }
        private async void Continue_Tapped(object sender, TappedRoutedEventArgs e)
        {
            try
            {
                MainPage.ShowLoader(ResourceLoader.GetForCurrentView().GetString("SynchronizingAccountsWithCloud"));

                IOneDriveClient oneDriveClient = OneDriveClientExtensions.GetUniversalClient(new[] { "onedrive.appfolder" });
                AccountSession  session        = await oneDriveClient.AuthenticateAsync();

                IEncrypter encrypter = new AESEncrypter();

                if (session.AccountType == AccountType.MicrosoftAccount)
                {
                    synchronizer.SetEncrypter(encrypter, userKey);
                    await AccountStorage.Instance.Synchronize();

                    MainPage.HideLoader();

                    Frame.Navigate(typeof(SetupSynchronizationFinishedPage), mainPage);
                }
            }
            catch (OneDriveException ex)
            {
                MessageDialog dialog = GetOneDriveErrorMessageDialog(ex);
                await dialog.ShowAsync();
            }
        }
示例#11
0
        private async void btnLogin_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                oneDriveClient = OneDriveClientExtensions.GetUniversalClient(scopes);
                var accountSession = await oneDriveClient.AuthenticateAsync();

                if (accountSession != null)
                {
                    var rootItem = await oneDriveClient
                                   .Drive
                                   .Root
                                   .Request()
                                   .GetAsync();

                    var items = await oneDriveClient
                                .Drive
                                .Items[rootItem.Id]
                                .Children
                                .Request()
                                .GetAsync();
                    gridView.ItemsSource = items.CurrentPage;
                }
            }
            catch (OneDriveException oe)
            {
                txtMsg.Text = "登陆失败";
            }
        }
 /// <summary>
 /// Constructs a new SharesCollectionRequest.
 /// </summary>
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 public SharesCollectionRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList <Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
 /// <summary>
 /// Constructs a new ThumbnailRequest.
 /// </summary>
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 public ThumbnailRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList<Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
示例#14
0
        async Task <bool> get_authorize()
        {
            var msaAuthProvider = new MsaAuthenticationProvider(
                MsaClientId,
                MsaReturnUrl,
                Scopes,
                new CredentialVault(MsaClientId)
                );

            try
            {
                await msaAuthProvider.RestoreMostRecentFromCacheOrAuthenticateUserAsync();

                oneDriveClient = new OneDriveClient("https://api.onedrive.com/v1.0", msaAuthProvider);
                return(true);
            }
            catch (ServiceException ex)
            {
                MessageBox.Show(
                    ex.Error.Message,
                    "Authentication failed",
                    MessageBoxButtons.OK);
                return(false);
            }
        }
示例#15
0
 /// <summary>
 /// Constructs a new DriveAllPhotosRequest.
 /// </summary>
 public DriveAllPhotosRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList <Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
示例#16
0
        private async void btnLogin_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                oneDriveClient = OneDriveClientExtensions.GetUniversalClient(scopes);
                var accountSession = await oneDriveClient.AuthenticateAsync();

                if (accountSession!=null)
                {
                    var rootItem = await oneDriveClient
                                        .Drive
                                        .Root
                                        .Request()
                                        .GetAsync();

                   var items=await oneDriveClient
                                          .Drive
                                          .Items[rootItem.Id]
                                          .Children
                                          .Request()
                                          .GetAsync();
                    gridView.ItemsSource = items.CurrentPage;
                }
            }
            catch (OneDriveException oe)
            {
                txtMsg.Text="登陆失败";
            }
        }
示例#17
0
 /// <summary>
 /// Constructs a new ItemRequest.
 /// </summary>
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 public ItemRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList <Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
 /// <summary>
 /// Constructs a new SpecialCollectionRequest.
 /// </summary>
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 public SpecialCollectionRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList<Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
 /// <summary>
 /// Constructs a new DriveSharedWithMeRequest.
 /// </summary>
 public DriveSharedWithMeRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList <Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="OneDriveRequestSource{T}"/> class.
 /// </summary>
 /// <param name="provider">OneDrive Data Client Provider</param>
 /// <param name="requestBuilder">Http request to execute</param>
 /// <param name="orderBy">Sort the order of items in the response collection</param>
 /// <param name="filter">Filters the response based on a set of criteria.</param>
 public OneDriveRequestSource(IOneDriveClient provider, IItemRequestBuilder requestBuilder, OrderBy orderBy, string filter)
 {
     _provider       = provider;
     _requestBuilder = requestBuilder;
     _orderBy        = orderBy;
     _filter         = filter;
 }
 /// <summary>
 /// Constructs a new PermissionRequest.
 /// </summary>
 /// <param name="requestUrl">The request URL.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 /// <param name="options">Query option name value pairs for the request.</param>
 public PermissionRequest(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     IList<Option> options)
     : base(requestUrl, oneDriveClient, options)
 {
 }
示例#22
0
        /// <inheritdoc/>
        public async Task <bool> LoginAsync()
        {
            _isConnected = false;

            if (!_isInitialized)
            {
                throw new InvalidOperationException("Microsoft OneDrive not initialized.");
            }

            OneDriveAuthenticationHelper.ResourceUri = "https://api.onedrive.com/v1.0";
            if (_accountProviderType == AccountProviderType.Msa)
            {
                _accountProvider = OneDriveAuthenticationHelper.CreateMSAAuthenticationProvider(_appClientId, _scopes);
                await OneDriveAuthenticationHelper.AuthenticateMsaUserAsync();
            }
            else if (_accountProviderType == AccountProviderType.OnlineId)
            {
                _accountProvider = new OnlineIdAuthenticationProvider(_scopes);
                await((OnlineIdAuthenticationProvider)_accountProvider).RestoreMostRecentFromCacheOrAuthenticateUserAsync();
            }

            _oneDriveProvider = new OneDriveClient(OneDriveAuthenticationHelper.ResourceUri, _accountProvider);
            _isConnected      = true;
            return(_isConnected);
        }
        public void Setup()
        {
            this.appConfig = new AppConfig();
            this.authenticationProvider = new MockAuthenticationProvider();
            this.authenticationProvider.Setup(provider => provider.AuthenticateAsync()).Returns(Task.FromResult(new AccountSession()));
            this.authenticationProvider.Setup(provider => provider.AppendAuthHeaderAsync(It.IsAny<HttpRequestMessage>())).Returns(Task.FromResult(0));
            this.credentialCache = new MockCredentialCache();
            this.serializer = new MockSerializer();
            this.httpResponseMessage = new HttpResponseMessage();
            this.httpProvider = new MockHttpProvider(this.httpResponseMessage, this.serializer.Object);
            this.serviceInfo = new ServiceInfo
            {
                AuthenticationProvider = this.authenticationProvider.Object,
            };

            this.serviceInfoProvider = new MockServiceInfoProvider(this.serviceInfo);
            this.webUi = new MockWebAuthenticationUi();
            this.oneDriveClient = new OneDriveClient(
                this.appConfig,
                this.credentialCache.Object,
                this.httpProvider.Object,
                this.serviceInfoProvider.Object)
            {
                BaseUrl = string.Format(Constants.Authentication.OneDriveConsumerBaseUrlFormatString, "v1.0"),
                ServiceInfo = this.serviceInfo,
            };
        }
示例#24
0
        /// <summary>
        ///  Initializes a new instance of the <see cref="OneDriveStorageItem"/> class.
        /// </summary>
        /// <param name="oneDriveProvider">Instance of OneDriveClient class</param>
        /// <param name="requestBuilder">Http request builder.</param>
        /// <param name="oneDriveItem">OneDrive's item</param>
        public OneDriveStorageItem(IOneDriveClient oneDriveProvider, IItemRequestBuilder requestBuilder, Item oneDriveItem)
        {
            _requestBuilder   = requestBuilder;
            _oneDriveProvider = oneDriveProvider;
            _oneDriveItem     = oneDriveItem;
            _name             = oneDriveItem.Name;
            _dateCreated      = oneDriveItem.CreatedDateTime;
            _dateModified     = oneDriveItem.LastModifiedDateTime;
            _displayName      = _name;
            _folderId         = oneDriveItem.Id;
            if (IsFile())
            {
                _displayType = "File";
            }
            else if (IsFolder())
            {
                _displayType = "Folder";
            }
            else
            {
                _displayType = "OneNote";
            }

            // ParentReference null means is root
            if (oneDriveItem.ParentReference != null)
            {
                _path = oneDriveItem.ParentReference.Path.Replace("/drive/root:", string.Empty);
            }
        }
 public ItemSearchRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     string q = null)
     : base(requestUrl, oneDriveClient)
 {
     this.Q = q;
 }
示例#26
0
        private void Page_Loaded(object sender, RoutedEventArgs e)
        {
            oneDriveClient = OneDriveClientExtensions.GetUniversalClient(new[] { "onedrive.appfolder" });

            vault = new PasswordVault();

            ShowInformation();
        }
示例#27
0
 public ItemCreateLinkRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     string type = null)
     : base(requestUrl, oneDriveClient)
 {
     this.Type = type;
 }
        private async void OnOneDriveWebViewLogin(object sender, RoutedEventArgs e)
        {
            _client = OneDriveClientExtensions.GetClientUsingWebAuthenticationBroker(ClientId, Scopes);
            await _client.AuthenticateAsync();

            refreshToken = _client.AuthenticationProvider.CurrentAccountSession.RefreshToken;
            ApplicationData.Current.LocalSettings.Values["RefreshToken"] = refreshToken;
        }
     /// <summary>
     /// Constructs a new DriveSharedWithMeRequest.
     /// </summary>
     public DriveSharedWithMeRequest(
         string requestUrl,
         IOneDriveClient oneDriveClient,
         IList<Option> options)
         : base(requestUrl, oneDriveClient, options)
     {
 
     }
 public ItemCreateSessionRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     ChunkedUploadSessionDescriptor item = null)
     : base(requestUrl, oneDriveClient)
 {
     this.Item = item;
 }
     /// <summary>
     /// Constructs a new ItemAllPhotosRequest.
     /// </summary>
     public ItemAllPhotosRequest(
         string requestUrl,
         IOneDriveClient oneDriveClient,
         IList<Option> options)
         : base(requestUrl, oneDriveClient, options)
     {
 
     }
 public ItemDeltaRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     string token = null)
     : base(requestUrl, oneDriveClient)
 {
     this.Token = token;
 }
        public async Task <bool> AuthenticateSaved(CancellationToken cs, string save)
        {
            msaAuthenticationProvider = new MsaAuthenticationProvider(MicrosoftSecret.ClientId, MicrosoftSecret.ClientSecret, "http://localhost:45674/authredirect", Scopes, null, new CredentialsVault(this, save));
            await msaAuthenticationProvider.RestoreMostRecentFromCacheOrAuthenticateUserAsync().ConfigureAwait(false);

            oneDriveClient = new OneDriveClient("https://api.onedrive.com/v1.0", msaAuthenticationProvider);

            return(msaAuthenticationProvider.IsAuthenticated);
        }
 public OneDriveCloudService(
     IOneDriveClient oneDriveClient,
     ISimpleDataStorage simpleDataStorage,
     IClock clock)
 {
     _oneDriveClient    = oneDriveClient;
     _simpleDataStorage = simpleDataStorage;
     _clock             = clock;
 }
        /// <summary>
        /// Signs in the user
        /// </summary>
        /// <returns>Returns success or failure of login attempt.</returns>
        public override async Task <bool> LoginAsync()
        {
            IsConnected = false;

            if (!IsInitialized)
            {
                throw new InvalidOperationException("Microsoft OneDrive not initialized.");
            }

            string resourceEndpointUri = null;

            if (_accountProviderType == AccountProviderType.Adal)
            {
                DiscoveryService  discoveryService  = null;
                DiscoverySettings discoverySettings = DiscoverySettings.Load();

                if (discoverySettings == null)
                {
                    // For OneDrive for business only
                    var authDiscoveryResult = await OneDriveAuthenticationHelper.AuthenticateAdalUserForDiscoveryAsync(AppClientId);

                    discoveryService = await OneDriveAuthenticationHelper.GetUserServiceResource(authDiscoveryResult);

                    discoverySettings = new DiscoverySettings {
                        ServiceEndpointUri = discoveryService.ServiceEndpointUri, ServiceResourceId = discoveryService.ServiceResourceId
                    };
                    discoverySettings.Save();
                }

                OneDriveAuthenticationHelper.ResourceUri = discoverySettings.ServiceResourceId;
                _accountProvider = OneDriveAuthenticationHelper.CreateAdalAuthenticationProvider(AppClientId);
                await OneDriveAuthenticationHelper.AuthenticateAdalUserAsync(true);

                resourceEndpointUri = discoverySettings.ServiceEndpointUri;
            }
            else if (_accountProviderType == AccountProviderType.Msa)
            {
                OneDriveAuthenticationHelper.ResourceUri = "https://api.onedrive.com/v1.0";
                _accountProvider = OneDriveAuthenticationHelper.CreateMSAAuthenticationProvider(AppClientId, Scopes);

                await((MsaAuthenticationProvider)OneDriveAuthenticationHelper.AuthenticationProvider).RestoreMostRecentFromCacheOrAuthenticateUserAsync();
                resourceEndpointUri = OneDriveAuthenticationHelper.ResourceUri;
            }
            else if (_accountProviderType == AccountProviderType.OnlineId)
            {
                OneDriveAuthenticationHelper.ResourceUri = "https://api.onedrive.com/v1.0";
                _accountProvider = new OnlineIdAuthenticationProvider(Scopes);
                await((MsaAuthenticationProvider)_accountProvider).RestoreMostRecentFromCacheOrAuthenticateUserAsync();
                resourceEndpointUri = OneDriveAuthenticationHelper.ResourceUri;
            }

            _oneDriveProvider = new OneDriveClient(resourceEndpointUri, _accountProvider);

            IsConnected = true;
            return(IsConnected);
        }
 public ItemCopyRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient,
     string name = null,
     ItemReference parentReference = null)
     : base(requestUrl, oneDriveClient)
 {
     this.Name            = name;
     this.ParentReference = parentReference;
 }
        public ItemSearchRequestBuilder(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            string q = null)
            : base(requestUrl, oneDriveClient)
        {
            
                this.Q = q;

        }
 /// <summary>
 /// Initializes the NextPageRequest property.
 /// </summary>
 public void InitializeNextPageRequest(IOneDriveClient oneDriveClient, string nextPageLinkString)
 {
     if (!string.IsNullOrEmpty(nextPageLinkString))
     {
         this.NextPageRequest = new ItemSearchRequest(
             nextPageLinkString,
             oneDriveClient,
             null);
     }
 }
        public ItemCreateLinkRequestBuilder(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            string type = null)
            : base(requestUrl, oneDriveClient)
        {
            
                this.Type = type;

        }
        public async Task SignOut(string save)
        {
            if (oneDriveClient != null)
            {
                await msaAuthenticationProvider.SignOutAsync();

                msaAuthenticationProvider = null;
                oneDriveClient            = null;
            }
        }
        public ItemDeltaRequestBuilder(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            string token = null)
            : base(requestUrl, oneDriveClient)
        {
            
                this.Token = token;

        }
 /// <summary>
 /// Initializes the NextPageRequest property.
 /// </summary>
 public void InitializeNextPageRequest(IOneDriveClient oneDriveClient, string nextPageLinkString)
 {
     if (!string.IsNullOrEmpty(nextPageLinkString))
     {
         this.NextPageRequest = new ThumbnailsCollectionRequest(
             nextPageLinkString,
             oneDriveClient,
             null);
     }
 }
        public ItemCreateSessionRequestBuilder(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            ChunkedUploadSessionDescriptor item = null)
            : base(requestUrl, oneDriveClient)
        {
            
                this.Item = item;

        }
        public ItemCopyRequestBuilder(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            string name = null,
            ItemReference parentReference = null)
            : base(requestUrl, oneDriveClient)
        {
            
                this.Name = name;
                this.ParentReference = parentReference;

        }
        public void Setup()
        {
            this.authenticationProvider = new MockAuthenticationProvider();
            this.serializer = new MockSerializer();
            this.httpResponseMessage = new HttpResponseMessage();
            this.httpProvider = new MockHttpProvider(this.httpResponseMessage, this.serializer.Object);

            this.oneDriveClient = new OneDriveClient(
                "https://api.onedrive.com/v1.0",
                this.authenticationProvider.Object,
                this.httpProvider.Object);
        }
示例#46
0
 async private void Initialize()
 {
     try
     {
         if (oneDriveClient == null)
         {
             oneDriveClient = OneDriveClientExtensions.GetClientUsingOnlineIdAuthenticator(scopes);
             await oneDriveClient.AuthenticateAsync();
         }
     }
     catch (Exception ex)
     {
     }
 }
     /// <summary>
     /// Constructs a new ItemCreateSessionRequest.
     /// </summary>
     public ItemCreateSessionRequest(
         string requestUrl,
         IOneDriveClient oneDriveClient,
         IList<Option> options,
         ChunkedUploadSessionDescriptor item = null)
         : base(requestUrl, oneDriveClient, options)
     {
 
         this.Method = "POST";
         this.ContentType = "application/json";
         this.RequestBody = new ItemCreateSessionRequestBody();
         this.RequestBody.Item = item;
 
     }
     /// <summary>
     /// Constructs a new ItemCreateLinkRequest.
     /// </summary>
     public ItemCreateLinkRequest(
         string requestUrl,
         IOneDriveClient oneDriveClient,
         IList<Option> options,
         string type = null)
         : base(requestUrl, oneDriveClient, options)
     {
 
         this.Method = "POST";
         this.ContentType = "application/json";
         this.RequestBody = new ItemCreateLinkRequestBody();
         this.RequestBody.Type = type;
 
     }
        public async Task<IOneDriveClient> LoginAsync()
        {
            if (oneDriveClient == null)
            {
                oneDriveClient = OneDriveClient.GetMicrosoftAccountClient(
                    ServiceConstants.MSA_CLIENT_ID,
                    ServiceConstants.RETURN_URL,
                    ServiceConstants.Scopes,
                    ServiceConstants.MSA_CLIENT_SECRET,
                    null, null,
                    new CustomServiceInfoProvider());
                try
                {
                    await oneDriveClient.AuthenticateAsync();
                }
                catch (Exception ex)
                {
                    Debug.Write(ex);
                }
            }

            try
            {
                if (!oneDriveClient.IsAuthenticated)
                {
                    await oneDriveClient.AuthenticateAsync();
                }

                return oneDriveClient;
            }
            catch (OneDriveException exception)
            {
                // Swallow authentication cancelled exceptions
                if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString()))
                {
                    if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString()))
                    {
                        await dialogService.ShowMessage(
                            "Authentication failed",
                            "Authentication failed");
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            return oneDriveClient;
        }
示例#50
0
文件: SplashVM.cs 项目: liquidboy/X
 private async void AADAuthenticate()
 {
     if (oneDriveClient != null) return;
     oneDriveClient = BusinessClientExtensions.GetClient(
         new AppConfig()
         {
             ActiveDirectoryAppId = _clientIDAAD,
             ActiveDirectoryClientSecret = _clientSecretAAD,
             ActiveDirectoryReturnUrl = _returnUrlAAD,
             ActiveDirectoryServiceEndpointUrl = _oneDriveApiEndpointAAD,
             ActiveDirectoryServiceResource = _serviceResourceIdAAD,
             ActiveDirectoryAuthenticationServiceUrl = _serviceUrlAAD
         });
     await oneDriveClient?.AuthenticateAsync();
 }
        /// <summary>
        /// Constructs a new ItemDeltaRequest.
        /// </summary>
        public ItemDeltaRequest(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            IList<Option> options,
            string token = null)
            : base(requestUrl, oneDriveClient, options)
        {
    
            this.Method = "GET";

            if (token != null)
            {
                this.QueryOptions.Add(new QueryOption("token", token));
            }
    
        }
        /// <summary>
        /// Constructs a new ItemSearchRequest.
        /// </summary>
        public ItemSearchRequest(
            string requestUrl,
            IOneDriveClient oneDriveClient,
            IList<Option> options,
            string q = null)
            : base(requestUrl, oneDriveClient, options)
        {
    
            this.Method = "GET";

            if (q != null)
            {
                this.QueryOptions.Add(new QueryOption("q", q));
            }
    
        }
示例#53
0
        public async Task<AccountSession> Initialize()
        {
            // onedrive
            try
            {
                var scopes = new string[] { "wl.basic", "wl.signin", "onedrive.readwrite" };
                client = OneDriveClientExtensions.GetUniversalClient(scopes);
                return await client.AuthenticateAsync();
            }
            catch (Exception)
            {

                throw;
            }

        }
     /// <summary>
     /// Constructs a new ItemCopyRequest.
     /// </summary>
     public ItemCopyRequest(
         string requestUrl,
         IOneDriveClient oneDriveClient,
         IList<Option> options,
         string name = null,
         ItemReference parentReference = null)
         : base(requestUrl, oneDriveClient, options)
     {
 
         this.Method = "POST";
         this.Headers.Add(new HeaderOption("Prefer", "respond-async"));
         this.ContentType = "application/json";
         this.RequestBody = new ItemCopyRequestBody();
         this.RequestBody.Name = name;
         this.RequestBody.ParentReference = parentReference;
 
     }
示例#55
0
        private async void saveToOneDriveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (oneDriveClient == null)
            {
                oneDriveClient = OneDriveClient.GetMicrosoftAccountClient(
                    OneDriveClientID,
                    "https://login.live.com/oauth20_desktop.srf",
                    new string[] { "onedrive.readwrite", "wl.offline_access", "wl.signin" },
                    webAuthenticationUi: new FormsWebAuthenticationUi());
            }

            try
            {
                if (!oneDriveClient.IsAuthenticated)
                {
                    await oneDriveClient.AuthenticateAsync();
                }
            }
            catch (OneDriveException)
            {
                MessageBox.Show("Authentication failed", "Error", MessageBoxButtons.OK);
                return;
            }

            try
            {
                var tmpFile = System.IO.Path.GetTempFileName();
                System.IO.File.WriteAllText(tmpFile, txContent.Text);
                var stream = new System.IO.FileStream(tmpFile, System.IO.FileMode.Open);
                var filename = DateTime.Now.ToString("yyyy_MM_dd_mm_ss") + "_MonoChat.txt";
                var uploadPath = @"/drive/items/root:/" + filename;
                var uploadedItem =
                    await
                        this.oneDriveClient.ItemWithPath(uploadPath).Content.Request().PutAsync<Item>(stream);

                MessageBox.Show("Chat histroy saved!", "Success", MessageBoxButtons.OK);
                stream.Close();
            }
            catch (Exception)
            {
                MessageBox.Show("Chat histroy could not be saved!", "Error", MessageBoxButtons.OK);
            }
        }
        public async Task<IOneDriveClient> LoginAsync()
        {
            if (oneDriveClient == null)
            {
                oneDriveClient = OneDriveClientExtensions.GetClientUsingWebAuthenticationBroker(MSA_CLIENT_ID, scopes);
                await oneDriveClient.AuthenticateAsync();
            }

            try
            {
                if (!oneDriveClient.IsAuthenticated)
                {
                    await oneDriveClient.AuthenticateAsync();
                }

                return oneDriveClient;
            }
            catch (OneDriveException exception)
            {
                // Swallow authentication cancelled exceptions
                if (!exception.IsMatch(OneDriveErrorCode.AuthenticationCancelled.ToString()))
                {
                    if (exception.IsMatch(OneDriveErrorCode.AuthenticationFailure.ToString()))
                    {
                        await dialogService.ShowMessage(
                            "Authentication failed",
                            "Authentication failed");
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            return oneDriveClient;
        }
 /// <summary>
 /// Constructs a new SharesCollectionRequestBuilder.
 /// </summary>
 /// <param name="requestUrl">The URL for the built request.</param>
 /// <param name="oneDriveClient">The <see cref="IOneDriveClient"/> for handling requests.</param>
 public SharesCollectionRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient)
     : base(requestUrl, oneDriveClient)
 {
 }
 public OneDriveTile(IOneDriveClient oneDriveClient)
 {
     this.oneDriveClient = oneDriveClient;
     InitializeComponent();
 }
示例#59
0
 private async Task AuthenticateOneDrive()
 {
     string[] scopes = { "wl.signin", "wl.offline_access", "onedrive.readwrite" };
     oneDriveClient = OneDriveClientExtensions.GetClientUsingOnlineIdAuthenticator(scopes);
     await oneDriveClient.AuthenticateAsync();
 }
 public DriveRecentRequestBuilder(
     string requestUrl,
     IOneDriveClient oneDriveClient)
     : base(requestUrl, oneDriveClient)
 {
 }