max/DotBased
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[CHANGE] Remove old ASP auth project

Browse Source
This commit is contained in:
max
2025-08-02 16:27:16 +02:00
parent 333cf66cb4
commit 3a9c499aab
29 changed files with 0 additions and 767 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
DotBased.ASP.Auth/AuthDataCache.cs
View File

@@ -1,98 +0,0 @@
using System.Collections.ObjectModel;
using DotBased.ASP.Auth.Domains.Auth;
using Microsoft.AspNetCore.Components.Authorization;
namespace DotBased.ASP.Auth;
public class AuthDataCache
{
public AuthDataCache(BasedAuthConfiguration configuration)
{
_configuration = configuration;
}
private readonly BasedAuthConfiguration _configuration;
private readonly AuthStateCacheCollection<AuthenticationStateModel, AuthenticationState> _authenticationStateCollection = [];
public ResultOld PurgeSessionState(string id) => _authenticationStateCollection.Remove(id) ? ResultOld.Ok() : ResultOld.Failed("Failed to purge session state from cache! Or the session was not cached...");
public void CacheSessionState(AuthenticationStateModel stateModel, AuthenticationState? state = null) => _authenticationStateCollection[stateModel.Id] =
new AuthStateCacheNode<AuthenticationStateModel, AuthenticationState>(stateModel, state);
public ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>> RequestSessionState(string id)
{
if (!_authenticationStateCollection.TryGetValue(id, out var node))
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed("No cached object found!");
string failedMsg;
if (node.StateModel != null)
{
if (node.IsValidLifespan(_configuration.CachedAuthSessionLifespan))
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Ok(new Tuple<AuthenticationStateModel, AuthenticationState?>(node.StateModel, node.State));
failedMsg = $"Session has invalid lifespan, removing entry: [{id}] from cache!";
}
else
failedMsg = $"Returned object is null, removing entry: [{id}] from cache!";
_authenticationStateCollection.Remove(id);
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed(failedMsg);
}
}
public class AuthStateCacheNode<TStateModel, TState> where TStateModel : class where TState : class
{
public AuthStateCacheNode(TStateModel stateModel, TState? state)
{
StateModel = stateModel;
State = state;
}
public TStateModel? StateModel { get; private set; }
public TState? State { get; private set; }
public DateTime DateCached { get; private set; } = DateTime.Now;
public void UpdateObject(TStateModel obj)
{
StateModel = obj;
DateCached = DateTime.Now;
}
/// <summary>
/// Checks if the cached object is within the given lifespan.
/// </summary>
/// <param name="lifespan">The max. lifespan</param>
public bool IsValidLifespan(TimeSpan lifespan) => DateCached.Add(lifespan) > DateTime.Now;
public override bool Equals(object? obj)
{
if (obj is AuthStateCacheNode<TStateModel, TState> cacheObj)
return StateModel != null && StateModel.Equals(cacheObj.StateModel);
return false;
}
public override int GetHashCode() => typeof(TStateModel).GetHashCode();
public override string ToString() => typeof(TStateModel).ToString();
}
public class AuthStateCacheCollection<TStateModel, TState> : KeyedCollection<string, AuthStateCacheNode<TStateModel, TState>> where TStateModel : class where TState : class
{
protected override string GetKeyForItem(AuthStateCacheNode<TStateModel, TState> item) => item.StateModel?.ToString() ?? string.Empty;
public new AuthStateCacheNode<TStateModel, TState>? this[string id]
{
get => TryGetValue(id, out AuthStateCacheNode<TStateModel, TState>? nodeValue) ? nodeValue : null;
set
{
if (value == null)
return;
if (TryGetValue(id, out AuthStateCacheNode<TStateModel, TState>? nodeValue))
Remove(nodeValue);
Add(value);
}
}
public void Insert(AuthStateCacheNode<TStateModel, TState> node)
{
if (Contains(node))
Remove(node);
Add(node);
}
}

13
DotBased.ASP.Auth/AuthenticationService.cs
View File

@@ -1,13 +0,0 @@
namespace DotBased.ASP.Auth.Services;
public class AuthenticationService
{
public AuthenticationService()
{
/*
* - Login
* - Logout
* - Register
*/
}
}

65
DotBased.ASP.Auth/BasedAuthConfiguration.cs
View File

@@ -1,65 +0,0 @@
namespace DotBased.ASP.Auth;
public class BasedAuthConfiguration
{
/// <summary>
/// Allow users to registrate.
/// </summary>
public bool AllowRegistration { get; set; }
//TODO: Callback when a user registers, so the application can handle sending emails or generate a code to complete the registration.
//TODO: Callback for validation email, phone number
/// <summary>
/// Allow no passwords on users, not recommended!
/// </summary>
public bool AllowEmptyPassword { get; set; } = false;
/// <summary>
/// This path is used for redirecting to the login page.
/// </summary>
public string LoginPath { get; set; } = string.Empty;
/// <summary>
/// The path that will be used if the logout is requested.
/// </summary>
public string LogoutPath { get; set; } = string.Empty;
/// <summary>
/// The page that the client will be redirected to after logging out.
/// </summary>
public string LoggedOutPath { get; set; } = string.Empty;
/// <summary>
/// The max age before a AuthenticationState will expire (default: 7 days).
/// </summary>
public TimeSpan AuthenticationStateMaxAgeBeforeExpire { get; set; } = TimeSpan.FromDays(7);
/// <summary>
/// How long a session state will be cached (default: 15 min)
/// </summary>
public TimeSpan CachedAuthSessionLifespan { get; set; } = TimeSpan.FromMinutes(15);
/// <summary>
/// Can be used to seed a default user and/or group for first time use.
/// </summary>
public Action<IAuthDataRepository>? SeedData { get; set; }
public Type? AuthDataRepositoryType { get; private set; }
public void SetDataRepositoryType<TDataProviderType>() where TDataProviderType : IAuthDataRepository =>
AuthDataRepositoryType = typeof(TDataProviderType);
public Type? SessionStateProviderType { get; private set; }
public void SetSessionStateProviderType<TSessionStateProviderType>()
where TSessionStateProviderType : ISessionStateProvider =>
SessionStateProviderType = typeof(TSessionStateProviderType);
}
public class BasedPasswordOptions
{
}
public class BasedUserOptions
{
}
public class BasedLockoutOptions
{
}

13
DotBased.ASP.Auth/BasedAuthDefaults.cs
View File

@@ -1,13 +0,0 @@
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
namespace DotBased.ASP.Auth;
public static class BasedAuthDefaults
{
public const string AuthenticationScheme = "DotBasedAuthentication";
public const string StorageKey = "dotbased_session";
public static IComponentRenderMode InteractiveServerWithoutPrerender { get; } =
new InteractiveServerRenderMode(prerender: false);
}

40
DotBased.ASP.Auth/BasedServerAuthenticationStateProvider.cs
View File

@@ -1,40 +0,0 @@
using System.Security.Claims;
using DotBased.Logging;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Components.Server;
using Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage;
using ILogger = DotBased.Logging.ILogger;
namespace DotBased.ASP.Auth;
// RevalidatingServerAuthenticationStateProvider
// AuthenticationStateProvider
// Handles roles
public class BasedServerAuthenticationStateProvider : ServerAuthenticationStateProvider
{
public BasedServerAuthenticationStateProvider(BasedAuthConfiguration configuration, ProtectedLocalStorage localStorage, SecurityService securityService)
{
_config = configuration;
_localStorage = localStorage;
_securityService = securityService;
_logger = LogService.RegisterLogger<BasedServerAuthenticationStateProvider>();
}
private BasedAuthConfiguration _config;
private readonly ProtectedLocalStorage _localStorage;
private readonly SecurityService _securityService;
private readonly ILogger _logger;
private readonly AuthenticationState _anonState = new(new ClaimsPrincipal());
public override async Task<AuthenticationState> GetAuthenticationStateAsync()
{
_logger.Debug("Getting authentication state...");
var sessionIdResult = await _localStorage.GetAsync<string>(BasedAuthDefaults.StorageKey);
if (!sessionIdResult.Success || sessionIdResult.Value == null)
return _anonState;
_logger.Debug("Found state [{State}], getting session from {Service}", sessionIdResult.Value, nameof(SecurityService));
var stateResult = await _securityService.GetAuthenticationStateFromSessionAsync(sessionIdResult.Value);
return stateResult is { Success: true, Value: not null } ? stateResult.Value : _anonState;
}
}

25
DotBased.ASP.Auth/Domains/Auth/AuthenticationStateModel.cs
View File

@@ -1,25 +0,0 @@
using DotBased.ASP.Auth.Domains.Identity;
namespace DotBased.ASP.Auth.Domains.Auth;
public class AuthenticationStateModel
{
public AuthenticationStateModel(UserModel user)
{
UserId = user.Id;
}
public string Id { get; set; } = Guid.NewGuid().ToString();
public string UserId { get; set; }
public DateTime CreationDate { get; set; } = DateTime.Now;
public override bool Equals(object? obj)
{
if (obj is AuthenticationStateModel authStateModel)
return authStateModel.Id == Id;
return false;
}
// ReSharper disable once NonReadonlyMemberInGetHashCode
public override int GetHashCode() => Id.GetHashCode();
public override string ToString() => Id;
}

8
DotBased.ASP.Auth/Domains/Auth/PermissionModel.cs
View File

@@ -1,8 +0,0 @@
namespace DotBased.ASP.Auth.Domains.Auth;
public class PermissionModel
{
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
public string Permission { get; set; } = string.Empty;
}

12
DotBased.ASP.Auth/Domains/Auth/RoleModel.cs
View File

@@ -1,12 +0,0 @@
using DotBased.Objects;
namespace DotBased.ASP.Auth.Domains.Auth;
public class RoleModel
{
public string Id { get; set; } = Guid.NewGuid().ToString();
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
public List<PermissionModel> Permissions { get; set; } = [];
public List<DbObjectAttribute<IConvertible>> Attributes { get; set; } = [];
}

8
DotBased.ASP.Auth/Domains/Identity/GroupItemModel.cs
View File

@@ -1,8 +0,0 @@
namespace DotBased.ASP.Auth.Domains.Identity;
public class GroupItemModel
{
public string Id { get; set; } = Guid.NewGuid().ToString();
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
}

13
DotBased.ASP.Auth/Domains/Identity/GroupModel.cs
View File

@@ -1,13 +0,0 @@
using DotBased.ASP.Auth.Domains.Auth;
using DotBased.Objects;
namespace DotBased.ASP.Auth.Domains.Identity;
public class GroupModel
{
public string Id { get; set; } = Guid.NewGuid().ToString();
public string Name { get; set; } = string.Empty;
public string Description { get; set; } = string.Empty;
public List<RoleModel> Roles { get; set; } = [];
public List<DbObjectAttribute<IConvertible>> Attributes { get; set; } = [];
}

10
DotBased.ASP.Auth/Domains/Identity/UserItemModel.cs
View File

@@ -1,10 +0,0 @@
namespace DotBased.ASP.Auth.Domains.Identity;
public class UserItemModel
{
public string Id { get; set; } = string.Empty;
public string UserName { get; set; } = string.Empty;
public string Email { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string FamilyName { get; set; } = string.Empty;
}

31
DotBased.ASP.Auth/Domains/Identity/UserModel.cs
View File

@@ -1,31 +0,0 @@
using DotBased.ASP.Auth.Domains.Auth;
using DotBased.Objects;
namespace DotBased.ASP.Auth.Domains.Identity;
public class UserModel
{
public string UserName { get; set; } = string.Empty;
public string PasswordHash { get; set; } = string.Empty;
public string Email { get; set; } = string.Empty;
public string PhoneNumber { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string FamilyName { get; set; } = string.Empty;
public DateTime Dob { get; set; }
public string Id { get; set; } = Guid.NewGuid().ToString();
public bool Enabled { get; set; }
public bool EmailValidated { get; set; }
public bool PhoneNumberConfirmed { get; set; }
public bool Lockout { get; set; }
public DateTime LockoutEnd { get; set; }
public DateTime CreationStamp { get; set; }
public DateTime SecurityStamp { get; set; }
public DateTime ConcurrencyStamp { get; set; }
public int AccessFailedCount { get; set; }
public bool ExternalAuthentication { get; set; }
public List<GroupModel> Groups { get; set; } = [];
public List<RoleModel> Roles { get; set; } = [];
public List<DbObjectAttribute<IConvertible>> Attributes { get; set; } = [];
}

8
DotBased.ASP.Auth/Domains/LoginModel.cs
View File

@@ -1,8 +0,0 @@
namespace DotBased.ASP.Auth.Domains;
public class LoginModel
{
public string UserName { get; set; } = string.Empty;
public string Email { get; set; } = string.Empty;
public string Password { get; set; } = string.Empty;
}

10
DotBased.ASP.Auth/Domains/RegisterModel.cs
View File

@@ -1,10 +0,0 @@
namespace DotBased.ASP.Auth.Domains;
public class RegisterModel
{
public string UserName { get; set; } = string.Empty;
public string Email { get; set; } = string.Empty;
public string Password { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
public string FamilyName { get; set; } = string.Empty;
}

21
DotBased.ASP.Auth/DotBased.ASP.Auth.csproj
View File

@@ -1,21 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\DotBased\DotBased.csproj" />
</ItemGroup>
<ItemGroup>
<FrameworkReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>
<ItemGroup>
<Folder Include="Models\Auth\States\" />
<Folder Include="Models\Repositories\" />
</ItemGroup>
</Project>

55
DotBased.ASP.Auth/DotBasedAuthDependencyInjection.cs
View File

@@ -1,55 +0,0 @@
using DotBased.ASP.Auth.Services;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.Extensions.DependencyInjection;
namespace DotBased.ASP.Auth;
public static class DotBasedAuthDependencyInjection
{
/// <summary>
/// Use the DotBased authentication implementation
/// </summary>
/// <remarks>Use UseBasedServerAuth()!</remarks>
/// <param name="services">Service collection</param>
/// <param name="configurationAction">DotBased auth configuration</param>
public static IServiceCollection AddBasedServerAuth(this IServiceCollection services, Action<BasedAuthConfiguration>? configurationAction = null)
{
var Configuration = new BasedAuthConfiguration();
configurationAction?.Invoke(Configuration);
services.AddSingleton<BasedAuthConfiguration>(Configuration);
if (Configuration.AuthDataRepositoryType == null)
throw new ArgumentNullException(nameof(Configuration.AuthDataRepositoryType), $"No '{nameof(IAuthDataRepository)}' configured!");
services.AddScoped(typeof(IAuthDataRepository), Configuration.AuthDataRepositoryType);
services.AddSingleton<AuthDataCache>();
services.AddScoped<SecurityService>();
services.AddScoped<AuthenticationStateProvider, BasedServerAuthenticationStateProvider>();
services.AddAuthentication(options =>
{
options.DefaultScheme = BasedAuthDefaults.AuthenticationScheme;
});
services.AddAuthorization();
services.AddCascadingAuthenticationState();
return services;
}
public static WebApplication UseBasedServerAuth(this WebApplication app)
{
app.UseAuthentication();
app.UseAuthorization();
// Data
var authConfig = app.Services.GetService<BasedAuthConfiguration>();
if (authConfig == null)
throw new NullReferenceException($"{nameof(BasedAuthConfiguration)} is null!");
if (authConfig.AuthDataRepositoryType == null)
throw new NullReferenceException($"{nameof(authConfig.AuthDataRepositoryType)} is null, cannot instantiate an instance of {nameof(IAuthDataRepository)}");
var dataProvider = (IAuthDataRepository?)Activator.CreateInstance(authConfig.AuthDataRepositoryType);
if (dataProvider != null) authConfig.SeedData?.Invoke(dataProvider);
return app;
}
}

22
DotBased.ASP.Auth/IAuthDataRepository.cs
View File

@@ -1,22 +0,0 @@
using DotBased.ASP.Auth.Domains.Auth;
using DotBased.ASP.Auth.Domains.Identity;
namespace DotBased.ASP.Auth;
public interface IAuthDataRepository
{
public Task<ResultOld> CreateUserAsync(UserModel user);
public Task<ResultOld> UpdateUserAsync(UserModel user);
public Task<ResultOld> DeleteUserAsync(UserModel user);
public Task<ResultOld<UserModel>> GetUserAsync(string id, string email, string username);
public Task<ListResultOld<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "");
public Task<ResultOld> CreateGroupAsync(GroupModel group);
public Task<ResultOld> UpdateGroupAsync(GroupModel group);
public Task<ResultOld> DeleteGroupAsync(GroupModel group);
public Task<ResultOld<GroupModel>> GetGroupAsync(string id);
public Task<ListResultOld<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "");
public Task<ResultOld> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld<AuthenticationStateModel>> GetAuthenticationStateAsync(string id);
}

8
DotBased.ASP.Auth/ISessionStateProvider.cs
View File

@@ -1,8 +0,0 @@
namespace DotBased.ASP.Auth;
public interface ISessionStateProvider
{
public const string SessionStateName = "BasedServerSession";
public Task<ResultOld<string>> GetSessionStateAsync();
public Task<ResultOld> SetSessionStateAsync(string state);
}

107
DotBased.ASP.Auth/MemoryAuthDataRepository.cs
View File

@@ -1,107 +0,0 @@
using System.Diagnostics.CodeAnalysis;
using DotBased.ASP.Auth.Domains.Auth;
using DotBased.ASP.Auth.Domains.Identity;
using DotBased.Extensions;
namespace DotBased.ASP.Auth;
/// <summary>
/// In memory data provider, for testing only!
/// </summary>
[SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
public class MemoryAuthDataRepository : IAuthDataRepository
{
public async Task<ResultOld> CreateUserAsync(UserModel user)
{
if (MemoryData.users.Any(x => x.Id == user.Id || x.Email == user.Email))
return ResultOld.Failed("User already exists.");
MemoryData.users.Add(user);
return ResultOld.Ok();
}
public async Task<ResultOld> UpdateUserAsync(UserModel user)
{
if (MemoryData.users.All(x => x.Id != user.Id))
return ResultOld.Failed("User does not exist!");
return ResultOld.Ok();
}
public Task<ResultOld> DeleteUserAsync(UserModel user)
{
throw new NotImplementedException();
}
public async Task<ResultOld<UserModel>> GetUserAsync(string id, string email, string username)
{
UserModel? userModel = null;
if (!id.IsNullOrEmpty())
userModel = MemoryData.users.FirstOrDefault(u => u.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
if (!email.IsNullOrEmpty())
userModel = MemoryData.users.FirstOrDefault(u => u.Email.Equals(email, StringComparison.OrdinalIgnoreCase));
if (!username.IsNullOrEmpty())
userModel = MemoryData.users.FirstOrDefault(u => u.UserName.Equals(username, StringComparison.OrdinalIgnoreCase));
return userModel != null ? ResultOld<UserModel>.Ok(userModel) : ResultOld<UserModel>.Failed("No user found!");
}
public Task<ListResultOld<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "")
{
throw new NotImplementedException();
}
public Task<ResultOld> CreateGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<ResultOld> UpdateGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<ResultOld> DeleteGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<ResultOld<GroupModel>> GetGroupAsync(string id)
{
throw new NotImplementedException();
}
public Task<ListResultOld<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "")
{
throw new NotImplementedException();
}
public async Task<ResultOld> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
if (MemoryData.AuthenticationStates.Contains(authenticationState)) return ResultOld.Failed("Item already exists!");
MemoryData.AuthenticationStates.Add(authenticationState);
return ResultOld.Ok();
}
public Task<ResultOld> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
throw new NotImplementedException();
}
public async Task<ResultOld> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
MemoryData.AuthenticationStates.Remove(authenticationState);
return ResultOld.Ok();
}
public async Task<ResultOld<AuthenticationStateModel>> GetAuthenticationStateAsync(string id)
{
var item = MemoryData.AuthenticationStates.FirstOrDefault(x => x.Id == id);
if (item == null) return ResultOld<AuthenticationStateModel>.Failed("Could not get the session state!");
return ResultOld<AuthenticationStateModel>.Ok(item);
}
}
internal static class MemoryData
{
public static readonly List<UserModel> users = [];
public static readonly List<GroupModel> Groups = [];
public static readonly List<AuthenticationStateModel> AuthenticationStates = [];
}

11
DotBased.ASP.Auth/Models/Configuration/AuthConfiguration.cs
View File

@@ -1,11 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class AuthConfiguration
{
public CacheConfiguration Cache { get; set; } = new();
public LockoutConfiguration Lockout { get; set; } = new();
public PasswordConfiguration Password { get; set; } = new();
public ProviderConfiguration Provider { get; set; } = new();
public RepositoryConfiguration Repository { get; set; } = new();
public UserConfiguration User { get; set; } = new();
}

6
DotBased.ASP.Auth/Models/Configuration/CacheConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class CacheConfiguration
{
}

6
DotBased.ASP.Auth/Models/Configuration/LockoutConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class LockoutConfiguration
{
}

6
DotBased.ASP.Auth/Models/Configuration/PasswordConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class PasswordConfiguration
{
}

6
DotBased.ASP.Auth/Models/Configuration/ProviderConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class ProviderConfiguration
{
}

6
DotBased.ASP.Auth/Models/Configuration/RepositoryConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class RepositoryConfiguration
{
}

6
DotBased.ASP.Auth/Models/Configuration/UserConfiguration.cs
View File

@@ -1,6 +0,0 @@
namespace DotBased.ASP.Auth.Models.Configuration;
public class UserConfiguration
{
}

9
DotBased.ASP.Auth/SecurityManager.cs
View File

@@ -1,9 +0,0 @@
namespace DotBased.ASP.Auth.Managers;
public class SecurityManager
{
public SecurityManager()
{
}
}

137
DotBased.ASP.Auth/SecurityService.cs
View File

@@ -1,137 +0,0 @@
using System.Security.Claims;
using DotBased.ASP.Auth.Domains;
using DotBased.ASP.Auth.Domains.Auth;
using DotBased.ASP.Auth.Domains.Identity;
using DotBased.Extensions;
using DotBased.Logging;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage;
namespace DotBased.ASP.Auth;
public class SecurityService
{
public SecurityService(IAuthDataRepository authDataRepository, AuthDataCache dataCache, ProtectedLocalStorage localStorage)
{
_authDataRepository = authDataRepository;
_dataCache = dataCache;
_localStorage = localStorage;
_logger = LogService.RegisterLogger<SecurityService>();
}
private readonly IAuthDataRepository _authDataRepository;
private readonly AuthDataCache _dataCache;
private readonly ProtectedLocalStorage _localStorage;
private readonly ILogger _logger;
public async Task<ResultOld<AuthenticationState>> GetAuthenticationStateFromSessionAsync(string id)
{
if (id.IsNullOrEmpty())
return ResultOld<AuthenticationState>.Failed("No valid id!");
AuthenticationStateModel? authStateModel = null;
var stateCache = _dataCache.RequestSessionState(id);
if (!stateCache.Success || stateCache.Value == null)
{
var stateResult = await _authDataRepository.GetAuthenticationStateAsync(id);
if (stateResult is { Success: true, Value: not null })
{
authStateModel = stateResult.Value;
_dataCache.CacheSessionState(authStateModel);
}
}
else
{
if (stateCache.Value.Item2 != null)
return ResultOld<AuthenticationState>.Ok(stateCache.Value.Item2);
authStateModel = stateCache.Value.Item1;
}
if (authStateModel == null)
return ResultOld<AuthenticationState>.Failed("Failed to get auth state!");
var userResult = await _authDataRepository.GetUserAsync(authStateModel.UserId, string.Empty, string.Empty);
if (userResult is not { Success: true, Value: not null })
return ResultOld<AuthenticationState>.Failed("Failed to get user from state!");
var claims = new List<Claim>()
{
new(ClaimTypes.Sid, userResult.Value.Id),
new(ClaimTypes.Name, userResult.Value.Name),
new(ClaimTypes.NameIdentifier, userResult.Value.UserName),
new(ClaimTypes.Surname, userResult.Value.FamilyName),
new(ClaimTypes.Email, userResult.Value.Email)
};
claims.AddRange(userResult.Value.Groups.Select(group => new Claim(ClaimTypes.GroupSid, group.Id)));
claims.AddRange(userResult.Value.Roles.Select(role => new Claim(ClaimTypes.Role, role.Name)));
claims.AddRange(userResult.Value.Groups.Select(g => g.Roles).SelectMany(gRolesList => gRolesList, (_, role) => new Claim(ClaimTypes.Role, role.Name)));
var claimsIdentity = new ClaimsIdentity(claims, BasedAuthDefaults.AuthenticationScheme);
var authState = new AuthenticationState(new ClaimsPrincipal(claimsIdentity));
_dataCache.CacheSessionState(authStateModel, authState);
return ResultOld<AuthenticationState>.Ok(authState);
}
public async Task<ResultOld<AuthenticationStateModel>> LoginAsync(LoginModel login)
{
try
{
UserModel? user = null;
ResultOld<UserModel> usrResultOld;
if (!login.UserName.IsNullOrEmpty())
{
usrResultOld = await _authDataRepository.GetUserAsync(string.Empty, string.Empty, login.UserName);
if (usrResultOld is { Success: true, Value: not null })
user = usrResultOld.Value;
}
else if (!login.Email.IsNullOrEmpty())
{
usrResultOld = await _authDataRepository.GetUserAsync(string.Empty, login.Email, string.Empty);
if (usrResultOld is { Success: true, Value: not null })
user = usrResultOld.Value;
}
else
return ResultOld<AuthenticationStateModel>.Failed("Username & Email is empty, cannot login!");
if (user == null || !usrResultOld.Success)
return ResultOld<AuthenticationStateModel>.Failed("No user found!");
if (user.PasswordHash != login.Password) //TODO: Hash password and compare
return ResultOld<AuthenticationStateModel>.Failed("Login failed, invalid password.");
var state = new AuthenticationStateModel(user);
var authResult = await _authDataRepository.CreateAuthenticationStateAsync(state);
if (!authResult.Success)
return ResultOld<AuthenticationStateModel>.Failed("Failed to store session to database!");
_dataCache.CacheSessionState(state);
await _localStorage.SetAsync(BasedAuthDefaults.StorageKey, state.Id);
return ResultOld<AuthenticationStateModel>.Ok(state);
}
catch (Exception e)
{
_logger.Error(e, "Failed to login!");
return ResultOld<AuthenticationStateModel>.Failed("Login failed, exception thrown!");
}
}
public async Task<ResultOld> LogoutAsync(string state)
{
try
{
if (state.IsNullOrEmpty())
return ResultOld.Failed($"Argument {nameof(state)} is empty!");
var stateResult = await _authDataRepository.GetAuthenticationStateAsync(state);
if (!stateResult.Success || stateResult.Value == null)
return stateResult;
var authState = stateResult.Value;
_dataCache.PurgeSessionState(state);
var updatedStateResult = await _authDataRepository.DeleteAuthenticationStateAsync(authState);
if (updatedStateResult.Success) return updatedStateResult;
_logger.Warning(updatedStateResult.Message);
return updatedStateResult;
}
catch (Exception e)
{
_logger.Error(e, "Failed to logout!");
return ResultOld.Failed("Failed to logout, exception thrown!");
}
}
}

7
DotBased.sln
View File

@@ -8,8 +8,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotBased.Logging.Serilog",
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Modules", "Modules", "{2156FB93-C252-4B33-8A0C-73C82FABB163}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotBased.ASP.Auth", "DotBased.ASP.Auth\DotBased.ASP.Auth.csproj", "{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotBased.Logging.MEL", "DotBased.Logging.MEL\DotBased.Logging.MEL.csproj", "{D4D9B584-A524-4CBB-9B61-9CD65ED4AF0D}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Test", "Test", "{DBDB4538-85D4-45AC-9E0A-A684467AEABA}"
@@ -42,10 +40,6 @@ Global
{EBBDAF9A-BFC7-4BDC-8C51-0501B59A1DDC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{EBBDAF9A-BFC7-4BDC-8C51-0501B59A1DDC}.Release|Any CPU.ActiveCfg = Release|Any CPU
{EBBDAF9A-BFC7-4BDC-8C51-0501B59A1DDC}.Release|Any CPU.Build.0 = Release|Any CPU
{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D}.Release|Any CPU.Build.0 = Release|Any CPU
{D4D9B584-A524-4CBB-9B61-9CD65ED4AF0D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{D4D9B584-A524-4CBB-9B61-9CD65ED4AF0D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D4D9B584-A524-4CBB-9B61-9CD65ED4AF0D}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -69,7 +63,6 @@ Global
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{EBBDAF9A-BFC7-4BDC-8C51-0501B59A1DDC} = {2156FB93-C252-4B33-8A0C-73C82FABB163}
{CBD4111D-F1CA-466A-AC73-9EAB7F235B3D} = {2156FB93-C252-4B33-8A0C-73C82FABB163}
{D4D9B584-A524-4CBB-9B61-9CD65ED4AF0D} = {2156FB93-C252-4B33-8A0C-73C82FABB163}
{BADA4BAF-142B-47A8-95FC-B25E1D3D0020} = {DBDB4538-85D4-45AC-9E0A-A684467AEABA}
{AC8343A5-7953-4E1D-A926-406BE4D7E819} = {DBDB4538-85D4-45AC-9E0A-A684467AEABA}