.gitea/workflows/BuildLibrary.yml

@@ -1,50 +0,0 @@
-name: Build C# Library
-
-run-name: Build Library project
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup .NET SDK
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: '8.0.x'
-
-      - name: Restore dependencies
-        run: dotnet restore
-
-      - name: Build library
-        run: dotnet build --configuration Release
-        
-      - name: Pack DotBased
-        run: dotnet pack ./DotBased/DotBased.csproj --configuration Release -o ./artifacts
-        
-      - name: Pack DotBased.Logging.MEL
-        run: dotnet pack ./DotBased.Logging.MEL/DotBased.Logging.MEL.csproj --configuration Release -o ./artifacts
-        
-      - name: Pack DotBased.Logging.Serilog
-        run: dotnet pack ./DotBased.Logging.Serilog/DotBased.Logging.Serilog.csproj --configuration Release -o ./artifacts
-
-      - name: Publish library to Gitea NuGet
-        run: |
-          dotnet nuget add source \
-            --username $GITEA_USER \
-            --password $GITEA_TOKEN \
-            --store-password-in-clear-text \
-            --name gitea \
-            https://git.netzbyte.com/api/packages/$GITEA_USER/nuget/index.json
-          
-          dotnet nuget push ./artifacts/*.nupkg --source gitea --skip-duplicate
-        env:
-          GITEA_USER: max
-          GITEA_TOKEN: ${{ secrets.PACKAGES_TOKEN }}

DotBased.ASP.Auth/AuthDataCache.cs

@@ -0,0 +1,98 @@
+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);
+    }
+}

DotBased.ASP.Auth/AuthenticationService.cs

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

DotBased.ASP.Auth/BasedAuthConfiguration.cs

@@ -0,0 +1,65 @@
+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
+{
+    
+}

DotBased.ASP.Auth/BasedAuthDefaults.cs

@@ -0,0 +1,13 @@
+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);
+}

DotBased.ASP.Auth/BasedServerAuthenticationStateProvider.cs

@@ -0,0 +1,40 @@
+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;
+    }
+}

DotBased.ASP.Auth/Domains/Auth/AuthenticationStateModel.cs

@@ -0,0 +1,25 @@
+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;
+}

DotBased.ASP.Auth/Domains/Auth/PermissionModel.cs

@@ -0,0 +1,8 @@
+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;
+}

DotBased.ASP.Auth/Domains/Auth/RoleModel.cs

@@ -0,0 +1,12 @@
+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; } = [];
+}

DotBased.ASP.Auth/Domains/Identity/GroupItemModel.cs

@@ -0,0 +1,8 @@
+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;
+}

DotBased.ASP.Auth/Domains/Identity/GroupModel.cs

@@ -0,0 +1,13 @@
+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; } = [];
+}

DotBased.ASP.Auth/Domains/Identity/UserItemModel.cs

@@ -0,0 +1,10 @@
+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;
+}

DotBased.ASP.Auth/Domains/Identity/UserModel.cs

@@ -0,0 +1,31 @@
+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; } = [];
+}

DotBased.ASP.Auth/Domains/LoginModel.cs

@@ -0,0 +1,8 @@
+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;
+}

DotBased.ASP.Auth/Domains/RegisterModel.cs

@@ -0,0 +1,10 @@
+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;
+}

DotBased.ASP.Auth/DotBased.ASP.Auth.csproj

@@ -0,0 +1,21 @@
+<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>

DotBased.ASP.Auth/DotBasedAuthDependencyInjection.cs

@@ -0,0 +1,55 @@
+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;
+    }
+}

DotBased.ASP.Auth/IAuthDataRepository.cs

@@ -0,0 +1,22 @@
+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);
+}

DotBased.ASP.Auth/ISessionStateProvider.cs

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

DotBased.ASP.Auth/MemoryAuthDataRepository.cs

@@ -0,0 +1,107 @@
+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 = [];
+}

DotBased.ASP.Auth/Models/Configuration/AuthConfiguration.cs

@@ -0,0 +1,11 @@
+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();
+}

DotBased.ASP.Auth/Models/Configuration/CacheConfiguration.cs

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

DotBased.ASP.Auth/Models/Configuration/LockoutConfiguration.cs

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

DotBased.ASP.Auth/Models/Configuration/PasswordConfiguration.cs

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

DotBased.ASP.Auth/Models/Configuration/ProviderConfiguration.cs

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

DotBased.ASP.Auth/Models/Configuration/RepositoryConfiguration.cs

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

DotBased.ASP.Auth/Models/Configuration/UserConfiguration.cs

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

DotBased.ASP.Auth/SecurityManager.cs

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

DotBased.ASP.Auth/SecurityService.cs

@@ -0,0 +1,137 @@
+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!");
+        }
+    }
+}

DotBased.AspNet.Authority/AuthorityProviderExtensions.cs

@@ -26,7 +26,6 @@ public static class AuthorityProviderExtensions
         services.TryAddScoped<IPasswordValidator, PasswordOptionsValidator>();
         services.TryAddScoped<IPasswordValidator, PasswordEqualsValidator>();
         services.TryAddScoped<IUserValidator, UserValidator>();
-        
         /*services.TryAddScoped<IEmailVerifier, EmailVerifier>();
         services.TryAddScoped<IPhoneNumberVerifier, PhoneNumberVerifier>();
         services.TryAddScoped<IUserVerifier, UserVerifier>();*/

DotBased.sln

@@ -8,6 +8,8 @@ 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}"
@@ -40,6 +42,10 @@ 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
@@ -63,6 +69,7 @@ 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}