new provoder for Daemon type apps.

src/OneDrive.Sdk.Authentication.Desktop/Business/AdalDaemonAuthenticationProvider.cs

@@ -0,0 +1,118 @@
+// ------------------------------------------------------------------------------
+//  Copyright (c) Microsoft Corporation.  All Rights Reserved.  
+//  Licensed under the MIT License.  
+//  See License in the project root for license information.
+// ------------------------------------------------------------------------------
+using System;
+using System.Threading.Tasks;
+using Microsoft.Graph;
+using Microsoft.IdentityModel.Clients.ActiveDirectory;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Globalization;
+using System.Threading;
+
+namespace Microsoft.OneDrive.Sdk.Authentication.Business
+{
+    public class AdalDaemonAuthenticationProvider : AdalAuthenticationProviderBase
+    {
+        private const int _retryCount = 3;
+        private const int _retrySleepDuration = 3000;
+        protected string _clientId;
+        protected string _clientKey;
+
+        public IAuthenticationContextWrapper authContextWrapper;
+        protected ClientCredential clientCredential;
+
+        protected override AuthenticateUserDelegate AuthenticateUser { get; set; }
+        protected override AuthenticateUserSilentlyDelegate AuthenticateUserSilently { get; set; }
+
+        /// <summary>
+        /// Authenticates the user silently 
+        /// </summary>
+        /// <param name="clientId">Your Application ID</param>
+        /// <param name="clientSecret">Your Application Key</param>
+        /// <param name="tenant">is usually a domain name for your Office365 service. Like 'yourcompany.onmicrosoft.com'</param>
+        public AdalDaemonAuthenticationProvider(
+            string clientId,
+            string returnUrl,
+            string clientSecret,
+            string tenant,
+            IAuthenticationContextWrapper authenticationContextWrapper) : base(clientId, returnUrl, authenticationContextWrapper)
+        {
+            _clientId = clientId;
+            _clientKey = clientSecret;
+
+            string authority = String.Format(CultureInfo.InvariantCulture, "https://login.microsoftonline.com/{0}", tenant);
+            this.authContextWrapper = authenticationContextWrapper;
+            this.clientCredential = new ClientCredential(_clientId, _clientKey);
+
+            this.AuthenticateUser = this.PromptUserForAuthenticationAsync;
+            this.AuthenticateUserSilently = this.SilentlyAuthenticateUserAsync;
+        }
+
+        public async Task AuthenticateUserAsync(string serviceResourceId)
+        {
+            IAuthenticationResult result = null;
+            result = null;
+            int retryCount = 0;
+            bool retry = false;
+            currentServiceResourceId = serviceResourceId;
+            do
+            {
+                retry = false;
+                try
+                {
+                    result = await this.authContextWrapper.AcquireTokenSilentAsync(
+                        serviceResourceId,
+                        clientCredential);
+                }
+                catch (AdalException ex)
+                {
+                    if (ex.ErrorCode == "temporarily_unavailable")
+                    {
+                        retry = true;
+                        retryCount++;
+                        await Task.Delay(_retrySleepDuration);
+                    }
+                }
+
+            } while ((retry == true) && (retryCount < _retryCount));
+
+            this.CurrentAccountSession = this.ConvertAuthenticationResultToAccountSession(result);
+        }
+
+        public override Task AuthenticateUserWithRefreshTokenAsync(string refreshToken)
+        {
+            return this.AuthenticateUserWithRefreshTokenAsync(refreshToken, /* serviceResourceId */ null);
+        }
+
+        public override async Task AuthenticateUserWithRefreshTokenAsync(string refreshToken, string serviceResourceId)
+        {
+            // Daemon App doesn't have refresh token.
+            // So we do the authentication again.
+            await this.AuthenticateUserAsync(this.currentServiceResourceId);
+        }
+
+        private async Task<IAuthenticationResult> SilentlyAuthenticateUserAsync(
+            string serviceResourceId,
+            string userId,
+            bool throwOnError)
+        {
+            var result = await this.authContextWrapper.AcquireTokenSilentAsync(
+                        serviceResourceId,
+                        clientCredential);
+            return result;
+        }
+
+        private Task<IAuthenticationResult> PromptUserForAuthenticationAsync(string serviceResourceId, string userId)
+        {
+            return this.SilentlyAuthenticateUserAsync(
+                        serviceResourceId,
+                        userId,
+                        true);
+        }
+    }
+}
+
+

src/OneDrive.Sdk.Authentication.Desktop/Business/AuthenticationContextWrapper.cs

@@ -54,6 +54,19 @@ public ITokenCache TokenCache
             }
         }
 
+
+        /// <summary>
+        /// Authenticates the daemon app silently"/>.
+        /// </summary>
+        /// <param name="resource">The resource to authenticate against.</param>
+        /// <param name="clientCredential">The client credential of the application.</param>
+        /// <returns>The <see cref="IAuthenticationResult"/>.</returns>
+        public async Task<IAuthenticationResult> AcquireTokenSilentAsync(string resource, ClientCredential clientCredential)
+        {
+            var result = await this.authenticationContext.AcquireTokenAsync(resource, clientCredential).ConfigureAwait(false);
+            return result == null ? null : new AuthenticationResultWrapper(result);
+        }
+
         /// <summary>
         /// Authenticates the user silently using <see cref="AuthenticationContext.AcquireTokenSilentAsync(string, string, UserIdentifier)"/>.
         /// </summary>

src/OneDrive.Sdk.Authentication.Desktop/Business/IAuthenticationContextWrapper.cs

@@ -31,6 +31,14 @@ public interface IAuthenticationContextWrapper
     {
         ITokenCache TokenCache { get; }
 
+        /// <summary>
+        /// Authenticates the daemon app silently"/>.
+        /// </summary>
+        /// <param name="resource">The resource to authenticate against.</param>
+        /// <param name="clientCredential">The client credential of the application.</param>
+        /// <returns>The <see cref="IAuthenticationResult"/>.</returns>
+        Task<IAuthenticationResult> AcquireTokenSilentAsync(string resource, ClientCredential clientCredential);
+
         /// <summary>
         /// Authenticates the user silently using <see cref="AuthenticationContext.AcquireTokenSilentAsync(string, string, UserIdentifier)"/>.
         /// </summary>