Allow user to select login strategy

Author: calebkiage

src/Authentication/AuthenticationServiceFactory.cs

@@ -8,54 +8,48 @@
 namespace Microsoft.Graph.Cli.Authentication;
 
 class AuthenticationServiceFactory {
-    public async Task<IAuthenticationService> GetAuthenticationServiceAsync(AuthenticationStrategy strategy, bool persistToken = false) {
+    public async Task<ILoginService> GetAuthenticationServiceAsync(AuthenticationStrategy strategy) {
         switch (strategy) {
             case AuthenticationStrategy.DeviceCode:
-                return await GetDeviceCodeAuthenticationServiceAsync(persistToken);
+                return await GetDeviceCodeLoginServiceAsync();
             default:
                 throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
         }
 
     }
 
-    public async Task<TokenCredential> GetTokenCredentialAsync(AuthenticationStrategy strategy, bool persistToken = false) {
+    public async Task<TokenCredential> GetTokenCredentialAsync(AuthenticationStrategy strategy) {
         switch (strategy) {
             case AuthenticationStrategy.DeviceCode:
-                return await GetDeviceCodeCredentialAsync(persistToken);
+                return await GetDeviceCodeCredentialAsync();
             default:
                 throw new InvalidOperationException($"The authentication strategy {strategy} is not supported");
         }
     }
 
-    private async Task<DeviceCodeAuthenticationService> GetDeviceCodeAuthenticationServiceAsync(bool persistToken = false) {
-        var credential = await GetDeviceCodeCredentialAsync(persistToken);
+    private async Task<DeviceCodeLoginService> GetDeviceCodeLoginServiceAsync() {
+        var credential = await GetDeviceCodeCredentialAsync();
         return new(credential);
     }
 
-    private async Task<DeviceCodeCredential> GetDeviceCodeCredentialAsync(bool persistToken) {
+    private async Task<DeviceCodeCredential> GetDeviceCodeCredentialAsync() {
         DeviceCodeCredentialOptions credOptions = new()
         {
             ClientId = Constants.ClientId,
             TenantId = Constants.TenantId
         };
 
-        if (persistToken) {
-            TokenCachePersistenceOptions tokenCacheOptions = new() { Name = Constants.TokenCacheName };
-            credOptions.TokenCachePersistenceOptions = tokenCacheOptions;
-            var recordPath = Constants.AuthRecordPath;
-
-            if (File.Exists(recordPath))
-            {
-                using var authRecordStream = new FileStream(recordPath, FileMode.Open, FileAccess.Read);
-                var authRecord = await AuthenticationRecord.DeserializeAsync(authRecordStream);
-                credOptions.AuthenticationRecord = authRecord;
-            }
+        TokenCachePersistenceOptions tokenCacheOptions = new() { Name = Constants.TokenCacheName };
+        credOptions.TokenCachePersistenceOptions = tokenCacheOptions;
+        var recordPath = Constants.AuthRecordPath;
+
+        if (File.Exists(recordPath))
+        {
+            using var authRecordStream = new FileStream(recordPath, FileMode.Open, FileAccess.Read);
+            var authRecord = await AuthenticationRecord.DeserializeAsync(authRecordStream);
+            credOptions.AuthenticationRecord = authRecord;
         }
 
         return new DeviceCodeCredential(credOptions);
     }
 }
-
-enum AuthenticationStrategy {
-    DeviceCode
-}

src/Authentication/AuthenticationStrategy.cs

@@ -0,0 +1,5 @@
+namespace Microsoft.Graph.Cli.Authentication;
+
+public enum AuthenticationStrategy {
+    DeviceCode
+}

src/Authentication/DeviceCodeAuthenticationService.cs

@@ -0,0 +1,19 @@
+using Azure.Core;
+using Azure.Identity;
+using Microsoft.Graph.Cli.Utils;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Microsoft.Graph.Cli.Authentication;
+
+class DeviceCodeLoginService : LoginServiceBase {
+    private DeviceCodeCredential credential;
+
+    public DeviceCodeLoginService(DeviceCodeCredential credential) {
+        this.credential = credential;
+    }
+
+    protected override async Task<AuthenticationRecord> DoLoginAsync(string[] scopes) {
+        return await credential.AuthenticateAsync(new TokenRequestContext(scopes));
+    }
+}

src/Authentication/DeviceCodeLoginService.cs

@@ -2,6 +2,8 @@
 
 namespace Microsoft.Graph.Cli.Authentication;
 
-interface IAuthenticationService {
+interface ILoginService {
     Task LoginAsync(string[] scopes);
+
+    void Logout();
 }

…Authentication/IAuthenticationService.cs src/Authentication/ILoginService.cssrc/Authentication/IAuthenticationService.cs renamed to src/Authentication/ILoginService.cs src/Authentication/IAuthenticationService.cs renamed to src/Authentication/ILoginService.cs

@@ -0,0 +1,26 @@
+using System.IO;
+using System.Threading.Tasks;
+using Azure.Identity;
+using Microsoft.Graph.Cli.Utils;
+
+namespace Microsoft.Graph.Cli.Authentication;
+
+abstract class LoginServiceBase : ILoginService {
+    public async Task LoginAsync(string[] scopes) {
+        var record = await this.DoLoginAsync(scopes);
+        await this.SaveSessionAsync(record);
+    }
+
+    public void Logout() {
+        if (File.Exists(Constants.AuthRecordPath)) {
+            File.Delete(Constants.AuthRecordPath);
+        }
+    }
+
+    protected abstract Task<AuthenticationRecord> DoLoginAsync(string[] scopes);
+
+    public async Task SaveSessionAsync(AuthenticationRecord record) {
+        using var authRecordStream = new FileStream(Constants.AuthRecordPath, FileMode.OpenOrCreate, FileAccess.Write);
+        await record.SerializeAsync(authRecordStream);
+    }
+}

src/Authentication/LoginServiceBase.cs

@@ -13,7 +13,7 @@ public LoginCommand(AuthenticationServiceFactory authenticationServiceFactory) {
         this.authenticationServiceFactory = authenticationServiceFactory;
     }
 
-    public Command Build(bool persistToken = false) {
+    public Command Build() {
         var loginCommand = new Command("login", "Login and store the session for use in subsequent commands");
         var scopes = new Option<string>("--scopes", "The login scopes e.g. User.Read");
         scopes.IsRequired = true;
@@ -25,7 +25,7 @@ public Command Build(bool persistToken = false) {
 
         loginCommand.Handler = CommandHandler.Create<string[], AuthenticationStrategy>(async (scopes, strategy) =>
         {
-            var authService = await this.authenticationServiceFactory.GetAuthenticationServiceAsync(strategy, persistToken);
+            var authService = await this.authenticationServiceFactory.GetAuthenticationServiceAsync(strategy);
             await authService.LoginAsync(scopes);
         });
 

src/Commands/Authentication/LoginCommand.cs

@@ -14,9 +14,8 @@ class Program {
         static async Task<int> Main(string[] args) {
             var authServiceFactory = new AuthenticationServiceFactory();
             var authStrategy = AuthenticationStrategy.DeviceCode;
-            var persistToken = true;
 
-            var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy, persistToken);
+            var credential = await authServiceFactory.GetTokenCredentialAsync(authStrategy);
             var authProvider = new AzureIdentityAuthenticationProvider(credential);
             var core = new HttpClientRequestAdapter(authProvider);
             var client = new GraphClient(core);
@@ -25,7 +24,7 @@ static async Task<int> Main(string[] args) {
             rootCommand.Description = "Microsoft Graph CLI";
 
             var loginCommand = new LoginCommand(authServiceFactory);
-            rootCommand.AddCommand(loginCommand.Build(persistToken));
+            rootCommand.AddCommand(loginCommand.Build());
             return await rootCommand.InvokeAsync(args);
         }
     }