Preparation Of First Release (Part 7/7)

samples/UAuthHub/CodeBeam.UltimateAuth.Sample.UAuthHub/Program.cs

@@ -90,7 +90,7 @@
 {
     scope.ServiceProvider.GetRequiredService<IUserLifecycleStore>();
     scope.ServiceProvider.GetRequiredService<IUserProfileStore>();
-    scope.ServiceProvider.GetRequiredService<IUserStore<UserKey>>();
+    scope.ServiceProvider.GetRequiredService<IUserIdentifierStore>();
 
     var seeder = scope.ServiceProvider.GetService<IAuthorizationSeeder>();
     //if (seeder is not null)

samples/blazor-server/CodeBeam.UltimateAuth.Sample.BlazorServer/Components/Pages/Home.razor

@@ -31,8 +31,8 @@
         <UALoginForm @ref="_form" Identifier="@_username" Secret="@_password">
             <MudStack>
                 <MudText Typo="Typo.h4">Welcome to UltimateAuth!</MudText>
-                <MudTextField @bind-Value="@_username" Variant="Variant.Outlined" Label="Username" Immediate="true" HelperText="Default: Admin" />
-                <MudPasswordField @bind-Value="@_password" Variant="Variant.Outlined" Label="Password" Immediate="true" HelperText="Default: Password!" />
+                <MudTextField @bind-Value="@_username" Variant="Variant.Outlined" Label="Username" Immediate="true" HelperText="Default: admin or user" />
+                <MudPasswordField @bind-Value="@_password" Variant="Variant.Outlined" Label="Password" Immediate="true" HelperText="Default: admin or user" />
                 <MudButton Variant="Variant.Filled" Color="Color.Primary" ButtonType="ButtonType.Submit">Login</MudButton>
             </MudStack>
         </UALoginForm>

samples/blazor-server/CodeBeam.UltimateAuth.Sample.BlazorServer/Components/Pages/Home.razor.cs

@@ -86,12 +86,12 @@ private async Task HandleGetMe()
 
         private async Task ChangeUserInactive()
         {
-            ChangeUserStatusRequest request = new ChangeUserStatusRequest
+            ChangeUserStatusAdminRequest request = new ChangeUserStatusAdminRequest
             {
                 UserKey = UserKey.FromString("user"),
                 NewStatus = UserStatus.Disabled
             };
-            var result = await UAuth.Users.ChangeStatusAsync(request);
+            var result = await UAuth.Users.ChangeStatusAdminAsync(request);
             if (result.Ok)
             {
                 Snackbar.Add($"User is disabled.", Severity.Info);

samples/blazor-server/CodeBeam.UltimateAuth.Sample.BlazorServer/Program.cs

@@ -2,8 +2,11 @@
 using CodeBeam.UltimateAuth.Authorization.InMemory.Extensions;
 using CodeBeam.UltimateAuth.Authorization.Reference.Extensions;
 using CodeBeam.UltimateAuth.Client.Extensions;
+using CodeBeam.UltimateAuth.Core.Abstractions;
 using CodeBeam.UltimateAuth.Core.Domain;
 using CodeBeam.UltimateAuth.Core.Extensions;
+using CodeBeam.UltimateAuth.Core.Infrastructure;
+using CodeBeam.UltimateAuth.Credentials;
 using CodeBeam.UltimateAuth.Credentials.InMemory.Extensions;
 using CodeBeam.UltimateAuth.Credentials.Reference;
 using CodeBeam.UltimateAuth.Sample.BlazorServer.Components;
@@ -13,6 +16,7 @@
 using CodeBeam.UltimateAuth.Server.Extensions;
 using CodeBeam.UltimateAuth.Sessions.InMemory;
 using CodeBeam.UltimateAuth.Tokens.InMemory;
+using CodeBeam.UltimateAuth.Users.InMemory;
 using CodeBeam.UltimateAuth.Users.InMemory.Extensions;
 using CodeBeam.UltimateAuth.Users.Reference;
 using CodeBeam.UltimateAuth.Users.Reference.Extensions;
@@ -96,17 +100,6 @@
 
 var app = builder.Build();
 
-using (var scope = app.Services.CreateScope())
-{
-    scope.ServiceProvider.GetRequiredService<IUserLifecycleStore>();
-    //scope.ServiceProvider.GetRequiredService<IUserProfileStore>();
-    //scope.ServiceProvider.GetRequiredService<IUserStore<UserKey>>();
-
-    var seeder = scope.ServiceProvider.GetService<IAuthorizationSeeder>();
-    //if (seeder is not null)
-    //    await seeder.SeedAsync();
-}
-
 // Configure the HTTP request pipeline.
 if (!app.Environment.IsDevelopment())
 {
@@ -118,6 +111,14 @@
 {
     app.MapOpenApi();
     app.MapScalarApiReference();
+    using var scope = app.Services.CreateScope();
+    //scope.ServiceProvider.GetRequiredService<IUserLifecycleStore>();
+    //scope.ServiceProvider.GetRequiredService<IUserProfileStore>();
+    //scope.ServiceProvider.GetRequiredService<IUserIdentifierStore>();
+    //scope.ServiceProvider.GetRequiredService<ICredentialStore<UserKey>>();
+    var seedRunner = scope.ServiceProvider.GetRequiredService<SeedRunner>();
+
+    await seedRunner.RunAsync(tenantId: null);
 }
 
 app.UseHttpsRedirection();

src/CodeBeam.UltimateAuth.Client/CodeBeam.UltimateAuth.Client.csproj

@@ -29,6 +29,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
+	  <ProjectReference Include="..\authorization\CodeBeam.UltimateAuth.Authorization.Contracts\CodeBeam.UltimateAuth.Authorization.Contracts.csproj" />
 	  <ProjectReference Include="..\CodeBeam.UltimateAuth.Core\CodeBeam.UltimateAuth.Core.csproj" />
 	  <ProjectReference Include="..\credentials\CodeBeam.UltimateAuth.Credentials.Contracts\CodeBeam.UltimateAuth.Credentials.Contracts.csproj" />
 	  <ProjectReference Include="..\users\CodeBeam.UltimateAuth.Users.Contracts\CodeBeam.UltimateAuth.Users.Contracts.csproj" />

src/CodeBeam.UltimateAuth.Client/Extensions/UltimateAuthClientServiceCollectionExtensions.cs

@@ -97,10 +97,12 @@ private static IServiceCollection AddUltimateAuthClientInternal(this IServiceCol
                 o.Refresh.Interval ??= TimeSpan.FromMinutes(5);
             });
 
-            services.AddScoped<IUAuthRequestClient, UAuthRequestClient>();
-            services.AddScoped<IUAuthClient, UAuthClient>();
-            services.AddScoped<IFlowClient, DefaultFlowClient>();
+            services.TryAddScoped<IUAuthRequestClient, UAuthRequestClient>();
+            services.TryAddScoped<IUAuthClient, UAuthClient>();
+            services.TryAddScoped<IFlowClient, DefaultFlowClient>();
             services.TryAddScoped<IUserClient, DefaultUserClient>();
+            services.TryAddScoped<IUserIdentifierClient, DefaultUserIdentifierClient>();
+            services.TryAddScoped<IAuthorizationClient, DefaultAuthorizationClient>();
 
             services.AddScoped<ISessionCoordinator>(sp =>
             {

src/CodeBeam.UltimateAuth.Client/Services/DefaultAuthorizationClient.cs

@@ -0,0 +1,65 @@
+using CodeBeam.UltimateAuth.Authorization.Contracts;
+using CodeBeam.UltimateAuth.Client.Infrastructure;
+using CodeBeam.UltimateAuth.Client.Options;
+using CodeBeam.UltimateAuth.Core.Contracts;
+using CodeBeam.UltimateAuth.Core.Domain;
+using Microsoft.Extensions.Options;
+
+namespace CodeBeam.UltimateAuth.Client.Services
+{
+    internal sealed class DefaultAuthorizationClient : IAuthorizationClient
+    {
+        private readonly IUAuthRequestClient _request;
+        private readonly UAuthClientOptions _options;
+
+        public DefaultAuthorizationClient(IUAuthRequestClient request, IOptions<UAuthClientOptions> options)
+        {
+            _request = request;
+            _options = options.Value;
+        }
+
+        public async Task<UAuthResult<AuthorizationResult>> CheckAsync(AuthorizationCheckRequest request)
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, "/authorization/check");
+            var raw = await _request.SendJsonAsync(url, request);
+            return UAuthResultMapper.FromJson<AuthorizationResult>(raw);
+        }
+
+        public async Task<UAuthResult<UserRolesResponse>> GetMyRolesAsync()
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, "/authorization/users/me/roles/get");
+            var raw = await _request.SendFormForJsonAsync(url);
+            return UAuthResultMapper.FromJson<UserRolesResponse>(raw);
+        }
+
+        public async Task<UAuthResult<UserRolesResponse>> GetUserRolesAsync(UserKey userKey)
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/admin/authorization/users/{userKey}/roles/get");
+            var raw = await _request.SendFormForJsonAsync(url);
+            return UAuthResultMapper.FromJson<UserRolesResponse>(raw);
+        }
+
+        public async Task<UAuthResult> AssignRoleAsync(UserKey userKey, string role)
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/admin/authorization/users/{userKey}/roles/post");
+            var raw = await _request.SendJsonAsync(url, new AssignRoleRequest
+            {
+                Role = role
+            });
+
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> RemoveRoleAsync(UserKey userKey, string role)
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/admin/authorization/users/{userKey}/roles/delete");
+
+            var raw = await _request.SendJsonAsync(url, new AssignRoleRequest
+            {
+                Role = role
+            });
+
+            return UAuthResultMapper.FromStatus(raw);
+        }
+    }
+}

src/CodeBeam.UltimateAuth.Client/Services/DefaultCredentialClient.cs

@@ -0,0 +1,103 @@
+using CodeBeam.UltimateAuth.Client.Infrastructure;
+using CodeBeam.UltimateAuth.Client.Options;
+using CodeBeam.UltimateAuth.Core.Contracts;
+using CodeBeam.UltimateAuth.Core.Domain;
+using CodeBeam.UltimateAuth.Credentials.Contracts;
+using Microsoft.Extensions.Options;
+
+namespace CodeBeam.UltimateAuth.Client.Services
+{
+    internal sealed class DefaultUserCredentialClient : ICredentialClient
+    {
+        private readonly IUAuthRequestClient _request;
+        private readonly UAuthClientOptions _options;
+
+        public DefaultUserCredentialClient(IUAuthRequestClient request, IOptions<UAuthClientOptions> options)
+        {
+            _request = request;
+            _options = options.Value;
+        }
+
+        private string Url(string path) => UAuthUrlBuilder.Combine(_options.Endpoints.Authority, path);
+
+        public async Task<UAuthResult<GetCredentialsResult>> GetMyAsync()
+        {
+            var raw = await _request.SendFormForJsonAsync(Url("/credentials/get"));
+            return UAuthResultMapper.FromJson<GetCredentialsResult>(raw);
+        }
+
+        public async Task<UAuthResult<AddCredentialResult>> AddMyAsync(AddCredentialRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url("/credentials/add"), request);
+            return UAuthResultMapper.FromJson<AddCredentialResult>(raw);
+        }
+
+        public async Task<UAuthResult<ChangeCredentialResult>> ChangeMyAsync(CredentialType type, ChangeCredentialRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/credentials/{type}/change"), request);
+            return UAuthResultMapper.FromJson<ChangeCredentialResult>(raw);
+        }
+
+        public async Task<UAuthResult> RevokeMyAsync(CredentialType type, RevokeCredentialRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/credentials/{type}/revoke"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> BeginResetMyAsync(CredentialType type, BeginCredentialResetRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/credentials/{type}/reset/begin"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> CompleteResetMyAsync(CredentialType type, CompleteCredentialResetRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/credentials/{type}/reset/complete"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+
+        public async Task<UAuthResult<GetCredentialsResult>> GetUserAsync(UserKey userKey)
+        {
+            var raw = await _request.SendFormForJsonAsync(Url($"/admin/users/{userKey}/credentials/get"));
+            return UAuthResultMapper.FromJson<GetCredentialsResult>(raw);
+        }
+
+        public async Task<UAuthResult<AddCredentialResult>> AddUserAsync(UserKey userKey, AddCredentialRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/admin/users/{userKey}/credentials/add"), request);
+            return UAuthResultMapper.FromJson<AddCredentialResult>(raw);
+        }
+
+        public async Task<UAuthResult> RevokeUserAsync(UserKey userKey, CredentialType type, RevokeCredentialRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/admin/users/{userKey}/credentials/{type}/revoke"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> ActivateUserAsync(UserKey userKey, CredentialType type)
+        {
+            var raw = await _request.SendFormAsync(Url($"/admin/users/{userKey}/credentials/{type}/activate"));
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> BeginResetUserAsync(UserKey userKey, CredentialType type, BeginCredentialResetRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/admin/users/{userKey}/credentials/{type}/reset/begin"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> CompleteResetUserAsync(UserKey userKey, CredentialType type, CompleteCredentialResetRequest request)
+        {
+            var raw = await _request.SendJsonAsync(Url($"/admin/users/{userKey}/credentials/{type}/reset/complete"), request);
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+        public async Task<UAuthResult> DeleteUserAsync(UserKey userKey, CredentialType type)
+        {
+            var raw = await _request.SendFormAsync(Url($"/admin/users/{userKey}/credentials/{type}/delete"));
+            return UAuthResultMapper.FromStatus(raw);
+        }
+
+    }
+}

src/CodeBeam.UltimateAuth.Client/Services/DefaultUserClient.cs

@@ -18,11 +18,11 @@ public DefaultUserClient(IUAuthRequestClient request, IOptions<UAuthClientOption
             _options = options.Value;
         }
 
-        public async Task<UAuthResult<UserProfileDto>> GetMeAsync()
+        public async Task<UAuthResult<UserViewDto>> GetMeAsync()
         {
             var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, "/users/me/get");
             var raw = await _request.SendFormForJsonAsync(url);
-            return UAuthResultMapper.FromJson<UserProfileDto>(raw);
+            return UAuthResultMapper.FromJson<UserViewDto>(raw);
         }
 
         public async Task<UAuthResult> UpdateMeAsync(UpdateProfileRequest request)
@@ -39,9 +39,16 @@ public async Task<UAuthResult<UserCreateResult>> CreateAsync(CreateUserRequest r
             return UAuthResultMapper.FromJson<UserCreateResult>(raw);
         }
 
-        public async Task<UAuthResult<UserStatusChangeResult>> ChangeStatusAsync(ChangeUserStatusRequest request)
+        public async Task<UAuthResult<UserStatusChangeResult>> ChangeStatusSelfAsync(ChangeUserStatusSelfRequest request)
         {
-            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, "/users/status");
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/users/me/status");
+            var raw = await _request.SendJsonAsync(url, request);
+            return UAuthResultMapper.FromJson<UserStatusChangeResult>(raw);
+        }
+
+        public async Task<UAuthResult<UserStatusChangeResult>> ChangeStatusAdminAsync(ChangeUserStatusAdminRequest request)
+        {
+            var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/admin/users/{request.UserKey.Value}/status");
             var raw = await _request.SendJsonAsync(url, request);
             return UAuthResultMapper.FromJson<UserStatusChangeResult>(raw);
         }
@@ -53,11 +60,11 @@ public async Task<UAuthResult<UserDeleteResult>> DeleteAsync(DeleteUserRequest r
             return UAuthResultMapper.FromJson<UserDeleteResult>(raw);
         }
 
-        public async Task<UAuthResult<UserProfileDto>> GetProfileAsync(UserKey userKey)
+        public async Task<UAuthResult<UserViewDto>> GetProfileAsync(UserKey userKey)
         {
             var url = UAuthUrlBuilder.Combine(_options.Endpoints.Authority, $"/admin/users/{userKey}/profile/get");
             var raw = await _request.SendFormForJsonAsync(url);
-            return UAuthResultMapper.FromJson<UserProfileDto>(raw);
+            return UAuthResultMapper.FromJson<UserViewDto>(raw);
         }
 
         public async Task<UAuthResult> UpdateProfileAsync(UserKey userKey, UpdateProfileRequest request)