Major refactoring 2.0

.github/workflows/dotnet.yml

@@ -12,11 +12,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Setup .NET
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v2
       with:
-        dotnet-version: 5.0.201
+        dotnet-version: '6.0.x'
     - name: Restore dependencies
       run: dotnet restore
     - name: Build

Client/Client.Account/Client.Account.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\Common\RockPaperScissors.Common\RockPaperScissors.Common.csproj" />
+    </ItemGroup>
+
+</Project>

Client/Client.Account/Enums/MenuTypes.cs

@@ -0,0 +1,9 @@
+namespace Client.Account.Enums;
+
+internal enum MenuTypes
+{
+    Unknown = 0,
+    SignUp = 1,
+    Login = 2,
+    Back = 3,
+}

Client/Client.Account/Extensions/EnumExtensions.cs

@@ -0,0 +1,39 @@
+using Client.Account.Enums;
+
+namespace Client.Account.Extensions;
+
+internal static class EnumExtensions
+{
+    internal static string GetDisplayName(this MenuTypes menuTypes)
+    {
+        return menuTypes switch
+        {
+            MenuTypes.Back => "Back",
+            MenuTypes.Login => "Login",
+            MenuTypes.SignUp => "Sign Up",
+            _ => "Unknown",
+        };
+    }
+
+    internal static MenuTypes TryGetMenuType(this string? stringInput)
+    {
+        return stringInput switch
+        {
+            "3" => MenuTypes.Back,
+            "2" => MenuTypes.Login,
+            "1" => MenuTypes.SignUp,
+            _ => MenuTypes.Unknown,
+        };
+    }
+
+    internal static int GetValue(this MenuTypes menuTypes)
+    {
+        return menuTypes switch
+        {
+            MenuTypes.Back => 3,
+            MenuTypes.Login => 2,
+            MenuTypes.SignUp => 1,
+            _ => 0,
+        };
+    }
+}

Client/Client.Account/Extensions/ServiceCollectionExtensions.cs

@@ -0,0 +1,19 @@
+using Client.Account.Menus;
+using Client.Account.Services;
+using Client.Account.Services.Interfaces;
+using RockPaperScissors.Common.Client;
+
+namespace Client.Account.Extensions;
+
+public static class ServiceCollectionExtensions
+{
+    public static IAccountService CreateAccountService(this IClient client)
+    {
+        return new AccountService(client);
+    }
+
+    public static IAccountMenu CreateAccountMenu(this IAccountService accountService)
+    {
+        return new AccountMenu(accountService);
+    }
+}

Client/Client.Account/Menus/AccountMenu.cs

@@ -0,0 +1,160 @@
+using Client.Account.Enums;
+using Client.Account.Extensions;
+using Client.Account.Services;
+using Client.Account.Services.Interfaces;
+using RockPaperScissors.Common.Enums;
+using RockPaperScissors.Common.Extensions;
+
+namespace Client.Account.Menus;
+
+internal sealed class AccountMenu : IAccountMenu
+{
+    private readonly IAccountService _accountService;
+
+    public AccountMenu(IAccountService accountService)
+    {
+        _accountService = accountService ?? throw new ArgumentNullException(nameof(accountService));
+    }
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            "Account Menu:".Print(ConsoleColor.DarkYellow);
+            $"{MenuTypes.SignUp.GetValue()}.\t{MenuTypes.SignUp.GetDisplayName()}".Print(ConsoleColor.DarkYellow);
+            $"{MenuTypes.Login.GetValue()}.\t{MenuTypes.Login.GetDisplayName()}".Print(ConsoleColor.DarkYellow);
+            $"{MenuTypes.Back.GetValue()}.\t{MenuTypes.Back.GetDisplayName()}".Print(ConsoleColor.DarkYellow);
+
+            "\nPlease select an item from the list".Print(ConsoleColor.Green);
+
+            Console.Write("Select -> ");
+
+            var menuType = Console.ReadLine().TryGetMenuType();
+
+            if (menuType is MenuTypes.Unknown)
+            {
+                "Invalid input. Try again.".Print(ConsoleColor.Red);
+
+                continue;
+            }
+
+            switch (menuType)
+            {
+                case MenuTypes.SignUp: 
+                    var isRegistered = await RegisterAsync(cancellationToken);
+
+                    if (!isRegistered)
+                    {
+                        "\nPress any key to back to the start up menu list!".Print(ConsoleColor.Cyan);
+                        Console.ReadKey();
+                        Console.Clear();
+
+                        continue;
+                    }
+
+                    "Trying logging in...".Print(ConsoleColor.White);
+                    Console.Clear();
+
+                    return;
+
+                case MenuTypes.Login: 
+                    var isSuccess = await LoginAsync(cancellationToken);
+
+                    if (isSuccess)
+                    {
+                        "\nPress any key to back to the start up menu list!".Print(ConsoleColor.Cyan);
+                        Console.ReadKey();
+                        Console.Clear();
+
+                        return;
+                    }
+
+                    continue;
+
+                case MenuTypes.Back:
+                    Console.Clear();
+
+                    return;
+
+                default:
+                    "Invalid input. Try again.".Print(ConsoleColor.Red);
+                    continue;
+            }
+        }
+    }
+
+    public async Task<bool> LogoutAsync(CancellationToken cancellationToken)
+    {
+        if (!_accountService.IsAuthorized())
+        {
+            return true;
+        }
+
+        var user = _accountService.GetUser();
+
+        var response = await _accountService.LogoutAsync(user.SessionId, cancellationToken);
+
+        return response.Match(
+            _ => 
+            {
+                "Successfully signed out".Print(ConsoleColor.DarkGreen);
+
+                return true;
+            },
+            exception =>
+            {
+                exception.Message.Print(ConsoleColor.Red);
+
+                return false;
+            });
+    }
+
+    private async Task<bool> RegisterAsync(CancellationToken cancellationToken)
+    { 
+        ("We are glad to welcome you in the registration form!\n" +
+         "Please enter the required details\n" +
+         "to register an account on the platform")
+            .Print(ConsoleColor.Magenta);
+
+        var login = "Login: ".BuildString(StringDestination.Login);
+        var password = "Password: ".BuildString(StringDestination.Password);
+
+        var response = await _accountService.SignUpAsync(login, password, cancellationToken);
+
+        return response.Match(
+            _ =>
+            {
+                "Successfully registered!".Print(ConsoleColor.Green);
+
+                return true;
+            },
+            exception =>
+            {
+                exception.Message.Print(ConsoleColor.Red);
+
+                return false;
+            });
+    }
+
+    private async Task<bool> LoginAsync(CancellationToken cancellationToken)
+    {
+        var login = "Login: ".BuildString(StringDestination.Login);
+        var password = "Password: ".BuildString(StringDestination.Password, isNeedConfirmation: true);
+
+        var response = await _accountService.LoginAsync(login, password, cancellationToken);
+
+        return response.Match(
+            _ =>
+            {
+                "Successfully signed in".Print(ConsoleColor.DarkGreen);
+
+                return true;
+            },
+            exception =>
+            {
+                exception.Message.Print(ConsoleColor.Red);
+
+                return false;
+            });
+    }
+}

Client/Client.Account/Menus/IAccountMenu.cs

@@ -0,0 +1,8 @@
+namespace Client.Account.Menus;
+
+public interface IAccountMenu
+{
+    Task StartAsync(CancellationToken cancellationToken);
+
+    Task<bool> LogoutAsync(CancellationToken cancellationToken);
+}

Client/Client.Account/Services/AccountService.cs

@@ -0,0 +1,105 @@
+using Client.Account.Services.Interfaces;
+using OneOf;
+using RockPaperScissors.Common;
+using RockPaperScissors.Common.Client;
+using RockPaperScissors.Common.Extensions;
+using RockPaperScissors.Common.Requests;
+using RockPaperScissors.Common.Responses;
+
+namespace Client.Account.Services;
+
+internal sealed class AccountService : IAccountService
+{
+    private readonly IClient _client;
+    private IUser _user = null!;
+
+    public AccountService(IClient client)
+    {
+        _client = client ?? throw new ArgumentNullException(nameof(client));
+    }
+
+    public Task<OneOf<string, CustomException>> SignUpAsync(
+        string login, string password, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(login))
+        {
+            return Task.FromResult(OneOf<string, CustomException>.FromT1(new CustomException("Login must not be 'null' or '\"\"'")));
+        }
+
+        if (string.IsNullOrEmpty(password))
+        {
+            return Task.FromResult(OneOf<string, CustomException>.FromT1(new CustomException("Password must not be 'null' or '\"\"'")));
+        }
+
+        var request = new RegisterRequest
+        {
+            Login = login,
+            Password = password
+        };
+
+        var response =
+            _client.PostAsync<string, RegisterRequest>("api/Account/register", request, cancellationToken);
+
+        return response;
+    }
+
+    public async Task<OneOf<LoginResponse, CustomException>> LoginAsync(
+        string login, string password, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(login))
+        {
+            return new CustomException("Login must not be 'null' or '\"\"'");
+        }
+
+        if (string.IsNullOrEmpty(password))
+        {
+            return new CustomException("Password must not be 'null' or '\"\"'");
+        }
+
+        var request = new LoginRequest
+        {
+            Login = login,
+            Password = password
+        };
+
+        var response =
+            await _client.PostAsync<LoginResponse, LoginRequest>("api/Account/login", request, cancellationToken);
+
+        if (!response.IsT0)
+        {
+            return response;
+        }
+
+        var loginResponse = response.AsT0;
+        _user = new User(loginResponse.Token, loginResponse.Login);
+
+        return response;
+    }
+
+    public Task<OneOf<int, CustomException>> LogoutAsync(
+        string? token, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(token))
+        {
+            return Task.FromResult(OneOf<int, CustomException>.FromT1(new CustomException("Token must not be 'null' or '\"\"'")));
+        }
+
+        var queryUrl = new QueryBuilder(1)
+        {
+            { "sessionId", token }
+        };
+        var url = $"api/Account/logout{queryUrl}";
+
+        var response =
+            _client.GetAsync<int>(url, ("Authorization", token), cancellationToken);
+
+        return response;
+    }
+
+    public IUser GetUser() => _user;
+
+    public bool IsAuthorized()
+    {
+        return _user is not null && _user.IsAuthorized;
+    }
+}