initial commit

.gitignore

@@ -0,0 +1,31 @@
+# OS files
+Thumbs.db
+.DS_Store
+*.swp
+*.swo
+
+# IDE
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# .NET
+bin/
+obj/
+*.user
+*.suo
+*.cache
+*.log
+*.vs/
+packages/
+*.nupkg
+
+# Docker
+.dockerignore
+
+# Uploads & Logs
+wwwroot/uploads/*
+!wwwroot/uploads/.gitkeep
+wwwroot/xlogs/*
+!wwwroot/xlogs/.gitkeep

ConfigBackEnd/Attributes/AuthorizeAttribute.cs

@@ -0,0 +1,18 @@
+namespace Indotalent.ConfigBackEnd.Attributes;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+public class AuthorizeAttribute : Attribute
+{
+    public string Role { get; set; } = string.Empty;
+    public string Permission { get; set; } = string.Empty;
+    public string Policy { get; set; } = string.Empty;
+
+    public AuthorizeAttribute()
+    {
+    }
+
+    public AuthorizeAttribute(string role)
+    {
+        Role = role;
+    }
+}

ConfigBackEnd/Behaviours/AuthorizationBehaviour.cs

@@ -0,0 +1,68 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Attributes;
+using Indotalent.ConfigBackEnd.Exceptions;
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR;
+using System.Reflection;
+
+public class AuthorizationBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ICurrentUserService _currentUserService;
+
+    public AuthorizationBehaviour(ICurrentUserService currentUserService)
+    {
+        _currentUserService = currentUserService;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        var authorizeAttributes = request.GetType().GetCustomAttributes<AuthorizeAttribute>();
+
+        if (authorizeAttributes.Any())
+        {
+            if (_currentUserService.UserId == null)
+            {
+                throw new UnauthorizedAccessException();
+            }
+
+            var authorizeAttributesWithRoles = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Role));
+
+            if (authorizeAttributesWithRoles.Any())
+            {
+                var authorized = false;
+                foreach (var role in authorizeAttributesWithRoles.Select(a => a.Role))
+                {
+                    var isInRole = await _currentUserService.IsInRoleAsync(role.Trim());
+                    if (isInRole)
+                    {
+                        authorized = true;
+                        break;
+                    }
+                }
+
+                if (!authorized)
+                {
+                    throw new ForbiddenAccessException();
+                }
+            }
+
+            var authorizeAttributesWithPermissions = authorizeAttributes.Where(a => !string.IsNullOrWhiteSpace(a.Permission));
+
+            if (authorizeAttributesWithPermissions.Any())
+            {
+                foreach (var permission in authorizeAttributesWithPermissions.Select(a => a.Permission))
+                {
+                    var hasPermission = await _currentUserService.HasPermissionAsync(permission.Trim());
+                    if (!hasPermission)
+                    {
+                        throw new ForbiddenAccessException();
+                    }
+                }
+            }
+        }
+
+        return await next();
+    }
+}

ConfigBackEnd/Behaviours/LoggingBehaviour.cs

@@ -0,0 +1,30 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR.Pipeline;
+using Microsoft.Extensions.Logging;
+
+public class LoggingBehaviour<TRequest> : IRequestPreProcessor<TRequest>
+    where TRequest : notnull
+{
+    private readonly ILogger _logger;
+    private readonly ICurrentUserService _currentUserService;
+
+    public LoggingBehaviour(ILogger<TRequest> logger, ICurrentUserService currentUserService)
+    {
+        _logger = logger;
+        _currentUserService = currentUserService;
+    }
+
+    public Task Process(TRequest request, CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+        var userId = _currentUserService.UserId ?? string.Empty;
+        var userName = _currentUserService.UserName ?? string.Empty;
+
+        _logger.LogInformation("Request: {Name} {UserId} {UserName} {@Request}",
+            requestName, userId, userName, request);
+
+        return Task.CompletedTask;
+    }
+}

ConfigBackEnd/Behaviours/PerformanceBehaviour.cs

@@ -0,0 +1,46 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.ConfigBackEnd.Interfaces;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+
+public class PerformanceBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly Stopwatch _timer;
+    private readonly ILogger<TRequest> _logger;
+    private readonly ICurrentUserService _currentUserService;
+
+    public PerformanceBehaviour(
+        ILogger<TRequest> logger,
+        ICurrentUserService currentUserService)
+    {
+        _timer = new Stopwatch();
+        _logger = logger;
+        _currentUserService = currentUserService;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        _timer.Start();
+
+        var response = await next();
+
+        _timer.Stop();
+
+        var elapsedMilliseconds = _timer.ElapsedMilliseconds;
+
+        if (elapsedMilliseconds > 500)
+        {
+            var requestName = typeof(TRequest).Name;
+            var userId = _currentUserService.UserId ?? string.Empty;
+            var userName = _currentUserService.UserName ?? string.Empty;
+
+            _logger.LogWarning("Long Running Request: {Name} ({ElapsedMilliseconds} milliseconds) {@UserId} {@UserName} {@Request}",
+                requestName, elapsedMilliseconds, userId, userName, request);
+        }
+
+        return response;
+    }
+}

ConfigBackEnd/Behaviours/UnhandledExceptionBehaviour.cs

@@ -0,0 +1,33 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using Indotalent.Shared.Consts;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+public class UnhandledExceptionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly ILogger<TRequest> _logger;
+
+    public UnhandledExceptionBehaviour(ILogger<TRequest> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await next();
+        }
+        catch (Exception ex)
+        {
+            var requestName = typeof(TRequest).Name;
+
+            _logger.LogError(ex, GlobalConsts.BehaviourError + " {Name} {@Request}",
+                requestName, request);
+
+            throw;
+        }
+    }
+}

ConfigBackEnd/Behaviours/ValidationBehaviour.cs

@@ -0,0 +1,42 @@
+namespace Indotalent.ConfigBackEnd.Behaviours;
+
+using FluentValidation;
+using MediatR;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class ValidationBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    private readonly IEnumerable<IValidator<TRequest>> _validators;
+
+    public ValidationBehaviour(IEnumerable<IValidator<TRequest>> validators)
+    {
+        _validators = validators;
+    }
+
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
+    {
+        if (_validators.Any())
+        {
+            var context = new ValidationContext<TRequest>(request);
+
+            var validationResults = await Task.WhenAll(
+                _validators.Select(v => v.ValidateAsync(context, cancellationToken)));
+
+            var failures = validationResults
+                .SelectMany(r => r.Errors)
+                .Where(f => f != null)
+                .ToList();
+
+            if (failures.Count != 0)
+            {
+                throw new ValidationException(failures);
+            }
+        }
+
+        return await next();
+    }
+}

ConfigBackEnd/DI.cs

@@ -0,0 +1,30 @@
+namespace Indotalent.ConfigBackEnd;
+
+using FluentValidation;
+using Indotalent.ConfigBackEnd.Behaviours;
+using MediatR;
+using MediatR.Pipeline;
+using Microsoft.Extensions.DependencyInjection;
+
+public static class DI
+{
+    public static IServiceCollection AddConfigBackEndDI(this IServiceCollection services)
+    {
+        services.AddMediatR(cfg =>
+        {
+            cfg.RegisterServicesFromAssembly(typeof(DI).Assembly);
+
+            cfg.AddRequestPreProcessor(typeof(IRequestPreProcessor<>), typeof(LoggingBehaviour<>));
+            cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(UnhandledExceptionBehaviour<,>));
+            cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(PerformanceBehaviour<,>));
+            cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehaviour<,>));
+            cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(AuthorizationBehaviour<,>));
+
+            cfg.Lifetime = ServiceLifetime.Scoped;
+        });
+
+        services.AddValidatorsFromAssembly(typeof(DI).Assembly);
+
+        return services;
+    }
+}

ConfigBackEnd/Exceptions/AlreadyExistsExceptions.cs

@@ -0,0 +1,24 @@
+namespace Indotalent.ConfigBackEnd.Exceptions;
+
+public class AlreadyExistsException : Exception
+{
+    public AlreadyExistsException()
+        : base()
+    {
+    }
+
+    public AlreadyExistsException(string message)
+        : base(message)
+    {
+    }
+
+    public AlreadyExistsException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+
+    public AlreadyExistsException(string name, object key)
+        : base($"Entity \"{name}\" ({key}) already exists.")
+    {
+    }
+}

ConfigBackEnd/Exceptions/ForbiddenAccessException.cs

@@ -0,0 +1,17 @@
+namespace Indotalent.ConfigBackEnd.Exceptions;
+
+public class ForbiddenAccessException : Exception
+{
+    public ForbiddenAccessException() : base()
+    {
+    }
+
+    public ForbiddenAccessException(string message) : base(message)
+    {
+    }
+
+    public ForbiddenAccessException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

ConfigBackEnd/Exceptions/MismatchException.cs

@@ -0,0 +1,24 @@
+namespace Indotalent.ConfigBackEnd.Exceptions;
+
+public class MismatchException : Exception
+{
+    public MismatchException()
+        : base()
+    {
+    }
+
+    public MismatchException(string message)
+        : base(message)
+    {
+    }
+
+    public MismatchException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+
+    public MismatchException(string name, object expected, object actual)
+        : base($"Mismatch detected for \"{name}\". Expected: {expected}, but received: {actual}.")
+    {
+    }
+}

ConfigBackEnd/Exceptions/NotFoundException.cs

@@ -0,0 +1,24 @@
+namespace Indotalent.ConfigBackEnd.Exceptions;
+
+public class NotFoundException : Exception
+{
+    public NotFoundException()
+        : base()
+    {
+    }
+
+    public NotFoundException(string message)
+        : base(message)
+    {
+    }
+
+    public NotFoundException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+
+    public NotFoundException(string name, object key)
+        : base($"Entity \"{name}\" ({key}) was not found.")
+    {
+    }
+}

ConfigBackEnd/Exceptions/ValidationException.cs

@@ -0,0 +1,36 @@
+namespace Indotalent.ConfigBackEnd.Exceptions;
+
+using FluentValidation.Results;
+using System.Collections.Generic;
+using System.Linq;
+
+public class ValidationException : Exception
+{
+    public IDictionary<string, string[]> Errors { get; }
+
+    public ValidationException()
+        : base("One or more validation failures have occurred.")
+    {
+        Errors = new Dictionary<string, string[]>();
+    }
+
+    public ValidationException(IEnumerable<ValidationFailure> failures)
+        : this()
+    {
+        Errors = failures
+            .GroupBy(e => e.PropertyName, e => e.ErrorMessage)
+            .ToDictionary(failureGroup => failureGroup.Key, failureGroup => failureGroup.ToArray());
+    }
+
+    public ValidationException(string message)
+        : base(message)
+    {
+        Errors = new Dictionary<string, string[]>();
+    }
+
+    public ValidationException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+        Errors = new Dictionary<string, string[]>();
+    }
+}

ConfigBackEnd/Extensions/AppDbContextExtensions.cs

@@ -0,0 +1,40 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.Infrastructure.AutoNumberGenerator;
+using Indotalent.Infrastructure.Database;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+public static class AppDbContextExtensions
+{
+    public static async Task<string> GenerateAutoNumberAsync(
+    this AppDbContext context,
+    string entityName,
+    string prefixTemplate,
+    string? suffixTemplate = null,
+    int paddingLength = 4,
+    bool useYear = true,
+    bool useMonth = false,
+    CancellationToken ct = default)
+    {
+        var currentUserService = context.GetService<ICurrentUserService>();
+        var tenantId = currentUserService?.TenantId;
+
+        if (string.IsNullOrWhiteSpace(tenantId))
+        {
+            throw new InvalidOperationException("TenantId cannot be null or empty for multi-tenant auto-number sequence generation. Ensure the user session context is valid.");
+        }
+
+        var generator = context.GetService<AutoNumberGeneratorService>();
+
+        return await generator.GenerateNextNumberAsync(
+            tenantId,
+            entityName,
+            prefixTemplate,
+            suffixTemplate,
+            paddingLength,
+            useYear,
+            useMonth,
+            ct);
+    }
+}

ConfigBackEnd/Extensions/DateTimeExtensions.cs

@@ -0,0 +1,14 @@
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+public static class DateTimeExtensions
+{
+    private const string DefaultFormat = "dd MMM yyyy, HH:mm";
+
+    public static string ToString(this DateTimeOffset? dateTimeOffset, string format = DefaultFormat)
+    {
+        if (!dateTimeOffset.HasValue) return "-";
+
+        return dateTimeOffset.Value.ToLocalTime().ToString(format);
+    }
+
+}

ConfigBackEnd/Extensions/GenericExtensions.cs

@@ -0,0 +1,86 @@
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+using Indotalent.Shared.Models;
+using Microsoft.AspNetCore.Http;
+using System.Text.Json;
+
+public static class GenericExtensions
+{
+    public static bool IsNullOrEmpty<T>(this IEnumerable<T>? enumerable)
+    {
+        return enumerable == null || !enumerable.Any();
+    }
+
+    public static T? ToObject<T>(this string json)
+    {
+        if (string.IsNullOrWhiteSpace(json)) return default;
+
+        return JsonSerializer.Deserialize<T>(json, new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        });
+    }
+
+    public static string ToJson<T>(this T obj)
+    {
+        return JsonSerializer.Serialize(obj);
+    }
+
+    public static TDestination MapTo<TDestination>(this object source)
+        where TDestination : new()
+    {
+        var json = JsonSerializer.Serialize(source);
+        return JsonSerializer.Deserialize<TDestination>(json) ?? new TDestination();
+    }
+
+    public static string ToCurrency(this decimal value, string culture = "id-ID")
+    {
+        return value.ToString("C0", new System.Globalization.CultureInfo(culture));
+    }
+
+    public static bool IsBetween<T>(this T value, T low, T high) where T : IComparable<T>
+    {
+        return value.CompareTo(low) >= 0 && value.CompareTo(high) <= 0;
+    }
+
+    public static IResult ToApiResponse<T>(this PagedList<T> result)
+    {
+        return Results.Ok(new ApiResponse<List<T>>
+        {
+            IsSuccess = true,
+            StatusCode = 200,
+            Value = result.Value,
+            Pagination = new PaginationMetadata
+            {
+                Count = result.Count,
+                Top = result.Top,
+                Skip = result.Skip
+            },
+            ServerTime = DateTime.UtcNow
+        });
+    }
+
+    public static IResult ToApiResponse<T>(this T? result, string? message = null, int statusCode = 200)
+    {
+        if (result == null)
+        {
+            return Results.NotFound(new ApiResponse<T>
+            {
+                IsSuccess = false,
+                StatusCode = 404,
+                Message = message ?? "Data not found",
+                ServerTime = DateTime.UtcNow
+            });
+        }
+
+        return Results.Ok(new ApiResponse<T>
+        {
+            IsSuccess = true,
+            StatusCode = statusCode,
+            Message = message,
+            Value = result,
+            Pagination = null,
+            ServerTime = DateTime.UtcNow
+        });
+    }
+}

ConfigBackEnd/Extensions/IQueryableExtensions.cs

@@ -0,0 +1,63 @@
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+using Indotalent.Data.Interfaces;
+using Indotalent.Shared.Models;
+using Microsoft.EntityFrameworkCore;
+using System.Linq.Expressions;
+
+public static class IQueryableExtensions
+{
+    public static IQueryable<T> WhereIf<T>(
+        this IQueryable<T> query,
+        bool condition,
+        Expression<Func<T, bool>> predicate)
+    {
+        return condition ? query.Where(predicate) : query;
+    }
+
+    public static async Task<PagedList<T>> ToPagedListAsync<T>(
+            this IQueryable<T> query,
+            int skip,
+            int top)
+    {
+        top = top <= 0 ? 5 : top;
+        skip = skip < 0 ? 0 : skip;
+
+        var count = await query.CountAsync();
+
+        var items = await query
+            .Skip(skip)
+            .Take(top)
+            .ToListAsync();
+
+        return new PagedList<T>(items, count, skip, top);
+    }
+
+    public static IQueryable<T> OrderByPropertyName<T>(
+        this IQueryable<T> query,
+        string? propertyName,
+        bool isDescending)
+    {
+        if (string.IsNullOrWhiteSpace(propertyName)) return query;
+
+        var parameter = Expression.Parameter(typeof(T), "x");
+        var property = Expression.Property(parameter, propertyName);
+        var lambda = Expression.Lambda(property, parameter);
+
+        var methodName = isDescending ? "OrderByDescending" : "OrderBy";
+        var resultExpression = Expression.Call(
+            typeof(Queryable),
+            methodName,
+            new Type[] { typeof(T), property.Type },
+            query.Expression,
+            Expression.Quote(lambda));
+
+        return query.Provider.CreateQuery<T>(resultExpression);
+    }
+
+    public static IQueryable<T> NotDeletedOnly<T>(this IQueryable<T> query)
+        where T : class, IHasIsDeleted
+    {
+        return query.Where(x => !x.IsDeleted);
+    }
+}

ConfigBackEnd/Extensions/ListExtensions.cs

@@ -0,0 +1,51 @@
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public static class ListExtensions
+{
+    public static void AddIf<T>(this IList<T> list, bool condition, T item)
+    {
+        if (condition)
+        {
+            list.Add(item);
+        }
+    }
+
+    public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int size)
+    {
+        while (source.Any())
+        {
+            yield return source.Take(size);
+            source = source.Skip(size);
+        }
+    }
+
+    public static void Shuffle<T>(this IList<T> list)
+    {
+        var rng = new Random();
+        int n = list.Count;
+        while (n > 1)
+        {
+            n--;
+            int k = rng.Next(n + 1);
+            T value = list[k];
+            list[k] = list[n];
+            list[n] = value;
+        }
+    }
+
+    public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
+    {
+        var seenKeys = new HashSet<TKey>();
+        foreach (var element in source)
+        {
+            if (seenKeys.Add(keySelector(element)))
+            {
+                yield return element;
+            }
+        }
+    }
+}

ConfigBackEnd/Extensions/StringExtensions.cs

@@ -0,0 +1,92 @@
+namespace Indotalent.ConfigBackEnd.Extensions;
+
+using System.Text.RegularExpressions;
+
+public static class StringExtensions
+{
+    public static string ToShortNameVowel(this string? value, int length = 3)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return "GEN";
+
+        var vowels = new string(value.Where(c => "AEIOUaeiou".Contains(c)).ToArray());
+        var baseName = vowels.Length >= length ? vowels : value;
+
+        return new string(baseName.Trim().Take(length).ToArray()).ToUpper();
+    }
+
+    public static string ToShortNameConsonant(this string? value, int length = 3)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return "GEN";
+
+        var consonants = new string(value.Where(c => char.IsLetter(c) && !"AEIOUaeiou".Contains(c)).ToArray());
+        var baseName = consonants.Length >= length ? consonants : value;
+
+        return new string(baseName.Trim().Take(length).ToArray()).ToUpper();
+    }
+
+    public static string ToInitial(this string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return "XX";
+
+        var words = value.Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
+
+        if (words.Length >= 2)
+        {
+            var firstInitial = words[0][0];
+            var secondInitial = words[1][0];
+            return $"{firstInitial}{secondInitial}".ToUpper();
+        }
+
+        return new string(value.Trim().Take(2).ToArray()).ToUpper();
+    }
+
+    public static bool IsNotNullOrWhiteSpace(this string? value)
+    {
+        return !string.IsNullOrWhiteSpace(value);
+    }
+
+    public static string ToTitleCase(this string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return string.Empty;
+
+        return System.Globalization.CultureInfo.CurrentCulture.TextInfo
+            .ToTitleCase(value.ToLower().Trim());
+    }
+
+    public static string ToSlug(this string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return string.Empty;
+
+        var str = value.ToLower().Trim();
+        str = Regex.Replace(str, @"[^a-z0-9\s-]", "");
+        str = Regex.Replace(str, @"[\s-]+", " ").Trim();
+        str = str.Replace(" ", "-");
+
+        return str;
+    }
+
+    public static string MaskEmail(this string? email)
+    {
+        if (string.IsNullOrWhiteSpace(email) || !email.Contains("@")) return "******";
+
+        var parts = email.Split('@');
+        var name = parts[0];
+        var domain = parts[1];
+
+        if (name.Length <= 2) return $"{name}***@{domain}";
+
+        return $"{name[..2]}***{name[^1..]}@{domain}";
+    }
+
+    public static string Truncate(this string? value, int maxLength)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return string.Empty;
+        return value.Length <= maxLength ? value : $"{value[..maxLength]}...";
+    }
+
+    public static string RemoveNonNumeric(this string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return string.Empty;
+        return Regex.Replace(value, "[^0-9]", "");
+    }
+}

ConfigBackEnd/Interfaces/ICurrentUserService.cs

@@ -0,0 +1,12 @@
+namespace Indotalent.ConfigBackEnd.Interfaces;
+
+public interface ICurrentUserService
+{
+    string? TenantId { get; set; }
+    string? UserId { get; set; }
+    string? UserName { get; set; }
+    string? Email { get; set; }
+    string? FullName { get; set; }
+    Task<bool> IsInRoleAsync(string role);
+    Task<bool> HasPermissionAsync(string permission);
+}

ConfigBackEnd/Mappings/IMapFrom.cs

@@ -0,0 +1,8 @@
+namespace Indotalent.ConfigBackEnd.Mappings;
+
+using AutoMapper;
+
+public interface IMapFrom<T>
+{
+    void Mapping(Profile profile) => profile.CreateMap(typeof(T), GetType());
+}

ConfigBackEnd/Mappings/MappingProfile.cs

@@ -0,0 +1,30 @@
+namespace Indotalent.ConfigBackEnd.Mappings;
+
+using AutoMapper;
+using System.Reflection;
+
+public class MappingProfile : Profile
+{
+    public MappingProfile()
+    {
+        ApplyMappingsFromAssembly(Assembly.GetExecutingAssembly());
+    }
+
+    private void ApplyMappingsFromAssembly(Assembly assembly)
+    {
+        var types = assembly.GetExportedTypes()
+            .Where(t => t.GetInterfaces().Any(i =>
+                i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMapFrom<>)))
+            .ToList();
+
+        foreach (var type in types)
+        {
+            var instance = Activator.CreateInstance(type);
+
+            var methodInfo = type.GetMethod("Mapping")
+                ?? type.GetInterface("IMapFrom`1")?.GetMethod("Mapping");
+
+            methodInfo?.Invoke(instance, new object[] { this });
+        }
+    }
+}

ConfigBackEnd/Middleware/ExceptionHandlingMiddleware.cs

@@ -0,0 +1,105 @@
+using Indotalent.ConfigBackEnd.Exceptions;
+using Indotalent.Shared.Consts;
+using Indotalent.Shared.Models;
+using System.Net;
+using System.Text.Json;
+
+namespace Indotalent.ConfigBackEnd.Middleware;
+
+public class ExceptionHandlingMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly ILogger<ExceptionHandlingMiddleware> _logger;
+
+    public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
+    {
+        _next = next;
+        _logger = logger;
+    }
+
+    public async Task Invoke(HttpContext context)
+    {
+        try
+        {
+            await _next(context);
+        }
+        catch (Exception ex)
+        {
+            await HandleExceptionAsync(context, ex);
+        }
+    }
+
+    private async Task HandleExceptionAsync(HttpContext context, Exception exception)
+    {
+        var code = HttpStatusCode.InternalServerError;
+        var message = "An unexpected error occurred on the server.";
+        var errors = new List<string>();
+
+        switch (exception)
+        {
+            case ValidationException validationException:
+                code = HttpStatusCode.BadRequest;
+                message = "One or more validation failures have occurred.";
+                foreach (var error in validationException.Errors)
+                {
+                    errors.AddRange(error.Value);
+                }
+                break;
+
+            case NotFoundException notFoundException:
+                code = HttpStatusCode.NotFound;
+                message = notFoundException.Message;
+                errors.Add(notFoundException.Message);
+                break;
+
+            case AlreadyExistsException alreadyExistsException:
+                code = HttpStatusCode.Conflict;
+                message = alreadyExistsException.Message;
+                errors.Add(alreadyExistsException.Message);
+                break;
+
+            case MismatchException mismatchException:
+                code = HttpStatusCode.BadRequest;
+                message = mismatchException.Message;
+                errors.Add(mismatchException.Message);
+                break;
+
+            case ForbiddenAccessException:
+                code = HttpStatusCode.Forbidden;
+                message = "You do not have permission to access this resource.";
+                errors.Add("Access denied to the requested resource.");
+                break;
+
+            case UnauthorizedAccessException:
+                code = HttpStatusCode.Unauthorized;
+                message = "Authentication is required to access this resource.";
+                errors.Add("Session invalid or expired.");
+                break;
+
+            default:
+                if (exception.StackTrace != null && exception.StackTrace.Contains(GlobalConsts.BehaviourError))
+                {
+                    _logger.LogError(exception, GlobalConsts.GlobalError + " {Message} on {Path}",
+                        exception.Message, context.Request.Path);
+                }
+                message = "An unexpected error occurred on the HRM server.";
+                errors.Add(exception.Message);
+                break;
+        }
+
+        context.Response.ContentType = "application/json";
+        context.Response.StatusCode = (int)code;
+
+        var response = new ApiResponse<object>
+        {
+            IsSuccess = false,
+            StatusCode = (int)code,
+            Message = message,
+            Errors = errors,
+            ServerTime = DateTime.UtcNow
+        };
+
+        var jsonOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+        await context.Response.WriteAsync(JsonSerializer.Serialize(response, jsonOptions));
+    }
+}

ConfigFrontEnd/Common/BaseAppPage.cs

@@ -0,0 +1,37 @@
+using Indotalent.ConfigFrontEnd.Extensions;
+using Indotalent.ConfigFrontEnd.Models;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Authorization;
+
+namespace Indotalent.ConfigFrontEnd.Common;
+
+
+public abstract class BaseAppPage : ComponentBase
+{
+    [Inject]
+    protected AuthenticationStateProvider AuthStateProvider { get; set; } = default!;
+
+    [Inject]
+    protected CurrentUserState State { get; set; } = default!;
+
+    protected override async Task OnParametersSetAsync()
+    {
+        await SyncUserContext();
+        await base.OnParametersSetAsync();
+    }
+
+    private async Task SyncUserContext()
+    {
+        var authState = await AuthStateProvider.GetAuthenticationStateAsync();
+        var user = authState.User;
+
+        if (user.Identity?.IsAuthenticated == true)
+        {
+            State.UserId = user.GetUserId();
+            State.UserName = user.GetUserName();
+            State.Email = user.GetEmail();
+            State.FullName = user.GetFullName();
+            State.TenantId = user.GetTenantId();
+        }
+    }
+}

ConfigFrontEnd/Common/BaseService.cs

@@ -0,0 +1,154 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.Features.Account.Login.Cqrs;
+using Indotalent.Infrastructure.Authentication.Identity;
+using Indotalent.Shared.Models;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+using RestSharp;
+using System.Net;
+
+namespace Indotalent.ConfigFrontEnd.Common;
+
+public abstract class BaseService
+{
+    protected readonly IHttpClientFactory ClientFactory;
+    protected readonly NavigationManager Nav;
+    protected readonly ISnackbar Snackbar;
+    protected readonly ICurrentUserService CurrentUserService;
+    protected readonly TokenProvider TokenProvider;
+
+    public BaseService(
+        IHttpClientFactory clientFactory,
+        NavigationManager nav,
+        ISnackbar snackbar,
+        ICurrentUserService currentUserService,
+        TokenProvider tokenProvider)
+    {
+        ClientFactory = clientFactory;
+        Nav = nav;
+        Snackbar = snackbar;
+        CurrentUserService = currentUserService;
+        TokenProvider = tokenProvider;
+    }
+
+    protected HttpClient CreateClient()
+    {
+        var client = ClientFactory.CreateClient();
+        if (client.BaseAddress == null)
+        {
+            client.BaseAddress = new Uri(Nav.BaseUri);
+        }
+        return client;
+    }
+
+    protected async Task<ApiResponse<T>?> ExecuteWithResponseAsync<T>(RestClient client, RestRequest request)
+    {
+        try
+        {
+            if (!string.IsNullOrEmpty(TokenProvider.Token))
+                request.AddOrUpdateHeader("Authorization", $"Bearer {TokenProvider.Token}");
+
+            if (!string.IsNullOrEmpty(TokenProvider.RefreshToken))
+                request.AddOrUpdateHeader("X-Refresh-Token", TokenProvider.RefreshToken);
+
+            if (!string.IsNullOrEmpty(CurrentUserService.UserId))
+            {
+                request.AddOrUpdateHeader("X-UserId", CurrentUserService.UserId);
+                request.AddOrUpdateHeader("X-UserName", CurrentUserService.UserName ?? string.Empty);
+                request.AddOrUpdateHeader("X-Email", CurrentUserService.Email ?? string.Empty);
+                request.AddOrUpdateHeader("X-FullName", CurrentUserService.FullName ?? string.Empty);
+                request.AddOrUpdateHeader("X-TenantId", CurrentUserService.TenantId ?? string.Empty);
+            }
+
+            var response = await client.ExecuteAsync<ApiResponse<T>>(request);
+
+
+            if (response.StatusCode == HttpStatusCode.Unauthorized)
+            {
+                var httpClient = CreateClient();
+
+                var refreshRequestMessage = new HttpRequestMessage(HttpMethod.Post, "/api/account/refresh-token");
+
+                if (!string.IsNullOrEmpty(TokenProvider.RefreshToken))
+                {
+                    refreshRequestMessage.Headers.Add("X-Refresh-Token", TokenProvider.RefreshToken);
+                }
+
+                var refreshResponse = await httpClient.SendAsync(refreshRequestMessage);
+
+                if (refreshResponse.IsSuccessStatusCode)
+                {
+                    var result = await refreshResponse.Content.ReadFromJsonAsync<LoginResponse>();
+                    if (result != null && !string.IsNullOrEmpty(result.Token))
+                    {
+                        TokenProvider.Token = result.Token;
+
+                        request.AddOrUpdateHeader("Authorization", $"Bearer {TokenProvider.Token}");
+                        response = await client.ExecuteAsync<ApiResponse<T>>(request);
+                    }
+                }
+                else
+                {
+                    Nav.NavigateTo("/account/login");
+                    return default;
+                }
+            }
+
+            if (response.Data != null)
+            {
+                if (!response.Data.IsSuccess)
+                {
+                    HandleApiError(response.Data);
+                }
+                return response.Data;
+            }
+
+            var fallbackMessage = GetFriendlyInfrastructureErrorMessage(response);
+            Snackbar.Add(fallbackMessage, Severity.Error);
+
+            return new ApiResponse<T>
+            {
+                IsSuccess = false,
+                StatusCode = (int)response.StatusCode,
+                Message = fallbackMessage
+            };
+        }
+        catch (Exception ex)
+        {
+            var systemError = $"Client System Error: {ex.Message}";
+            Snackbar.Add(systemError, Severity.Error);
+            return new ApiResponse<T> { IsSuccess = false, Message = systemError };
+        }
+    }
+
+    private void HandleApiError<T>(ApiResponse<T> response)
+    {
+        var mainMessage = response.Message ?? "Operation failed";
+        if (response.Errors != null && response.Errors.Any())
+        {
+            var combinedErrors = string.Join(Environment.NewLine, response.Errors.Select(e => $"• {e}"));
+            Snackbar.Add(combinedErrors, Severity.Error, config =>
+            {
+                config.ShowCloseIcon = true;
+                config.VisibleStateDuration = 3000;
+            });
+        }
+        else
+        {
+            Snackbar.Add(mainMessage, Severity.Error);
+        }
+    }
+
+    private string GetFriendlyInfrastructureErrorMessage(RestResponse response)
+    {
+        return response.StatusCode switch
+        {
+            HttpStatusCode.ServiceUnavailable => "Server is currently under maintenance.",
+            HttpStatusCode.GatewayTimeout => "Server took too long to respond.",
+            HttpStatusCode.Unauthorized => "Session expired. Please login again.",
+            HttpStatusCode.Forbidden => "You do not have permission to access this resource.",
+            HttpStatusCode.InternalServerError => "A critical error occurred on the server.",
+            _ => "Unable to reach the server. Please check your connection."
+        };
+    }
+}

ConfigFrontEnd/DI.cs

@@ -0,0 +1,37 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.ConfigFrontEnd.Models;
+using Indotalent.ConfigFrontEnd.Service;
+using MudBlazor;
+using MudBlazor.Services;
+
+namespace Indotalent.ConfigFrontEnd;
+
+public static class DI
+{
+    public static IServiceCollection AddConfigFrontEndDI(this IServiceCollection services)
+    {
+        services.AddMudServices(config =>
+        {
+            config.SnackbarConfiguration.PositionClass = Defaults.Classes.Position.TopRight;
+            config.SnackbarConfiguration.PreventDuplicates = true;
+            config.SnackbarConfiguration.NewestOnTop = true;
+            config.SnackbarConfiguration.ShowCloseIcon = true;
+            config.SnackbarConfiguration.VisibleStateDuration = 5000;
+            config.SnackbarConfiguration.HideTransitionDuration = 300;
+            config.SnackbarConfiguration.ShowTransitionDuration = 300;
+            config.SnackbarConfiguration.SnackbarVariant = Variant.Filled;
+        });
+
+
+        services.AddHttpClient("AppClient", client =>
+        {
+            client.Timeout = TimeSpan.FromMinutes(30);
+            client.DefaultRequestHeaders.Add("Accept", "application/json");
+        });
+
+        services.AddScoped<CurrentUserState>();
+        services.AddScoped<ICurrentUserService, CurrentUserService>();
+
+        return services;
+    }
+}

ConfigFrontEnd/Extensions/IdentityClaimPrincipalExtension.cs

@@ -0,0 +1,30 @@
+using System.Security.Claims;
+
+namespace Indotalent.ConfigFrontEnd.Extensions;
+
+public static class IdentityClaimPrincipalExtension
+{
+    public static string? GetUserId(this ClaimsPrincipal? user)
+    {
+        return user?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
+    }
+
+    public static string? GetEmail(this ClaimsPrincipal? user)
+    {
+        return user?.FindFirst(ClaimTypes.Email)?.Value;
+    }
+
+    public static string? GetUserName(this ClaimsPrincipal? user)
+    {
+        return user?.FindFirst(ClaimTypes.Name)?.Value;
+    }
+
+    public static string? GetFullName(this ClaimsPrincipal? user)
+    {
+        return user?.FindFirst(ClaimTypes.GivenName)?.Value;
+    }
+    public static string? GetTenantId(this ClaimsPrincipal? user)
+    {
+        return user?.FindFirst(ClaimTypes.GroupSid)?.Value;
+    }
+}

ConfigFrontEnd/Filter/CurrentUserFilter.cs

@@ -0,0 +1,47 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.ConfigFrontEnd.Extensions;
+
+namespace Indotalent.ConfigFrontEnd.Filter;
+
+public class CurrentUserFilter : IEndpointFilter
+{
+    private readonly ICurrentUserService _currentUserService;
+
+    public CurrentUserFilter(ICurrentUserService currentUserService)
+    {
+        _currentUserService = currentUserService;
+    }
+
+    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
+    {
+        var httpContext = context.HttpContext;
+        var user = httpContext.User;
+
+        string? userId = user.GetUserId();
+        string? email = user.GetEmail();
+        string? userName = user.GetUserName();
+        string? fullName = user.GetFullName();
+        string? tenantId = user.GetTenantId();
+
+
+        if (string.IsNullOrEmpty(userId))
+        {
+            userId = httpContext.Request.Headers["X-UserId"].ToString();
+            userName = httpContext.Request.Headers["X-UserName"].ToString();
+            email = httpContext.Request.Headers["X-Email"].ToString();
+            fullName = httpContext.Request.Headers["X-FullName"].ToString();
+            tenantId = httpContext.Request.Headers["X-TenantId"].ToString();
+        }
+
+        if (!string.IsNullOrEmpty(userId))
+        {
+            _currentUserService.UserId = userId;
+            _currentUserService.UserName = userName;
+            _currentUserService.Email = email;
+            _currentUserService.FullName = fullName;
+            _currentUserService.TenantId = tenantId;
+        }
+
+        return await next(context);
+    }
+}

ConfigFrontEnd/Models/CurrentUserState.cs

@@ -0,0 +1,10 @@
+namespace Indotalent.ConfigFrontEnd.Models;
+
+public class CurrentUserState
+{
+    public string? TenantId { get; set; }
+    public string? UserId { get; set; }
+    public string? UserName { get; set; }
+    public string? Email { get; set; }
+    public string? FullName { get; set; }
+}

ConfigFrontEnd/Service/CurrentUserService.cs

@@ -0,0 +1,54 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.ConfigFrontEnd.Models;
+
+namespace Indotalent.ConfigFrontEnd.Service;
+
+public class CurrentUserService : ICurrentUserService
+{
+    private readonly CurrentUserState _state;
+
+    public CurrentUserService(CurrentUserState state)
+    {
+        _state = state;
+    }
+
+    public string? TenantId
+    {
+        get => _state.TenantId;
+        set => _state.TenantId = value;
+    }
+
+    public string? UserId
+    {
+        get => _state.UserId;
+        set => _state.UserId = value;
+    }
+
+    public string? UserName
+    {
+        get => _state.UserName;
+        set => _state.UserName = value;
+    }
+
+    public string? Email
+    {
+        get => _state.Email;
+        set => _state.Email = value;
+    }
+
+    public string? FullName
+    {
+        get => _state.FullName;
+        set => _state.FullName = value;
+    }
+
+    public Task<bool> IsInRoleAsync(string role)
+    {
+        return Task.FromResult(false);
+    }
+
+    public Task<bool> HasPermissionAsync(string permission)
+    {
+        return Task.FromResult(false);
+    }
+}

ConfigFrontEnd/Service/JwtService.cs

@@ -0,0 +1,62 @@
+using Indotalent.Data.Entities;
+using Indotalent.Infrastructure.Authentication.Identity;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+namespace Indotalent.ConfigFrontEnd.Service;
+
+public static class JwtService
+{
+    public static string GenerateNewJwt(ApplicationUser user, JwtSettingsModel _jwtSettings)
+    {
+        var authClaims = new List<Claim>
+        {
+            new(ClaimTypes.Name, user.UserName ?? ""),
+            new(ClaimTypes.Email, user.Email ?? ""),
+            new(ClaimTypes.NameIdentifier, user.Id),
+            new(ClaimTypes.GivenName, user.FullName ?? ""),
+            new(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+        };
+
+        var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.Key));
+
+        var token = new JwtSecurityToken(
+            issuer: _jwtSettings.Issuer,
+            audience: _jwtSettings.Audience,
+            expires: DateTime.Now.AddMinutes(_jwtSettings.DurationInMinutes),
+            claims: authClaims,
+            signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
+        );
+
+        return new JwtSecurityTokenHandler().WriteToken(token);
+    }
+
+    public static string GenerateNewJwtWithClaims(ApplicationUser user, List<Claim> extraClaims, JwtSettingsModel settings)
+    {
+        var authClaims = new List<Claim>
+        {
+            new(ClaimTypes.Name, user.UserName ?? ""),
+            new(ClaimTypes.Email, user.Email ?? ""),
+            new(ClaimTypes.NameIdentifier, user.Id),
+            new(ClaimTypes.GivenName, user.FullName ?? ""),
+            new(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+        };
+
+        authClaims.AddRange(extraClaims);
+
+        var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(settings.Key));
+
+        var token = new JwtSecurityToken(
+            issuer: settings.Issuer,
+            audience: settings.Audience,
+            expires: DateTime.Now.AddMinutes(settings.DurationInMinutes),
+            claims: authClaims,
+            signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
+        );
+
+        return new JwtSecurityTokenHandler().WriteToken(token);
+    }
+
+}

Data/Abstracts/BaseEntity.cs

@@ -0,0 +1,16 @@
+using Indotalent.Data.Interfaces;
+using Indotalent.Shared.Utils;
+using System.ComponentModel.DataAnnotations;
+
+namespace Indotalent.Data.Abstracts;
+
+public abstract class BaseEntity : IHasAudit, IHasIsDeleted
+{
+    [Key]
+    public string Id { get; set; } = SequentialGuidGenerator.NewSequentialId();
+    public DateTimeOffset? CreatedAt { get; set; }
+    public string? CreatedBy { get; set; }
+    public DateTimeOffset? UpdatedAt { get; set; }
+    public string? UpdatedBy { get; set; }
+    public bool IsDeleted { get; set; } = false;
+}

Data/Entities/ApplicationUser.cs

@@ -0,0 +1,41 @@
+using Indotalent.Data.Interfaces;
+using Microsoft.AspNetCore.Identity;
+
+namespace Indotalent.Data.Entities;
+
+public class ApplicationUser : IdentityUser, IHasIsDeleted
+{
+    public string? FullName { get; set; }
+    public string? FirstName { get; set; }
+    public string? LastName { get; set; }
+    public string? ShortBio { get; set; }
+    public string? JobTitle { get; set; }
+    public DateTime DateOfBirth { get; set; }
+    public string? StreetAddress { get; set; }
+    public string? City { get; set; }
+    public string? StateProvince { get; set; }
+    public string? ZipCode { get; set; }
+    public string? Country { get; set; }
+    public string SocialMediaLinkedIn { get; set; } = string.Empty;
+    public string SocialMediaX { get; set; } = string.Empty;
+    public string SocialMediaFacebook { get; set; } = string.Empty;
+    public string SocialMediaInstagram { get; set; } = string.Empty;
+    public string SocialMediaTikTok { get; set; } = string.Empty;
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? SsoIdFirebase { get; set; }
+    public string? SsoIdKeycloak { get; set; }
+    public string? SsoIdAzure { get; set; }
+    public string? SsoIdAws { get; set; }
+    public string? SsoIdOther1 { get; set; }
+    public string? SsoIdOther2 { get; set; }
+    public string? SsoIdOther3 { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.Now;
+    public DateTime? LastLoginAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public bool IsActive { get; set; } = true;
+    public bool IsDeleted { get; set; } = false;
+    public string? AvatarFile { get; set; }
+    public string? RefreshToken { get; set; }
+}

Data/Entities/Appraisal.cs

@@ -0,0 +1,20 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Appraisal : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string LastRating { get; set; } = string.Empty;
+    public decimal CurrentSalary { get; set; }
+    public decimal IncrementPercentage { get; set; }
+    public decimal NewSalary { get; set; }
+    public string AppraisalType { get; set; } = string.Empty;
+    public DateTime EffectiveDate { get; set; }
+    public string AppraisalNote { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/AutoNumberSequence.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+using Indotalent.Infrastructure.AutoNumberGenerator;
+
+namespace Indotalent.Data.Entities;
+
+public class AutoNumberSequence : BaseEntity, IAutoNumberGenerator, IMultiTenant
+{
+    public string? EntityName { get; set; }
+    public int? Year { get; set; }
+    public int? Month { get; set; }
+    public long? CurrentSequence { get; set; }
+    public string? PrefixTemplate { get; set; }
+    public string? SuffixTemplate { get; set; }
+    public int? PaddingLength { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/Branch.cs

@@ -0,0 +1,22 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Branch : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Code { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string StreetAddress { get; set; } = string.Empty;
+    public string City { get; set; } = string.Empty;
+    public string StateProvince { get; set; } = string.Empty;
+    public string ZipCode { get; set; } = string.Empty;
+    public string Phone { get; set; } = string.Empty;
+    public string Email { get; set; } = string.Empty;
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/Company.cs

@@ -0,0 +1,32 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Company : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
+    public bool IsDefault { get; set; } = false;
+    public string CurrencyId { get; set; } = string.Empty; //lookup to Currency
+    public Currency? Currency { get; set; }
+    public string TaxIdentification { get; set; } = string.Empty;
+    public string BusinessLicense { get; set; } = string.Empty;
+    public string CompanyLogo { get; set; } = string.Empty;
+    public string StreetAddress { get; set; } = string.Empty;
+    public string City { get; set; } = string.Empty;
+    public string StateProvince { get; set; } = string.Empty;
+    public string ZipCode { get; set; } = string.Empty;
+    public string Phone { get; set; } = string.Empty;
+    public string Email { get; set; } = string.Empty;
+    public string SocialMediaLinkedIn { get; set; } = string.Empty;
+    public string SocialMediaX { get; set; } = string.Empty;
+    public string SocialMediaFacebook { get; set; } = string.Empty;
+    public string SocialMediaInstagram { get; set; } = string.Empty;
+    public string SocialMediaTikTok { get; set; } = string.Empty;
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/Currency.cs

@@ -0,0 +1,15 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Currency : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Code { get; set; }
+    public string? Symbol { get; set; }
+    public string? CountryOwner { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/Deduction.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Deduction : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Code { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Category { get; set; }
+    public bool PreTax { get; set; } = false;
+    public string? CalculationMethod { get; set; }
+    public string? Status { get; set; } = "Active";
+    public string? TenantId { get; set; }
+}

Data/Entities/Department.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Department : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? CostCenter { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string HeadOfDeptartment { get; set; } = string.Empty;
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/Designation.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Designation : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Code { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Level { get; set; }
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/Employee.cs

@@ -0,0 +1,57 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Employee : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string Code { get; set; } = string.Empty;
+    public string FirstName { get; set; } = string.Empty;
+    public string MiddleName { get; set; } = string.Empty;
+    public string LastName { get; set; } = string.Empty;
+    public string JobDescription { get; set; } = string.Empty;
+    public string? GradeId { get; set; }
+    public Grade? Grade { get; set; }
+    public decimal BasicSalary { get; set; }
+    public string SalaryBankName { get; set; } = string.Empty;
+    public string SalaryBankAccountName { get; set; } = string.Empty;
+    public string SalaryBankAccountNumber { get; set; } = string.Empty;
+    public string PlaceOfBirth { get; set; } = string.Empty;
+    public DateTime? DateOfBirth { get; set; }
+    public string Gender { get; set; } = string.Empty;
+    public string MaritalStatus { get; set; } = string.Empty;
+    public string Religion { get; set; } = string.Empty;
+    public string BloodType { get; set; } = string.Empty;
+    public string IdentityNumber { get; set; } = string.Empty;
+    public string TaxNumber { get; set; } = string.Empty;
+    public string LastEducation { get; set; } = string.Empty;
+    public DateTime? JoinedDate { get; set; }
+    public DateTime? ResignedDate { get; set; }
+    public string EmployeeStatus { get; set; } = string.Empty;
+    public string EmploymentType { get; set; } = string.Empty;
+    public string StreetAddress { get; set; } = string.Empty;
+    public string City { get; set; } = string.Empty;
+    public string StateProvince { get; set; } = string.Empty;
+    public string ZipCode { get; set; } = string.Empty;
+    public string Phone { get; set; } = string.Empty;
+    public string Email { get; set; } = string.Empty;
+    public string BranchId { get; set; } = string.Empty;
+    public Branch? Branch { get; set; }
+    public string DepartmentId { get; set; } = string.Empty;
+    public Department? Department { get; set; }
+    public string DesignationId { get; set; } = string.Empty;
+    public Designation? Designation { get; set; }
+    public string SocialMediaLinkedIn { get; set; } = string.Empty;
+    public string SocialMediaX { get; set; } = string.Empty;
+    public string SocialMediaFacebook { get; set; } = string.Empty;
+    public string SocialMediaInstagram { get; set; } = string.Empty;
+    public string SocialMediaTikTok { get; set; } = string.Empty;
+    public string OtherInformation1 { get; set; } = string.Empty;
+    public string OtherInformation2 { get; set; } = string.Empty;
+    public string OtherInformation3 { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+
+    public virtual ICollection<EmployeeIncome> EmployeeIncome { get; set; } = new List<EmployeeIncome>();
+    public virtual ICollection<EmployeeDeduction> EmployeeDeduction { get; set; } = new List<EmployeeDeduction>();
+}

Data/Entities/EmployeeDeduction.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class EmployeeDeduction : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? EmployeeId { get; set; }
+    public Employee? Employee { get; set; }
+    public string? DeductionId { get; set; }
+    public Deduction? Deduction { get; set; }
+    public decimal Amount { get; set; }
+    public string? Description { get; set; }
+    public bool IsActive { get; set; } = true;
+    public string? TenantId { get; set; }
+}

Data/Entities/EmployeeIncome.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class EmployeeIncome : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? EmployeeId { get; set; }
+    public Employee? Employee { get; set; }
+    public string? IncomeId { get; set; }
+    public Income? Income { get; set; }
+    public decimal Amount { get; set; }
+    public string? Description { get; set; }
+    public bool IsActive { get; set; } = true;
+    public string? TenantId { get; set; }
+}

Data/Entities/Evaluation.cs

@@ -0,0 +1,20 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Evaluation : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string Period { get; set; } = string.Empty;
+    public string FinalScore { get; set; } = string.Empty;
+    public string Rating { get; set; } = string.Empty;
+    public string EvaluatorId { get; set; } = string.Empty;
+    public Employee? Evaluator { get; set; }
+    public DateTime EvaluationDate { get; set; }
+    public string EvaluationNote { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/Grade.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Grade : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Code { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public decimal SalaryFrom { get; set; }
+    public decimal SalaryTo { get; set; }
+    public bool IsOverTimeEligible { get; set; } = true;
+    public string? Status { get; set; } = "Active";
+    public string? TenantId { get; set; }
+}

Data/Entities/Income.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Income : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Code { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Type { get; set; }
+    public bool IsTaxable { get; set; } = true;
+    public string? CalculationBase { get; set; }
+    public string? Status { get; set; } = "Active";
+    public string? TenantId { get; set; }
+}

Data/Entities/LeaveBalance.cs

@@ -0,0 +1,23 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class LeaveBalance : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string LeaveCategoryId { get; set; } = string.Empty;
+    public LeaveCategory? LeaveCategory { get; set; }
+    public int Entitlement { get; set; }
+    public int Used { get; set; }
+    public int Pending { get; set; }
+    public int Remaining { get; set; }
+    public int Year { get; set; }
+    public DateTime ValidFrom { get; set; }
+    public DateTime ValidTo { get; set; }
+    public int CarryForward { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/LeaveCategory.cs

@@ -0,0 +1,20 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+
+public class LeaveCategory : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string Code { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public int Quota { get; set; }
+    public bool IsPaidLeave { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty;
+    public bool AllowCarryForward { get; set; }
+    public int MaxCarryForward { get; set; }
+    public int MinServiceMonths { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/LeaveRequest.cs

@@ -0,0 +1,23 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class LeaveRequest : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string LeaveCategoryId { get; set; } = string.Empty;
+    public LeaveCategory? LeaveCategory { get; set; }
+    public DateTime StartDate { get; set; }
+    public DateTime EndDate { get; set; }
+    public double Days { get; set; }
+    public string Reason { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty; // Pending, Approved, Rejected, Cancelled
+    public string? AttachmentPath { get; set; }
+    public string? ApproverId { get; set; }
+    public DateTime? ActionDate { get; set; }
+    public string? RejectReason { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/PayrollComponent.cs

@@ -0,0 +1,15 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class PayrollComponent : BaseEntity, IMultiTenant
+{
+    public string? PayrollDetailId { get; set; }
+    public PayrollDetail? PayrollDetail { get; set; }
+    public string? ComponentName { get; set; } 
+    public string? ComponentType { get; set; } 
+    public decimal Amount { get; set; }
+    public string? Description { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/PayrollDetail.cs

@@ -0,0 +1,20 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class PayrollDetail : BaseEntity, IMultiTenant
+{
+    public string? PayrollProcessId { get; set; }
+    public PayrollProcess? PayrollProcess { get; set; }
+    public string? EmployeeId { get; set; }
+    public Employee? Employee { get; set; }
+    public string? EmployeeCode { get; set; }
+    public string? EmployeeName { get; set; }
+    public decimal BasicSalary { get; set; }
+    public decimal TotalIncome { get; set; }
+    public decimal TotalDeduction { get; set; }
+    public decimal TakeHomePay { get; set; }
+    public virtual ICollection<PayrollComponent> Components { get; set; } = new List<PayrollComponent>();
+    public string? TenantId { get; set; }
+}

Data/Entities/PayrollProcess.cs

@@ -0,0 +1,23 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class PayrollProcess : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? PeriodName { get; set; } 
+    public DateTime FromDate { get; set; }
+    public DateTime ToDate { get; set; }
+    public int TotalEmployees { get; set; }
+    public decimal TotalBasicSalary { get; set; }
+    public decimal TotalIncome { get; set; }
+    public decimal TotalDeduction { get; set; }
+    public decimal TotalGross { get; set; } 
+    public decimal TotalTakeHomePay { get; set; } 
+    public string? Status { get; set; } 
+    public string? ProcessedBy { get; set; }
+    public DateTime ProcessedAt { get; set; }
+    public string? Description { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/Promotion.cs

@@ -0,0 +1,17 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Promotion : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string FromGrade { get; set; } = string.Empty;
+    public string ToGrade { get; set; } = string.Empty;
+    public DateTime? EffectiveDate { get; set; }
+    public string PromotionNote { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Entities/SerilogLogs.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Indotalent.Data.Entities;
+
+public class SerilogLogs
+{
+    [Key]
+    public int Id { get; set; }
+    public string? Message { get; set; }
+    public string? MessageTemplate { get; set; }
+    public string? Level { get; set; }
+    public DateTimeOffset TimeStamp { get; set; }
+    public string? Exception { get; set; }
+    public string? Properties { get; set; }
+    public string? LogEvent { get; set; }
+}

Data/Entities/Tax.cs

@@ -0,0 +1,15 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Tax : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Code { get; set; }
+    public decimal PercentageValue { get; set; }
+    public string? Category { get; set; }
+    public string? TenantId { get; set; }
+}

Data/Entities/Tenant.cs

@@ -0,0 +1,21 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Tenant : BaseEntity
+{
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public string? Street { get; set; }
+    public string? City { get; set; }
+    public string? State { get; set; }
+    public string? ZipCode { get; set; }
+    public string? Country { get; set; }
+    public string? PhoneNumber { get; set; }
+    public string? FaxNumber { get; set; }
+    public string? EmailAddress { get; set; }
+    public string? Website { get; set; }
+    public bool IsActive { get; set; } = true;
+    public ICollection<TenantUser> TenantUserList { get; set; } = new List<TenantUser>();
+}

Data/Entities/TenantUser.cs

@@ -0,0 +1,12 @@
+using Indotalent.Data.Abstracts;
+
+namespace Indotalent.Data.Entities;
+
+public class TenantUser : BaseEntity
+{
+    public string? TenantId { get; set; }
+    public Tenant? Tenant { get; set; }
+    public string? UserId { get; set; }
+    public string? Summary { get; set; }
+    public bool IsActive { get; set; } = true;
+}

Data/Entities/Transfer.cs

@@ -0,0 +1,27 @@
+using Indotalent.Data.Abstracts;
+using Indotalent.Data.Interfaces;
+
+namespace Indotalent.Data.Entities;
+
+public class Transfer : BaseEntity, IHasAutoNumber, IMultiTenant
+{
+    public string? AutoNumber { get; set; }
+    public string EmployeeId { get; set; } = string.Empty;
+    public Employee? Employee { get; set; }
+    public string FromBranchId { get; set; } = string.Empty;
+    public Branch? FromBranch { get; set; }
+    public string FromDepartmentId { get; set; } = string.Empty;
+    public Department? FromDepartment { get; set; }
+    public string FromDesignationId { get; set; } = string.Empty;
+    public Designation? FromDesignation { get; set; }
+    public string ToBranchId { get; set; } = string.Empty;
+    public Branch? ToBranch { get; set; }
+    public string ToDepartmentId { get; set; } = string.Empty;
+    public Department? ToDepartment { get; set; }
+    public string ToDesignationId { get; set; } = string.Empty;
+    public Designation? ToDesignation { get; set; }
+    public DateTime? TransferDate { get; set; }
+    public string TransferNote { get; set; } = string.Empty;
+    public string Status { get; set; } = string.Empty;
+    public string? TenantId { get; set; }
+}

Data/Interfaces/IHasAudit.cs

@@ -0,0 +1,9 @@
+namespace Indotalent.Data.Interfaces;
+
+public interface IHasAudit
+{
+    DateTimeOffset? CreatedAt { get; set; }
+    string? CreatedBy { get; set; }
+    DateTimeOffset? UpdatedAt { get; set; }
+    string? UpdatedBy { get; set; }
+}

Data/Interfaces/IHasAutoNumber.cs

@@ -0,0 +1,6 @@
+namespace Indotalent.Data.Interfaces;
+
+public interface IHasAutoNumber
+{
+    string? AutoNumber { get; set; }
+}

Data/Interfaces/IHasIsDeleted.cs

@@ -0,0 +1,6 @@
+namespace Indotalent.Data.Interfaces;
+
+public interface IHasIsDeleted
+{
+    bool IsDeleted { get; set; }
+}

Data/Interfaces/IMultiTenant.cs

@@ -0,0 +1,7 @@
+namespace Indotalent.Data.Interfaces;
+
+public interface IMultiTenant
+{
+    string? TenantId { get; set; }
+}
+    

Dockerfile

@@ -0,0 +1,15 @@
+FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+WORKDIR /src
+COPY *.csproj .
+RUN dotnet restore
+COPY . .
+RUN dotnet publish -c Release -o /app --no-restore
+
+FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS runtime
+WORKDIR /app
+RUN apt-get update && apt-get install -y --no-install-recommends libicu-dev && rm -rf /var/lib/apt/lists/*
+COPY --from=build /app .
+ENV ASPNETCORE_ENVIRONMENT=Production
+ENV ASPNETCORE_URLS=http://+:8080
+EXPOSE 8080
+ENTRYPOINT ["dotnet", "Indotalent.dll"]

Features/Account/AccessDenied/AccessDeniedPage.razor

@@ -0,0 +1,63 @@
+@page "/account/access-denied"
+@using Indotalent.Features.Root
+@using MudBlazor
+@layout MainLayout
+
+<PageTitle>Access Denied - Insufficient Permissions</PageTitle>
+
+<MudContainer MaxWidth="MaxWidth.Medium" Class="d-flex align-center justify-center" Style="height: calc(100vh - 64px);">
+
+    <div class="text-center">
+
+        <MudIcon Icon="@Icons.Material.Filled.GppBad"
+                 Size="Size.Large"
+                 Color="Color.Error"
+                 Class="mb-6"
+                 Style="font-size: 120px;" />
+
+        <MudText Typo="Typo.h3" Class="mb-4" Style="font-weight: 800; color: #1a1a1a;">Access Denied</MudText>
+
+        <MudText Typo="Typo.body1" Class="mb-6" Style="color: #64748b;">
+            Sorry, you do not have the required permissions to access this module.<br />
+            This area is restricted to authorized administrative personnel only.
+        </MudText>
+
+        <MudPaper Elevation="1" Class="pa-4 mb-8 d-inline-block" Style="border-radius: 0px; border: 1px solid #DCEBFA;">
+            <MudText Typo="Typo.subtitle2" Class="mb-1">
+                <strong>Error Code:</strong> <code>AGS_AUTH_INSUFFICIENT_PERMISSIONS</code>
+            </MudText>
+            <MudText Typo="Typo.caption" Style="color: #94a3b8; font-family: 'Consolas', monospace;">
+                Verification failed for the current security context.
+            </MudText>
+        </MudPaper>
+
+        <div class="d-flex align-center justify-center gap-4">
+            <MudButton Variant="Variant.Filled"
+                       Color="Color.Primary"
+                       Size="Size.Large"
+                       OnClick="GoHome"
+                       StartIcon="@Icons.Material.Filled.Home"
+                       Style="border-radius: 4px; font-weight: 700;">
+                Back to Home
+            </MudButton>
+
+            <MudButton Variant="Variant.Outlined"
+                       Color="Color.Default"
+                       Size="Size.Large"
+                       OnClick="Logout"
+                       StartIcon="@Icons.Material.Filled.Logout"
+                       Style="border: 1px solid #e0e0e0; border-radius: 4px; font-weight: 700; border: 2px solid #e2e8f0;">
+                Logout & Switch Account
+            </MudButton>
+        </div>
+
+    </div>
+
+</MudContainer>
+
+@code {
+    [Inject] private NavigationManager Nav { get; set; } = default!;
+
+    private void GoHome() => Nav.NavigateTo("/");
+    private void Logout() => Nav.NavigateTo("/account/logout");
+}

Features/Account/AccessDenied/RedirectToAccessDenied.razor

@@ -0,0 +1,19 @@
+@inject NavigationManager Navigation
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.AspNetCore.Components.Authorization
+@attribute [AllowAnonymous]
+
+<AuthorizeView>
+    <NotAuthorized>
+        @{
+            var returnUrl = Navigation.ToBaseRelativePath(Navigation.Uri);
+            Navigation.NavigateTo($"/account/login?returnUrl={Uri.EscapeDataString(returnUrl)}", forceLoad: false);
+        }
+    </NotAuthorized>
+    <Authorized>
+        @{
+            Navigation.NavigateTo("/account/access-denied");
+        }
+    </Authorized>
+</AuthorizeView>
+

Features/Account/AccountEndPoint.cs

@@ -0,0 +1,285 @@
+using Indotalent.ConfigFrontEnd.Service;
+using Indotalent.Data.Entities;
+using Indotalent.Features.Account.ForgotPassword.Cqrs;
+using Indotalent.Features.Account.Login.Cqrs;
+using Indotalent.Features.Account.Register.Cqrs;
+using Indotalent.Features.Account.ResetPassword.Cqrs;
+using Indotalent.Features.Account.TenantSelection.Cqrs;
+using Indotalent.Infrastructure.Authentication.Identity;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using System.Security.Claims;
+
+namespace Indotalent.Features.Account;
+
+public static class AccountEndPoint
+{
+    public static IEndpointConventionBuilder MapAccountEndpoints(this IEndpointRouteBuilder endpoints)
+    {
+        var group = endpoints.MapGroup("/account").WithTags("Account");
+
+        group.MapPost("/signin-sso", async ([FromQuery] string email, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, IOptions<JwtSettingsModel> jwtOptions, HttpContext context) =>
+        {
+            if (string.IsNullOrWhiteSpace(email)) return Results.Json(new { status = 401, title = "Email is required" }, statusCode: 401);
+
+            var user = await userManager.FindByEmailAsync(email);
+
+            if (user == null || !user.IsActive)
+            {
+                return Results.Json(new { status = 401, title = "Account not found or inactive" }, statusCode: 401);
+            }
+
+            var jwtSettings = jwtOptions.Value;
+            var token = JwtService.GenerateNewJwt(user, jwtSettings);
+            var refreshToken = Guid.NewGuid().ToString().Replace("-", "");
+
+            user.RefreshToken = refreshToken;
+            user.LastLoginAt = DateTime.Now;
+            await userManager.UpdateAsync(user);
+
+            await signInManager.SignInAsync(user, isPersistent: true);
+
+            context.Response.Cookies.Append("X-Auth-Token", token, new CookieOptions
+            {
+                HttpOnly = true,
+                Secure = true,
+                SameSite = SameSiteMode.Strict,
+                Expires = DateTimeOffset.UtcNow.AddDays(1)
+            });
+
+            context.Response.Cookies.Append("X-Refresh-Token", refreshToken, new CookieOptions
+            {
+                HttpOnly = true,
+                Secure = true,
+                SameSite = SameSiteMode.Strict,
+                Expires = DateTimeOffset.UtcNow.AddDays(7)
+            });
+
+            return Results.Ok(new { status = 200, title = "SSO Login successful" });
+        });
+
+        group.MapGet("/active-user-exists", async ([FromQuery] string email, UserManager<ApplicationUser> userManager) =>
+        {
+            if (string.IsNullOrWhiteSpace(email))
+            {
+                return Results.Ok(new { exists = false, isActive = false });
+            }
+
+            var user = await userManager.FindByEmailAsync(email);
+
+            if (user == null)
+            {
+                return Results.Ok(new { exists = false, isActive = false });
+            }
+
+            return Results.Ok(new { exists = true, isActive = user.IsActive });
+        });
+
+        group.MapPost("/signin", async ([FromBody] LoginRequest request, IMediator mediator, HttpContext context, UserManager<ApplicationUser> userManager) =>
+        {
+            var command = new LoginCommand(request);
+            var response = await mediator.Send(command);
+
+            if (response.Succeeded)
+            {
+                var user = await userManager.FindByEmailAsync(request.Email);
+
+                if (user != null)
+                {
+                    context.Response.Cookies.Append("X-Auth-Token", response.Token!, new CookieOptions
+                    {
+                        HttpOnly = true,
+                        Secure = true,
+                        SameSite = SameSiteMode.Strict,
+                        Expires = DateTimeOffset.UtcNow.AddDays(1)
+                    });
+
+                    context.Response.Cookies.Append("X-Refresh-Token", user.RefreshToken!, new CookieOptions
+                    {
+                        HttpOnly = true,
+                        Secure = true,
+                        SameSite = SameSiteMode.Strict,
+                        Expires = DateTimeOffset.UtcNow.AddDays(7)
+                    });
+                }
+
+                return Results.Ok(new { status = 200, title = response.Message });
+            }
+            return Results.Json(new { status = 401, title = response.Message }, statusCode: 401);
+        });
+
+
+
+        group.MapPost("/refresh-token", async (HttpContext context) =>
+        {
+            var userManager = context.RequestServices.GetRequiredService<UserManager<ApplicationUser>>();
+            var jwtSettings = context.RequestServices.GetRequiredService<IOptions<JwtSettingsModel>>().Value;
+
+            var refreshToken = context.Request.Headers["X-Refresh-Token"].ToString();
+
+            if (string.IsNullOrEmpty(refreshToken)) return Results.Unauthorized();
+
+            var user = await userManager.Users.FirstOrDefaultAsync(u => u.RefreshToken == refreshToken);
+
+            if (user == null || !user.IsActive) return Results.Unauthorized();
+
+            var newToken = JwtService.GenerateNewJwt(user, jwtSettings);
+
+            context.Response.Cookies.Append("X-Auth-Token", newToken, new CookieOptions
+            {
+                HttpOnly = true,
+                Secure = true,
+                SameSite = SameSiteMode.Strict,
+                Expires = DateTimeOffset.UtcNow.AddDays(1)
+            });
+
+            return Results.Ok(new LoginResponse { Succeeded = true, Token = newToken });
+        });
+
+        group.MapPost("/signup", async ([FromBody] CreateUserRequest request, IMediator mediator) =>
+        {
+            try
+            {
+                var command = new CreateUserCommand(request);
+                var response = await mediator.Send(command);
+                return Results.Ok(response);
+            }
+            catch (Exception ex)
+            {
+                return Results.BadRequest(new { errors = new[] { ex.Message } });
+            }
+        });
+
+        group.MapPost("/signout", async (
+            SignInManager<ApplicationUser> signInManager,
+            UserManager<ApplicationUser> userManager,
+            HttpContext context) =>
+        {
+            var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
+
+            if (!string.IsNullOrEmpty(userId))
+            {
+                var user = await userManager.FindByIdAsync(userId);
+                if (user != null)
+                {
+                    user.RefreshToken = null;
+                    await userManager.UpdateAsync(user);
+                }
+            }
+
+            await signInManager.SignOutAsync();
+
+            context.Response.Cookies.Delete("X-Auth-Token");
+            context.Response.Cookies.Delete("X-Refresh-Token");
+
+            return Results.Ok(new { status = 200, title = "Successfully signed out" });
+
+        });
+
+        group.MapPost("/forgot-password", async ([FromBody] ForgotPasswordRequest request, IMediator mediator) =>
+        {
+            try
+            {
+                var command = new ForgotPasswordCommand(request);
+                var response = await mediator.Send(command);
+                return Results.Ok(response);
+            }
+            catch (Exception ex)
+            {
+                return Results.BadRequest(new { errors = new[] { ex.Message } });
+            }
+        });
+
+        group.MapPost("/logout", async (SignInManager<ApplicationUser> signInManager) =>
+        {
+            await signInManager.SignOutAsync();
+            return Results.Ok(new { title = "Success user logout" });
+        }).RequireAuthorization();
+
+        group.MapPost("/reset-password", async ([FromBody] ResetPasswordRequest request, IMediator mediator) =>
+        {
+            try
+            {
+                var command = new ResetPasswordCommand(request);
+                var response = await mediator.Send(command);
+                return Results.Ok(response);
+            }
+            catch (Exception ex)
+            {
+                return Results.BadRequest(new { errors = new[] { ex.Message } });
+            }
+        });
+
+        group.MapGet("/my-tenants", async (IMediator mediator, HttpContext context) =>
+        {
+            var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
+
+            var query = new GetTenantsQuery(userId);
+            var response = await mediator.Send(query);
+            return Results.Ok(response);
+        }).RequireAuthorization();
+
+        group.MapPost("/confirm-tenant", async (
+            [FromBody] ConfirmTenantRequest request,
+            IMediator mediator,
+            HttpContext context,
+            SignInManager<ApplicationUser> signInManager,
+            UserManager<ApplicationUser> userManager) =>
+        {
+            var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userId)) return Results.Unauthorized();
+
+            var command = new ConfirmTenantCommand(userId, request);
+            var response = await mediator.Send(command);
+
+            if (!response.Success)
+            {
+                return Results.Json(new { success = false, title = response.Message }, statusCode: 400);
+            }
+
+            var user = await userManager.FindByIdAsync(userId);
+            if (user == null) return Results.Unauthorized();
+
+            var principal = await signInManager.CreateUserPrincipalAsync(user);
+            var identity = (ClaimsIdentity?)principal.Identity;
+
+            if (identity != null)
+            {
+                identity.AddClaim(new Claim(ClaimTypes.GroupSid, request.TenantId));
+                var jwtClaims = new List<Claim>
+                {
+                    new Claim(ClaimTypes.NameIdentifier, user.Id ?? string.Empty),
+                    new Claim(ClaimTypes.Name, user.UserName ?? string.Empty),
+                    new Claim(ClaimTypes.Email, user.Email ?? string.Empty),
+                    new Claim(ClaimTypes.GivenName, user.FullName ?? string.Empty),
+                    new Claim(ClaimTypes.GroupSid, request.TenantId)
+                };
+
+                var jwtSettings = context.RequestServices.GetRequiredService<IOptions<JwtSettingsModel>>().Value;
+                var newToken = JwtService.GenerateNewJwtWithClaims(user, jwtClaims, jwtSettings);
+                var newRefreshToken = Guid.NewGuid().ToString().Replace("-", "");
+
+                user.RefreshToken = newRefreshToken;
+                await userManager.UpdateAsync(user);
+
+                context.Response.Cookies.Append("X-Auth-Token", newToken, new CookieOptions
+                {
+                    HttpOnly = true,
+                    Secure = true,
+                    SameSite = SameSiteMode.Strict,
+                    Expires = DateTimeOffset.UtcNow.AddDays(1)
+                });
+
+                return Results.Ok(new { success = true, token = newToken });
+            }
+
+            return Results.Json(new { success = false, title = "Failed to reconstruct security claims" }, statusCode: 400);
+        }).RequireAuthorization();
+
+        return group;
+    }
+}

Features/Account/AuthenticationLayout.razor

@@ -0,0 +1,366 @@
+@using Indotalent.Shared.Consts
+@inherits LayoutComponentBase
+@inject NavigationManager Navigation
+
+<MudThemeProvider Theme="_theme" />
+<MudDialogProvider />
+<MudSnackbarProvider />
+<MudPopoverProvider />
+
+<style>
+    .auth-split-container {
+        display: flex;
+        min-height: 100vh;
+    }
+
+    .auth-left-panel {
+        display: none;
+    }
+
+    @@media (min-width: 1024px) {
+        .auth-left-panel {
+            display: flex;
+            width: 50%;
+            align-items: center;
+            justify-content: center;
+            padding: 3rem;
+            position: relative;
+            overflow: hidden;
+            background: linear-gradient(135deg, #3228A0, #594AE2, #7B6FE8);
+        }
+
+        .auth-left-panel::before {
+            content: '';
+            position: absolute;
+            top: -80px;
+            right: -80px;
+            width: 300px;
+            height: 300px;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.04);
+        }
+
+        .auth-left-panel::after {
+            content: '';
+            position: absolute;
+            bottom: -60px;
+            left: -60px;
+            width: 200px;
+            height: 200px;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.04);
+        }
+
+        .auth-left-content {
+            max-width: 28rem;
+            z-index: 1;
+        }
+
+        .auth-brand-row {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+            margin-bottom: 2rem;
+        }
+
+        .auth-brand-icon {
+            width: 3.5rem;
+            height: 3.5rem;
+            background: rgba(255, 255, 255, 0.2);
+            border-radius: 0.75rem;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            backdrop-filter: blur(8px);
+            color: white;
+            font-size: 2rem;
+        }
+
+        .auth-welcome-title {
+            font-size: 1.875rem;
+            font-weight: 700;
+            color: white;
+            line-height: 1.3;
+            margin-bottom: 1rem;
+        }
+
+        .auth-welcome-desc {
+            color: rgba(255, 255, 255, 0.8);
+            line-height: 1.6;
+            margin-bottom: 2rem;
+            font-size: 0.9rem;
+        }
+
+        .auth-feature-list {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .auth-feature-item {
+            display: flex;
+            align-items: flex-start;
+            gap: 0.75rem;
+        }
+
+        .auth-feature-check {
+            width: 1.25rem;
+            height: 1.25rem;
+            border-radius: 0.25rem;
+            background: rgba(255, 255, 255, 0.2);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            flex-shrink: 0;
+            margin-top: 0.125rem;
+        }
+
+        .auth-feature-check svg {
+            width: 0.75rem;
+            height: 0.75rem;
+            color: white;
+        }
+
+        .auth-feature-label {
+            font-weight: 600;
+            color: white;
+            font-size: 0.875rem;
+        }
+
+        .auth-feature-desc {
+            color: rgba(255, 255, 255, 0.7);
+            font-size: 0.75rem;
+            margin-top: 0.125rem;
+        }
+
+        .auth-support-card {
+            margin-top: 2.5rem;
+            padding: 1rem;
+            background: rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(8px);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+            border-radius: 0.75rem;
+        }
+
+        .auth-support-row {
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+        }
+
+        .auth-support-avatar {
+            width: 2.5rem;
+            height: 2.5rem;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.2);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            flex-shrink: 0;
+        }
+
+        .auth-support-avatar svg {
+            width: 1.25rem;
+            height: 1.25rem;
+            color: white;
+        }
+
+        .auth-support-label {
+            font-size: 0.875rem;
+            font-weight: 600;
+            color: white;
+        }
+
+        .auth-support-desc {
+            font-size: 0.75rem;
+            color: rgba(255, 255, 255, 0.7);
+        }
+    }
+
+    .auth-right-panel {
+        width: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 1.5rem;
+        background: #f8fafc;
+    }
+
+    @@media (min-width: 1024px) {
+        .auth-right-panel {
+            width: 50%;
+            padding: 3rem;
+        }
+    }
+
+    .auth-form-wrapper {
+        width: 100%;
+        max-width: 28rem;
+    }
+
+    .auth-card {
+        border-radius: 0.75rem;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08), 0 1px 2px rgba(0, 0, 0, 0.06);
+        border: 1px solid #e2e8f0 !important;
+        background: white !important;
+    }
+
+    .auth-card-footer {
+        text-align: center;
+        padding-top: 1rem;
+        border-top: 1px solid #e2e8f0;
+        font-size: 0.75rem;
+        color: #64748b;
+    }
+
+    .auth-mobile-brand {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 0.5rem;
+        padding: 1rem 0;
+        margin-bottom: 0.5rem;
+    }
+
+    @@media (min-width: 1024px) {
+        .auth-mobile-brand {
+            display: none;
+        }
+    }
+
+    .auth-mobile-brand-icon {
+        width: 2rem;
+        height: 2rem;
+        background: #594AE2;
+        border-radius: 0.5rem;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+
+    .auth-mobile-brand-icon svg {
+        width: 1.25rem;
+        height: 1.25rem;
+        color: white;
+    }
+
+    .auth-mobile-brand-name {
+        font-weight: 700;
+        font-size: 1.125rem;
+        color: #594AE2;
+    }
+
+    .auth-mobile-brand-tagline {
+        font-size: 0.75rem;
+        color: #64748b;
+    }
+</style>
+
+<div class="auth-split-container">
+
+    <!-- LEFT PANEL - Branding -->
+    <div class="auth-left-panel">
+        <div class="auth-left-content">
+            <div class="auth-brand-row" @onclick="NavigateToHome" style="cursor: pointer;">
+                <div class="auth-brand-icon">
+                    <svg fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" style="width: 2rem; height: 2rem;"><path stroke-linecap="round" stroke-linejoin="round" d="M18 18.72a9.094 9.094 0 003.741-.479 3 3 0 00-4.682-2.72m.94 3.198l.001.031c0 .225-.012.447-.037.666A11.944 11.944 0 0112 21c-2.17 0-4.207-.576-5.963-1.584A6.062 6.062 0 016 18.719m12 0a5.971 5.971 0 00-.941-3.197m0 0A5.995 5.995 0 0012 12.75a5.995 5.995 0 00-5.058 2.772m0 0a3 3 0 00-4.681 2.72 8.986 8.986 0 003.74.477m.94-3.197a5.971 5.971 0 00-.94 3.197M15 6.75a3 3 0 11-6 0 3 3 0 016 0zm6 3a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0zm-13.5 0a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0z" /></svg>
+                </div>
+                <div>
+                    <div style="font-size: 1.5rem; font-weight: 700; color: white;">@GlobalConsts.AppName</div>
+                    <div style="font-size: 0.875rem; color: rgba(255, 255, 255, 0.7);">@GlobalConsts.AppTagline</div>
+                </div>
+            </div>
+            <h2 class="auth-welcome-title">Smart HR, Simplified</h2>
+            <p class="auth-welcome-desc">Manage your workforce with a complete, production-ready platform built on .NET 10 & Blazor Server.</p>
+            <div class="auth-feature-list">
+                <div class="auth-feature-item">
+                    <div class="auth-feature-check">
+                        <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="3"><path stroke-linecap="round" stroke-linejoin="round" d="M4.5 12.75l6 6 9-13.5"/></svg>
+                    </div>
+                    <div>
+                        <div class="auth-feature-label">Leave & Attendance</div>
+                        <div class="auth-feature-desc">Request, approve, and track leave with balance overview</div>
+                    </div>
+                </div>
+                <div class="auth-feature-item">
+                    <div class="auth-feature-check">
+                        <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="3"><path stroke-linecap="round" stroke-linejoin="round" d="M4.5 12.75l6 6 9-13.5"/></svg>
+                    </div>
+                    <div>
+                        <div class="auth-feature-label">Performance & Appraisal</div>
+                        <div class="auth-feature-desc">Evaluations, promotions, and transfer management</div>
+                    </div>
+                </div>
+                <div class="auth-feature-item">
+                    <div class="auth-feature-check">
+                        <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="3"><path stroke-linecap="round" stroke-linejoin="round" d="M4.5 12.75l6 6 9-13.5"/></svg>
+                    </div>
+                    <div>
+                        <div class="auth-feature-label">Payroll Processing</div>
+                        <div class="auth-feature-desc">Salary grades, income, deduction, and payroll runs</div>
+                    </div>
+                </div>
+            </div>
+            <div class="auth-support-card">
+                <div class="auth-support-row">
+                    <div class="auth-support-avatar">
+                        <svg fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5"><path stroke-linecap="round" stroke-linejoin="round" d="M15.75 9V5.25A2.25 2.25 0 0013.5 3h-6a2.25 2.25 0 00-2.25 2.25v13.5A2.25 2.25 0 007.5 21h6a2.25 2.25 0 002.25-2.25V15m3 0l3-3m0 0l-3-3m3 3H9"/></svg>
+                    </div>
+                    <div>
+                        <div class="auth-support-label">Try the Live Demo</div>
+                        <div class="auth-support-desc">Explore every feature at blazor-saas-hrm.csharpasp.net</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- RIGHT PANEL - Form -->
+    <div class="auth-right-panel">
+        <div class="auth-form-wrapper">
+            <div class="auth-mobile-brand">
+                <div class="auth-mobile-brand-icon">
+                    <svg fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" style="width: 1.25rem; height: 1.25rem;"><path stroke-linecap="round" stroke-linejoin="round" d="M18 18.72a9.094 9.094 0 003.741-.479 3 3 0 00-4.682-2.72m.94 3.198l.001.031c0 .225-.012.447-.037.666A11.944 11.944 0 0112 21c-2.17 0-4.207-.576-5.963-1.584A6.062 6.062 0 016 18.719m12 0a5.971 5.971 0 00-.941-3.197m0 0A5.995 5.995 0 0012 12.75a5.995 5.995 0 00-5.058 2.772m0 0a3 3 0 00-4.681 2.72 8.986 8.986 0 003.74.477m.94-3.197a5.971 5.971 0 00-.94 3.197M15 6.75a3 3 0 11-6 0 3 3 0 016 0zm6 3a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0zm-13.5 0a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0z" /></svg>
+                </div>
+                <div>
+                    <div class="auth-mobile-brand-name">@GlobalConsts.AppName</div>
+                    <div class="auth-mobile-brand-tagline">@GlobalConsts.AppTagline</div>
+                </div>
+            </div>
+
+            <MudCard Elevation="0" Class="auth-card pa-4 pa-sm-5">
+                <MudCardContent Class="pa-0 pa-sm-2">
+                    @Body
+                </MudCardContent>
+                <div class="auth-card-footer mt-4">
+                    &copy; @DateTime.Now.Year @GlobalConsts.AppInitial. ALL RIGHTS RESERVED.
+                </div>
+            </MudCard>
+        </div>
+    </div>
+
+</div>
+
+@code {
+    private MudTheme _theme = new MudTheme
+    {
+        PaletteLight = new PaletteLight
+        {
+            Primary = "#594AE2",
+            Secondary = "#7B6FE8",
+            AppbarBackground = "#594AE2",
+            DrawerBackground = "#ffffff",
+            Background = "#f8fafc",
+            Surface = "#ffffff",
+            TextPrimary = "#1e293b",
+            TextSecondary = "#64748b",
+            Divider = "#e2e8f0",
+
+        }
+    };
+
+    private void NavigateToHome()
+    {
+        Navigation.NavigateTo("/", forceLoad: true);
+    }
+}

Features/Account/ConfirmEmail/ConfirmEmailPage.razor

@@ -0,0 +1,101 @@
+@page "/account/confirm-email"
+@layout AuthenticationLayout
+@using Indotalent.Shared.Consts
+@using Microsoft.AspNetCore.Identity
+@using Microsoft.AspNetCore.WebUtilities
+@using System.Text
+@using Indotalent.Data.Entities
+@inject UserManager<ApplicationUser> UserManager
+@inject NavigationManager Navigation
+@inject ISnackbar Snackbar
+
+<PageTitle>Confirming Email - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .confirm-container {
+        text-align: center;
+        padding: 0.5rem 0;
+    }
+    .confirm-icon-wrapper {
+        display: flex;
+        justify-content: center;
+        margin-bottom: 1.5rem;
+    }
+    .confirm-icon-circle {
+        background: #EEECFA;
+        border-radius: 50%;
+        padding: 1.25rem;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: #594AE2;
+    }
+    .confirm-title {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin-bottom: 0.5rem;
+    }
+    .confirm-desc {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin-bottom: 1.5rem;
+    }
+</style>
+
+<div class="confirm-container">
+    <div class="confirm-icon-wrapper">
+        <div class="confirm-icon-circle">
+            <MudIcon Icon="@Icons.Material.Filled.Verified" />
+        </div>
+    </div>
+
+    <div class="confirm-title">Verifying Your Account</div>
+    <div class="confirm-desc">Please wait while we validate your email address...</div>
+
+    <MudProgressCircular Color="Color.Primary" Indeterminate="true" Size="Size.Large" />
+</div>
+
+@code {
+    [SupplyParameterFromQuery] public string? userId { get; set; }
+    [SupplyParameterFromQuery] public string? code { get; set; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (string.IsNullOrEmpty(userId) || string.IsNullOrEmpty(code))
+        {
+            Snackbar.Add("Invalid or expired confirmation link.", Severity.Error);
+            Navigation.NavigateTo("/account/login");
+            return;
+        }
+
+        var user = await UserManager.FindByIdAsync(userId);
+        if (user == null)
+        {
+            Snackbar.Add("User record not found.", Severity.Error);
+            Navigation.NavigateTo("/account/login");
+            return;
+        }
+
+        try
+        {
+            var decodedCode = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
+            var result = await UserManager.ConfirmEmailAsync(user, decodedCode);
+            await Task.Delay(500);
+            if (result.Succeeded)
+            {
+                Snackbar.Add("Email verified successfully! You can now sign in.", Severity.Success);
+            }
+            else
+            {
+                Snackbar.Add("Verification failed. The link may have expired.", Severity.Error);
+            }
+        }
+        catch
+        {
+            Snackbar.Add("An error occurred during verification.", Severity.Error);
+        }
+
+        Navigation.NavigateTo("/account/login");
+    }
+}

Features/Account/ForgotPassword/Components/ForgotPasswordPage.razor

@@ -0,0 +1,167 @@
+@page "/account/forgot-password"
+@layout AuthenticationLayout
+@using System.ComponentModel.DataAnnotations
+@using Indotalent.Shared.Consts
+@using Microsoft.JSInterop
+@inject IJSRuntime JSRuntime
+@inject ISnackbar Snackbar
+@inject NavigationManager Navigation
+
+<PageTitle>Forgot Password - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .page-header {
+        text-align: center;
+        margin-bottom: 1.5rem;
+    }
+    .page-header h2 {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin: 0 0 0.25rem 0;
+    }
+    .page-header p {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin: 0;
+    }
+    .form-label {
+        font-size: 0.8125rem;
+        font-weight: 600;
+        color: #475569;
+        margin-bottom: 0.375rem;
+        margin-left: 0.25rem;
+    }
+    .auth-link {
+        color: #594AE2;
+        font-weight: 600;
+        text-decoration: none;
+        cursor: pointer;
+    }
+    .auth-link:hover {
+        color: #4235B8;
+        text-decoration: underline;
+    }
+    .btn-submit {
+        text-transform: none;
+        border-radius: 0.5rem;
+        height: 48px;
+        font-weight: 600;
+        font-size: 0.875rem;
+        letter-spacing: 0;
+    }
+</style>
+
+<div class="page-header">
+    <h2>Forgot Password?</h2>
+    <p>Enter your email address and we'll send you a link to reset your password.</p>
+</div>
+
+<MudForm @ref="form" @bind-IsValid="@success">
+
+    <div class="mb-4">
+        <div class="form-label">Email Address</div>
+        <MudTextField T="string"
+                      @bind-Value="model.Email"
+                      Variant="Variant.Outlined"
+                      Placeholder="name@example.com"
+                      Margin="Margin.Dense"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Email"
+                      Required="true"
+                      Validation="@(new EmailAddressAttribute() { ErrorMessage = "Invalid email address format" })"
+                      For="@(() => model.Email)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <MudButton Variant="Variant.Filled"
+               Color="Color.Primary"
+               Size="Size.Large"
+               FullWidth="true"
+               Disabled="!success || isProcessing"
+               OnClick="HandleForgotPassword"
+               Class="btn-submit">
+        @if (isProcessing)
+        {
+            <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+            <span class="ms-2">Sending link...</span>
+        }
+        else
+        {
+            <span>Send Reset Link</span>
+        }
+    </MudButton>
+</MudForm>
+
+<div style="text-align: center; margin-top: 1.5rem;">
+    <MudText Typo="Typo.body2">
+        Remember your password?
+        <a class="auth-link ms-1" href="/account/login">Back to Sign In</a>
+    </MudText>
+</div>
+
+@code {
+    private MudForm form = default!;
+    private bool success;
+    private bool isProcessing;
+    private ForgotPasswordModel model = new();
+
+    private class ForgotPasswordModel
+    {
+        public string Email { get; set; } = "";
+    }
+
+    private async Task HandleForgotPassword()
+    {
+        await form.Validate();
+        if (!success) return;
+
+        isProcessing = true;
+        StateHasChanged();
+
+        var result = await JSRuntime.InvokeAsync<ApiResponse>("apiForgotPassword", model.Email);
+
+        if (result.Status == 200)
+        {
+            Snackbar.Add("If your email is registered, a reset link has been sent.", Severity.Success);
+            await Task.Delay(500);
+            Navigation.NavigateTo("/account/login");
+        }
+        else
+        {
+            Snackbar.Add(result.Title ?? "Failed to send reset link", Severity.Error);
+        }
+
+        isProcessing = false;
+        StateHasChanged();
+    }
+
+    private class ApiResponse
+    {
+        public int Status { get; set; }
+        public string? Title { get; set; }
+    }
+}
+
+<script>
+    window.apiForgotPassword = async (email) => {
+        try {
+            const response = await fetch('/api/account/forgot-password', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email })
+            });
+
+            if (response.ok) {
+                return { status: 200, title: 'Success' };
+            } else {
+                const data = await response.json();
+                let msg = 'Error processing request';
+                if (data.errors && data.errors.length > 0) msg = data.errors[0];
+                return { status: response.status, title: msg };
+            }
+        } catch (error) {
+            return { status: 500, title: 'Network error' };
+        }
+    };
+</script>

Features/Account/ForgotPassword/Cqrs/ForgotPasswordHandler.cs

@@ -0,0 +1,70 @@
+using Indotalent.Data.Entities;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.WebUtilities;
+using System.Text;
+
+namespace Indotalent.Features.Account.ForgotPassword.Cqrs;
+
+public class ForgotPasswordRequest
+{
+    public string Email { get; set; } = string.Empty;
+}
+
+public class ForgotPasswordResponse
+{
+    public string Message { get; set; } = string.Empty;
+}
+
+public record ForgotPasswordCommand(ForgotPasswordRequest Data) : IRequest<ForgotPasswordResponse>;
+
+public class ForgotPasswordHandler : IRequestHandler<ForgotPasswordCommand, ForgotPasswordResponse>
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly IEmailSender<ApplicationUser> _emailSender;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public ForgotPasswordHandler(
+        UserManager<ApplicationUser> userManager,
+        IEmailSender<ApplicationUser> emailSender,
+        IHttpContextAccessor httpContextAccessor)
+    {
+        _userManager = userManager;
+        _emailSender = emailSender;
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<ForgotPasswordResponse> Handle(ForgotPasswordCommand request, CancellationToken cancellationToken)
+    {
+        var user = await _userManager.FindByEmailAsync(request.Data.Email);
+
+        if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
+        {
+            return new ForgotPasswordResponse { Message = "If your email is registered, you will receive a reset link." };
+        }
+
+        var code = await _userManager.GeneratePasswordResetTokenAsync(user);
+        code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
+
+        var requestHttp = _httpContextAccessor.HttpContext?.Request;
+        var scheme = requestHttp?.Scheme ?? "https";
+        var host = requestHttp?.Host.Value ?? "localhost:8080";
+
+        var callbackUrl = $"{scheme}://{host}/account/reset-password?userId={user.Id}&code={code}";
+
+        var message = $@"
+            <div style=""font-family: Arial, sans-serif;"">
+                <h3>Password Reset Request</h3>
+                <p>Hello, {user.FullName}!</p>
+                <p>We received a request to reset your password. Click the link below to proceed:</p>
+                <p><a href=""{callbackUrl}"" style=""color: #2196F3; font-weight: bold;"">Reset Password</a></p>
+                <br/>
+                <p style=""font-size: 0.8em; color: #666;"">If you didn't request this, you can safely ignore this email.</p>
+                <p style=""font-size: 0.8em; color: #666;"">{callbackUrl}</p>
+            </div>";
+
+        await _emailSender.SendPasswordResetLinkAsync(user, user.Email!, message);
+
+        return new ForgotPasswordResponse { Message = "Reset link has been sent." };
+    }
+}

Features/Account/Login/Components/LoginPage.razor

@@ -0,0 +1,378 @@
+@page "/account/login"
+@layout AuthenticationLayout
+@using Indotalent.Shared.Consts
+@using Microsoft.JSInterop
+@using Indotalent.Infrastructure.Authentication.Identity
+@using Microsoft.Extensions.Options
+@inject IJSRuntime JSRuntime
+@inject IOptions<IdentitySettingsModel> IdentityOptions
+@inject NavigationManager Navigation
+@inject ISnackbar Snackbar
+
+<PageTitle>Sign In - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .page-header {
+        text-align: center;
+        margin-bottom: 1.5rem;
+    }
+    .page-header h2 {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin: 0 0 0.25rem 0;
+    }
+    .page-header p {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin: 0;
+    }
+    .form-label {
+        font-size: 0.8125rem;
+        font-weight: 600;
+        color: #475569;
+        margin-bottom: 0.375rem;
+        margin-left: 0.25rem;
+    }
+    .form-label-row {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        margin-bottom: 0.25rem;
+    }
+    .forgot-link {
+        font-size: 0.75rem;
+        font-weight: 600;
+        color: #594AE2;
+        text-decoration: none;
+        cursor: pointer;
+    }
+    .forgot-link:hover {
+        color: #4235B8;
+        text-decoration: underline;
+    }
+    .remember-row {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
+    .divider-or {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        margin: 1.25rem 0;
+    }
+    .divider-or::before,
+    .divider-or::after {
+        content: '';
+        flex: 1;
+        height: 1px;
+        background: #e2e8f0;
+    }
+    .divider-or span {
+        font-size: 0.75rem;
+        color: #94a3b8;
+        font-weight: 500;
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+    }
+    .auth-link {
+        color: #594AE2;
+        font-weight: 600;
+        text-decoration: none;
+        cursor: pointer;
+    }
+    .auth-link:hover {
+        color: #4235B8;
+        text-decoration: underline;
+    }
+    .btn-google {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 0.5rem;
+        padding: 0.625rem 1rem;
+        width: 100%;
+        background: white;
+        color: #475569;
+        font-size: 0.875rem;
+        font-weight: 500;
+        border-radius: 0.5rem;
+        border: 1.5px solid #e2e8f0;
+        transition: all 0.2s;
+        cursor: pointer;
+        text-transform: none;
+    }
+    .btn-google:hover {
+        border-color: #cbd5e1;
+        background: #f8fafc;
+    }
+    .btn-submit {
+        text-transform: none;
+        border-radius: 0.5rem;
+        height: 48px;
+        font-weight: 600;
+        font-size: 0.875rem;
+        letter-spacing: 0;
+    }
+</style>
+
+<div class="page-header">
+    <h2>Sign In</h2>
+    <p>Enter your credentials to access your account</p>
+</div>
+
+<MudForm @ref="form" @bind-IsValid="@success" Validation="@(new Func<EditContext, Task<bool>>(ValidateForm))" Class="w-100 px-2">
+
+    <div class="mb-3">
+        <div class="form-label">Email Address</div>
+        <MudTextField T="string"
+                      @bind-Value="model.Email"
+                      Variant="Variant.Outlined"
+                      Placeholder="you@company.com"
+                      Margin="Margin.Dense"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Email"
+                      Required="true"
+                      For="@(() => model.Email)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <div class="mb-3">
+        <div class="form-label-row">
+            <span class="form-label" style="margin-bottom:0;">Password</span>
+            <a class="forgot-link" href="/account/forgot-password">Forgot password?</a>
+        </div>
+        <MudTextField T="string"
+                      @bind-Value="model.Password"
+                      Variant="Variant.Outlined"
+                      Placeholder="Enter your password"
+                      Margin="Margin.Dense"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Lock"
+                      InputType="@(showPassword ? InputType.Text : InputType.Password)"
+                      AdornmentEndIcon="@(showPassword? Icons.Material.Filled.Visibility : Icons.Material.Filled.VisibilityOff)"
+                      OnAdornmentEndClick="() => showPassword = !showPassword"
+                      Required="true"
+                      For="@(() => model.Password)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <div class="remember-row mb-4">
+        <MudCheckBox T="bool"
+                     @bind-Value="rememberMe"
+                     Label="Remember me"
+                     Color="Color.Primary"
+                     Dense="true" />
+    </div>
+
+    <MudButton Variant="Variant.Filled"
+               Color="Color.Primary"
+               Size="Size.Large"
+               FullWidth="true"
+               Disabled="!success || isProcessing"
+               OnClick="HandleLogin"
+               Class="btn-submit">
+        @if (isProcessing)
+        {
+            <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+            <span class="ms-2">Signing in...</span>
+        }
+        else
+        {
+            <span>Sign In</span>
+        }
+    </MudButton>
+
+    @if (IdentityOptions.Value.SsoFirebase.IsUsed)
+    {
+        <div class="divider-or"><span>Or continue with</span></div>
+
+        <MudButton Variant="Variant.Outlined"
+                   FullWidth="true"
+                   Size="Size.Large"
+                   Disabled="isProcessing"
+                   OnClick="HandleFirebaseGoogleLogin"
+                   StartIcon="@Icons.Custom.Brands.Google"
+                   Class="btn-google">
+            Sign in with Google
+        </MudButton>
+    }
+</MudForm>
+
+<div style="text-align: center; margin-top: 1.5rem;">
+    <MudText Typo="Typo.body2">
+        Don't have an account?
+        <a class="auth-link ms-1" href="/account/register">Create one</a>
+    </MudText>
+</div>
+
+@code {
+    private MudForm form = default!;
+    private bool success;
+    private bool isProcessing;
+    private bool showPassword;
+    private bool rememberMe;
+    private LoginModel model = new();
+
+    private async Task<bool> ValidateForm(EditContext context) => await Task.FromResult(true);
+
+    private async Task HandleLogin()
+    {
+        await form.Validate();
+        if (!success) return;
+        isProcessing = true;
+        StateHasChanged();
+
+        var result = await JSRuntime.InvokeAsync<ApiJSRuntimeResponse>("apiAccountSignIn", model.Email, model.Password, rememberMe);
+        ProcessLoginResult(result);
+    }
+
+    private async Task HandleFirebaseGoogleLogin()
+    {
+        isProcessing = true;
+        StateHasChanged();
+
+        var firebaseUser = await JSRuntime.InvokeAsync<FirebaseUserResponse>("signInWithGoogle");
+
+        if (firebaseUser == null || string.IsNullOrEmpty(firebaseUser.Email))
+        {
+            Snackbar.Add("Google Sign-In failed or cancelled.", Severity.Error);
+            isProcessing = false;
+            return;
+        }
+
+        var checkResult = await JSRuntime.InvokeAsync<ActiveCheckResponse>("apiCheckActiveUser", firebaseUser.Email);
+        bool openForPublic = IdentityOptions.Value.SsoFirebase.OpenForPublic;
+
+        if (checkResult.Exists)
+        {
+            if (checkResult.IsActive)
+            {
+                await ExecuteSsoSignIn(firebaseUser.Email);
+            }
+            else
+            {
+                Snackbar.Add("Account is registered but not active.", Severity.Warning);
+                isProcessing = false;
+            }
+        }
+        else
+        {
+            var registerResult = await JSRuntime.InvokeAsync<ApiJSRuntimeResponse>(
+                "apiAccountSignUpSso",
+                firebaseUser.Email,
+                firebaseUser.Email,
+                openForPublic
+            );
+
+            if (registerResult.Status == 200)
+            {
+                if (openForPublic)
+                {
+                    await ExecuteSsoSignIn(firebaseUser.Email);
+                }
+                else
+                {
+                    Snackbar.Add("Registration successful. Please wait for admin approval.", Severity.Info);
+                    isProcessing = false;
+                }
+            }
+            else
+            {
+                Snackbar.Add("Failed to auto-register account.", Severity.Error);
+                isProcessing = false;
+            }
+        }
+    }
+
+    private async Task ExecuteSsoSignIn(string email)
+    {
+        var result = await JSRuntime.InvokeAsync<ApiJSRuntimeResponse>("apiAccountSsoSignIn", email);
+        ProcessLoginResult(result);
+    }
+
+    private void ProcessLoginResult(ApiJSRuntimeResponse result)
+    {
+        if (result.Status == 200)
+        {
+            Snackbar.Add(result.Title ?? "Login successful!", Severity.Success);
+            Task.Run(async () =>
+            {
+                await Task.Delay(500);
+                Navigation.NavigateTo("/account/tenant-selection", forceLoad: true);
+            });
+        }
+        else
+        {
+            Snackbar.Add(result.Title ?? "Sign in failed.", Severity.Error);
+            isProcessing = false;
+        }
+        StateHasChanged();
+    }
+
+    private class ApiJSRuntimeResponse { public int? Status { get; set; } public string? Title { get; set; } public string? Message { get; set; } }
+    private class FirebaseUserResponse { public string? Email { get; set; } }
+    private class ActiveCheckResponse { public bool Exists { get; set; } public bool IsActive { get; set; } }
+    private class LoginModel { public string Email { get; set; } = ""; public string Password { get; set; } = ""; }
+}
+
+<script>
+    window.apiAccountSignIn = async (email, password, rememberMe) => {
+        try {
+            const response = await fetch('/api/account/signin', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password, rememberMe }),
+                credentials: 'include'
+            });
+            const result = await response.json();
+            return { status: response.status, title: result.title };
+        } catch (error) {
+            return { status: 500, title: 'Network error' };
+        }
+    };
+
+    window.apiCheckActiveUser = async (email) => {
+        try {
+            const response = await fetch(`/api/account/active-user-exists?email=${encodeURIComponent(email)}`);
+            return await response.json();
+        } catch (error) {
+            return { exists: false, isActive: false };
+        }
+    };
+
+    window.apiAccountSignUpSso = async (email, fullName, isOpenForPublic) => {
+        try {
+            const response = await fetch('/api/account/signup', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    email: email,
+                    fullName: fullName,
+                    password: 'SSO_AUTO_GENERATED_PASSWORD_123!',
+                    isActive: isOpenForPublic,
+                    emailConfirmed: isOpenForPublic
+                })
+            });
+            const result = await response.json();
+            return { status: response.status, message: result.message };
+        } catch (error) {
+            return { status: 500 };
+        }
+    };
+
+    window.apiAccountSsoSignIn = async (email) => {
+        try {
+            const response = await fetch(`/api/account/signin-sso?email=${encodeURIComponent(email)}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include'
+            });
+            const result = await response.json();
+            return { status: response.status, title: result.title };
+        } catch (error) {
+            return { status: 500, title: 'SSO Network error' };
+        }
+    };
+</script>

Features/Account/Login/Cqrs/LoginHandler.cs

@@ -0,0 +1,74 @@
+using Indotalent.ConfigFrontEnd.Service;
+using Indotalent.Data.Entities;
+using Indotalent.Infrastructure.Authentication.Identity;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+
+namespace Indotalent.Features.Account.Login.Cqrs;
+
+public class LoginRequest
+{
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+    public bool RememberMe { get; set; }
+}
+
+public class LoginResponse
+{
+    public bool Succeeded { get; set; }
+    public string Message { get; set; } = string.Empty;
+    public bool IsNotAllowed { get; set; }
+    public string? Token { get; set; }
+    public string? RefreshToken { get; set; }
+}
+
+public record LoginCommand(LoginRequest Data) : IRequest<LoginResponse>;
+
+public class LoginHandler : IRequestHandler<LoginCommand, LoginResponse>
+{
+    private readonly SignInManager<ApplicationUser> _signInManager;
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly JwtSettingsModel _jwtSettings;
+
+    public LoginHandler(
+        SignInManager<ApplicationUser> signInManager,
+        UserManager<ApplicationUser> userManager,
+        IOptions<JwtSettingsModel> jwtSettings)
+    {
+        _signInManager = signInManager;
+        _userManager = userManager;
+        _jwtSettings = jwtSettings.Value;
+    }
+
+    public async Task<LoginResponse> Handle(LoginCommand request, CancellationToken cancellationToken)
+    {
+        var user = await _userManager.FindByEmailAsync(request.Data.Email);
+        if (user == null) return new LoginResponse { Succeeded = false, Message = "Invalid credentials" };
+
+        var result = await _signInManager.PasswordSignInAsync(user, request.Data.Password, request.Data.RememberMe, false);
+
+        if (result.Succeeded)
+        {
+            var token = JwtService.GenerateNewJwt(user, _jwtSettings);
+
+            var refreshToken = Guid.NewGuid().ToString().Replace("-", "");
+
+            user.RefreshToken = refreshToken;
+            user.LastLoginAt = DateTime.Now;
+            await _userManager.UpdateAsync(user);
+
+            return new LoginResponse
+            {
+                Succeeded = true,
+                Message = "Login successful",
+                Token = token,
+                RefreshToken = refreshToken
+            };
+        }
+
+        return new LoginResponse { Succeeded = false, Message = "Invalid credentials" };
+    }
+
+
+}

Features/Account/Logout/LogoutPage.razor

@@ -0,0 +1,152 @@
+@page "/account/logout"
+@layout AuthenticationLayout
+
+@using Indotalent.Shared.Consts
+@using Microsoft.JSInterop
+@inject IJSRuntime JSRuntime
+@inject ISnackbar Snackbar
+@inject NavigationManager Navigation
+
+<PageTitle>Sign Out - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .logout-container {
+        text-align: center;
+        padding: 0.5rem 0;
+    }
+    .logout-icon-wrapper {
+        display: flex;
+        justify-content: center;
+        margin-bottom: 1.5rem;
+    }
+    .logout-icon-circle {
+        background: #EEECFA;
+        border-radius: 50%;
+        padding: 1.25rem;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: #594AE2;
+    }
+    .logout-icon-circle .mud-icon-root {
+        font-size: 3rem;
+    }
+    .logout-title {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin-bottom: 0.5rem;
+    }
+    .logout-desc {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin-bottom: 2rem;
+    }
+    .btn-signout {
+        text-transform: none;
+        border-radius: 0.5rem;
+        height: 48px;
+        font-weight: 600;
+        font-size: 0.875rem;
+        letter-spacing: 0;
+        background-color: #594AE2;
+        color: white;
+    }
+    .btn-signout:hover {
+        background-color: #4235B8;
+    }
+    .btn-cancel {
+        text-transform: none;
+        color: #94a3b8;
+        font-weight: 600;
+    }
+</style>
+
+<div class="logout-container">
+    <div class="logout-icon-wrapper">
+        <div class="logout-icon-circle">
+            <MudIcon Icon="@Icons.Material.Filled.ExitToApp" />
+        </div>
+    </div>
+
+    <div class="logout-title">Sign Out</div>
+    <div class="logout-desc">Are you sure you want to sign out of your account?</div>
+
+    <MudButton Variant="Variant.Filled"
+               Size="Size.Large"
+               FullWidth="true"
+               Disabled="@isLoggingOut"
+               OnClick="Logout"
+               Class="btn-signout">
+        @if (isLoggingOut)
+        {
+            <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+            <span class="ms-2">Processing...</span>
+        }
+        else
+        {
+            <span>Sign Out</span>
+        }
+    </MudButton>
+
+    <MudButton Variant="Variant.Text"
+               Class="mt-3 btn-cancel"
+               FullWidth="true"
+               Href="/account/tenant-selection"
+               Disabled="@isLoggingOut">
+        Cancel
+    </MudButton>
+</div>
+
+@code {
+    private bool isLoggingOut;
+
+    private async Task Logout()
+    {
+        isLoggingOut = true;
+        StateHasChanged();
+
+        var result = await JSRuntime.InvokeAsync<ApiJSRuntimeResponse>("apiAccountLogout");
+
+        if (result.Status == 200)
+        {
+            Snackbar.Add("Successfully signed out!", Severity.Success);
+            await Task.Delay(500);
+            Navigation.NavigateTo("/", forceLoad: true);
+        }
+        else
+        {
+            Snackbar.Add(result.Title ?? "Failed to logout.", Severity.Error);
+            await Task.Delay(500);
+        }
+
+        isLoggingOut = false;
+        StateHasChanged();
+    }
+
+    private class ApiJSRuntimeResponse
+    {
+        public int? Status { get; set; }
+        public string? Title { get; set; }
+    }
+}
+
+<script>
+    window.apiAccountLogout = async () => {
+        try {
+            const response = await fetch('/api/account/signout', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                credentials: 'include'
+            });
+            if (!response.ok) {
+                throw new Error('Unknown error occurred');
+            }
+            return { status: 200, title: 'Success user logout' };
+        } catch (error) {
+            return { status: 500, title: 'Server / Network error' };
+        }
+    };
+</script>

Features/Account/Register/Components/RegisterPage.razor

@@ -0,0 +1,232 @@
+@page "/account/register"
+@layout AuthenticationLayout
+
+@using Indotalent.Shared.Consts
+@using Microsoft.JSInterop
+@inject IJSRuntime JSRuntime
+@inject ISnackbar Snackbar
+@inject NavigationManager Navigation
+@inject IConfiguration Configuration
+
+<PageTitle>Sign Up - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .page-header {
+        text-align: center;
+        margin-bottom: 1.5rem;
+    }
+    .page-header h2 {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin: 0 0 0.25rem 0;
+    }
+    .page-header p {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin: 0;
+    }
+    .form-label {
+        font-size: 0.8125rem;
+        font-weight: 600;
+        color: #475569;
+        margin-bottom: 0.375rem;
+        margin-left: 0.25rem;
+    }
+    .auth-link {
+        color: #594AE2;
+        font-weight: 600;
+        text-decoration: none;
+        cursor: pointer;
+    }
+    .auth-link:hover {
+        color: #4235B8;
+        text-decoration: underline;
+    }
+    .btn-submit {
+        text-transform: none;
+        border-radius: 0.5rem;
+        height: 48px;
+        font-weight: 600;
+        font-size: 0.875rem;
+        letter-spacing: 0;
+    }
+</style>
+
+<div class="page-header">
+    <h2>Sign Up</h2>
+    <p>Create your account to get started</p>
+</div>
+
+<MudForm @ref="form" @bind-IsValid="@success" Validation="@(new Func<EditContext, Task<bool>>(ValidateForm))">
+
+    <div class="mb-3">
+        <div class="form-label">Full Name</div>
+        <MudTextField T="string"
+                      @bind-Value="model.FullName"
+                      Variant="Variant.Outlined"
+                      Placeholder="Enter your full name"
+                      Margin="Margin.Dense"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Person"
+                      Required="true"
+                      For="@(() => model.FullName)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <div class="mb-3">
+        <div class="form-label">Email Address</div>
+        <MudTextField T="string"
+                      @bind-Value="model.Email"
+                      Variant="Variant.Outlined"
+                      Placeholder="you@company.com"
+                      Margin="Margin.Dense"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Email"
+                      Required="true"
+                      For="@(() => model.Email)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <div class="mb-4">
+        <div class="form-label">Password</div>
+        <MudTextField T="string"
+                      @bind-Value="model.Password"
+                      Variant="Variant.Outlined"
+                      Placeholder="Create a password"
+                      Margin="Margin.Dense"
+                      InputType="@(showPassword ? InputType.Text : InputType.Password)"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Lock"
+                      AdornmentEndIcon="@(showPassword? Icons.Material.Filled.Visibility : Icons.Material.Filled.VisibilityOff)"
+                      OnAdornmentEndClick="() => showPassword = !showPassword"
+                      Required="true"
+                      For="@(() => model.Password)"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <MudButton Variant="Variant.Filled"
+               Color="Color.Primary"
+               Size="Size.Large"
+               FullWidth="true"
+               Disabled="!success || isProcessing"
+               OnClick="HandleRegister"
+               Class="btn-submit">
+        @if (isProcessing)
+        {
+            <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+            <span class="ms-2">Creating account...</span>
+        }
+        else
+        {
+            <span>Create Account</span>
+        }
+    </MudButton>
+</MudForm>
+
+<div style="text-align: center; margin-top: 1.5rem;">
+    <MudText Typo="Typo.body2">
+        Already have an account?
+        <a class="auth-link ms-1" href="/account/login">Sign In</a>
+    </MudText>
+</div>
+
+@code {
+    private MudForm form = default!;
+    private bool success;
+    private bool isProcessing;
+    private bool showPassword;
+
+    private RegisterModel model = new();
+
+    private class RegisterModel
+    {
+        public string FullName { get; set; } = "";
+        public string Email { get; set; } = "";
+        public string Password { get; set; } = "";
+    }
+
+    private async Task<bool> ValidateForm(EditContext context)
+    {
+        return await Task.FromResult(true);
+    }
+
+    private async Task HandleRegister()
+    {
+        await form.Validate();
+
+        if (!success) return;
+
+        isProcessing = true;
+        StateHasChanged();
+
+        var result = await JSRuntime.InvokeAsync<ApiJSRuntimeResponse>("apiAccountRegister", model.FullName, model.Email, model.Password);
+
+        if (result.Status == 200)
+        {
+            var requireConfirmation = Configuration.GetValue<bool>("IdentitySettings:SignIn:RequireConfirmedAccount");
+
+            if (requireConfirmation)
+            {
+                Snackbar.Add("Registration successful! Please check your email to confirm your account.", Severity.Info);
+            }
+            else
+            {
+                Snackbar.Add("Registration successful! You can now sign in.", Severity.Success);
+            }
+
+            await Task.Delay(500);
+            Navigation.NavigateTo("/account/login");
+        }
+        else
+        {
+            Snackbar.Add(result.Title ?? "Registration failed", Severity.Error);
+        }
+
+        isProcessing = false;
+        StateHasChanged();
+    }
+
+    private class ApiJSRuntimeResponse
+    {
+        public int? Status { get; set; }
+        public string? Title { get; set; }
+    }
+}
+
+<script>
+    window.apiAccountRegister = async (fullName, email, password) => {
+        try {
+            const response = await fetch('/api/account/signup', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ fullName, email, password })
+            });
+
+            const data = await response.json();
+
+            if (response.ok) {
+                return { status: 200, title: 'Success account registration' };
+            } else {
+                let errorMessage = data.title || data.message || 'Registration failed';
+
+                if (data.errors) {
+                    if (Array.isArray(data.errors) && data.errors.length > 0) {
+                        errorMessage = data.errors[0];
+                    } else if (typeof data.errors === 'object') {
+                        const firstKey = Object.keys(data.errors)[0];
+                        if (firstKey) {
+                            errorMessage = data.errors[firstKey][0];
+                        }
+                    }
+                }
+
+                return { status: response.status, title: errorMessage };
+            }
+        } catch (error) {
+            return { status: 500, title: 'Server / Network error' };
+        }
+    };
+</script>

Features/Account/Register/Cqrs/RegisterHandler.cs

@@ -0,0 +1,131 @@
+using Indotalent.Data.Entities;
+using Indotalent.Infrastructure.Authorization.Identity;
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.EntityFrameworkCore;
+using System.Text;
+
+namespace Indotalent.Features.Account.Register.Cqrs;
+
+public class CreateUserRequest
+{
+    public string FullName { get; set; } = string.Empty;
+    public string Email { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+    public bool IsActive { get; set; } = true;
+    public bool EmailConfirmed { get; set; } = false;
+}
+
+public class CreateUserResponse
+{
+    public string? Id { get; set; }
+    public string? Email { get; set; }
+}
+
+public record CreateUserCommand(CreateUserRequest Data) : IRequest<CreateUserResponse>;
+
+public class RegisterHandler : IRequestHandler<CreateUserCommand, CreateUserResponse>
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly IEmailSender<ApplicationUser> _emailSender;
+    private readonly IConfiguration _configuration;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly AppDbContext _context;
+
+    public RegisterHandler(
+        UserManager<ApplicationUser> userManager,
+        IEmailSender<ApplicationUser> emailSender,
+        IConfiguration configuration,
+        IHttpContextAccessor httpContextAccessor,
+        AppDbContext context)
+    {
+        _userManager = userManager;
+        _emailSender = emailSender;
+        _configuration = configuration;
+        _httpContextAccessor = httpContextAccessor;
+        _context = context;
+    }
+
+    public async Task<CreateUserResponse> Handle(CreateUserCommand request, CancellationToken cancellationToken)
+    {
+        var user = new ApplicationUser
+        {
+            UserName = request.Data.Email,
+            Email = request.Data.Email,
+            FullName = request.Data.FullName,
+            IsActive = request.Data.IsActive,
+            EmailConfirmed = request.Data.EmailConfirmed,
+        };
+
+        var result = await _userManager.CreateAsync(user, request.Data.Password);
+
+        if (!result.Succeeded)
+        {
+            var errors = result.Errors.Select(x => x.Description).ToList();
+            throw new Exception(string.Join(", ", errors));
+        }
+
+        // Assign default roles: Member and TenantAdmin (but not Admin)
+        var rolesToAdd = new List<string> { ApplicationRoles.Member, ApplicationRoles.TenantAdmin };
+
+        await _userManager.AddToRolesAsync(user, rolesToAdd);
+
+        // Create default tenant for the new user
+        var tenant = new Data.Entities.Tenant
+        {
+            Name = "Default Tenant",
+            Description = $"Default tenant for {request.Data.Email}",
+            EmailAddress = request.Data.Email,
+            IsActive = true
+        };
+
+        _context.Tenant.Add(tenant);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        // Create TenantUser linking the user to the default tenant
+        var tenantUser = new Data.Entities.TenantUser
+        {
+            TenantId = tenant.Id,
+            UserId = user.Id,
+            Summary = $"Default tenant assignment for {request.Data.FullName}",
+            IsActive = true
+        };
+
+        _context.TenantUser.Add(tenantUser);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        var requireConfirmation = _configuration.GetValue<bool>("IdentitySettings:SignIn:RequireConfirmedAccount");
+
+        if (requireConfirmation)
+        {
+            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
+            code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
+
+            var requestHttp = _httpContextAccessor.HttpContext?.Request;
+            var scheme = requestHttp?.Scheme ?? "https";
+            var host = requestHttp?.Host.Value ?? "localhost:8080";
+
+            var callbackUrl = $"{scheme}://{host}/account/confirm-email?userId={user.Id}&code={code}";
+
+            var message = $@"
+                <div style=""font-family: Arial, sans-serif;"">
+                    <h3>Welcome, {user.FullName}!</h3>
+                    <p>Please confirm your account by clicking the link below:</p>
+                    <p><a href=""{callbackUrl}"" style=""color: #2196F3; font-weight: bold; text-decoration: underline;"">Confirm Account</a></p>
+                    <br/>
+                    <p style=""font-size: 0.8em; color: #666;"">If the link doesn't work, copy and paste this URL into your browser:</p>
+                    <p style=""font-size: 0.8em; color: #666;"">{callbackUrl}</p>
+                </div>";
+
+            await _emailSender.SendConfirmationLinkAsync(user, user.Email!, message);
+        }
+
+        return new CreateUserResponse
+        {
+            Id = user.Id,
+            Email = user.Email
+        };
+    }
+}

Features/Account/ResetPassword/Components/ResetPasswordPage.razor

@@ -0,0 +1,181 @@
+@page "/account/reset-password"
+@layout AuthenticationLayout
+@using Indotalent.Shared.Consts
+@using Microsoft.JSInterop
+@inject IJSRuntime JSRuntime
+@inject ISnackbar Snackbar
+@inject NavigationManager Navigation
+
+<PageTitle>Reset Password - @GlobalConsts.AppInitial</PageTitle>
+
+<style>
+    .page-header {
+        text-align: center;
+        margin-bottom: 1.5rem;
+    }
+    .page-header h2 {
+        font-size: 1.5rem;
+        font-weight: 700;
+        color: #1e293b;
+        margin: 0 0 0.25rem 0;
+    }
+    .page-header p {
+        font-size: 0.875rem;
+        color: #64748b;
+        margin: 0;
+    }
+    .form-label {
+        font-size: 0.8125rem;
+        font-weight: 600;
+        color: #475569;
+        margin-bottom: 0.375rem;
+        margin-left: 0.25rem;
+    }
+    .btn-submit {
+        text-transform: none;
+        border-radius: 0.5rem;
+        height: 48px;
+        font-weight: 600;
+        font-size: 0.875rem;
+        letter-spacing: 0;
+    }
+</style>
+
+<div class="page-header">
+    <h2>Create New Password</h2>
+    <p>Please enter your new password below.</p>
+</div>
+
+<MudForm @ref="form" @bind-IsValid="@success">
+    <div class="mb-3">
+        <div class="form-label">New Password</div>
+        <MudTextField T="string"
+                      @bind-Value="model.NewPassword"
+                      Variant="Variant.Outlined"
+                      Placeholder="Enter new password"
+                      Margin="Margin.Dense"
+                      InputType="@(showPassword ? InputType.Text : InputType.Password)"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Lock"
+                      AdornmentEndIcon="@(showPassword? Icons.Material.Filled.Visibility : Icons.Material.Filled.VisibilityOff)"
+                      OnAdornmentEndClick="() => showPassword = !showPassword"
+                      Required="true"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <div class="mb-4">
+        <div class="form-label">Confirm New Password</div>
+        <MudTextField T="string"
+                      @bind-Value="model.ConfirmPassword"
+                      Variant="Variant.Outlined"
+                      Placeholder="Repeat new password"
+                      Margin="Margin.Dense"
+                      InputType="@(showPassword ? InputType.Text : InputType.Password)"
+                      Adornment="Adornment.Start"
+                      AdornmentIcon="@Icons.Material.Filled.Lock"
+                      Required="true"
+                      Validation="@(new Func<string, string?>(PasswordMatch))"
+                      Style="border-radius: 0.5rem;" />
+    </div>
+
+    <MudButton Variant="Variant.Filled"
+               Color="Color.Primary"
+               Size="Size.Large"
+               FullWidth="true"
+               Disabled="!success || isProcessing"
+               OnClick="HandleResetPassword"
+               Class="btn-submit">
+        @if (isProcessing)
+        {
+            <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+            <span class="ms-2">Resetting...</span>
+        }
+        else
+        {
+            <span>Reset Password</span>
+        }
+    </MudButton>
+</MudForm>
+
+@code {
+    [SupplyParameterFromQuery] public string? userId { get; set; }
+    [SupplyParameterFromQuery] public string? code { get; set; }
+
+    private MudForm form = default!;
+    private bool success;
+    private bool isProcessing;
+    private bool showPassword;
+    private ResetModel model = new();
+
+    private class ResetModel
+    {
+        public string NewPassword { get; set; } = "";
+        public string ConfirmPassword { get; set; } = "";
+    }
+
+    private string? PasswordMatch(string arg)
+    {
+        if (model.NewPassword != arg) return "Passwords do not match";
+        return null;
+    }
+
+    private async Task HandleResetPassword()
+    {
+        await form.Validate();
+        if (!success) return;
+
+        if (string.IsNullOrEmpty(userId) || string.IsNullOrEmpty(code))
+        {
+            Snackbar.Add("Invalid reset token or user ID.", Severity.Error);
+            return;
+        }
+
+        isProcessing = true;
+        StateHasChanged();
+
+        var result = await JSRuntime.InvokeAsync<ApiResponse>("apiResetPassword", userId, code, model.NewPassword);
+
+        if (result.Status == 200)
+        {
+            Snackbar.Add("Password reset successful! You can now sign in.", Severity.Success);
+            await Task.Delay(500);
+            Navigation.NavigateTo("/account/login");
+        }
+        else
+        {
+            Snackbar.Add(result.Title ?? "Failed to reset password", Severity.Error);
+        }
+
+        isProcessing = false;
+        StateHasChanged();
+    }
+
+    private class ApiResponse
+    {
+        public int Status { get; set; }
+        public string? Title { get; set; }
+    }
+}
+
+<script>
+    window.apiResetPassword = async (userId, code, newPassword) => {
+        try {
+            const response = await fetch('/api/account/reset-password', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ userId, code, newPassword })
+            });
+
+            if (response.ok) {
+                return { status: 200, title: 'Success' };
+            } else {
+                const data = await response.json();
+                let msg = 'Failed to reset password';
+                if (data.errors && data.errors.length > 0) msg = data.errors[0];
+                return { status: response.status, title: msg };
+            }
+        } catch (error) {
+            return { status: 500, title: 'Network error' };
+        }
+    };
+</script>

Features/Account/ResetPassword/Cqrs/ResetPasswordHandler.cs

@@ -0,0 +1,51 @@
+using Indotalent.Data.Entities;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.WebUtilities;
+using System.Text;
+
+namespace Indotalent.Features.Account.ResetPassword.Cqrs;
+
+public class ResetPasswordRequest
+{
+    public string UserId { get; set; } = string.Empty;
+    public string Code { get; set; } = string.Empty;
+    public string NewPassword { get; set; } = string.Empty;
+}
+
+public class ResetPasswordResponse
+{
+    public string Message { get; set; } = string.Empty;
+}
+
+public record ResetPasswordCommand(ResetPasswordRequest Data) : IRequest<ResetPasswordResponse>;
+
+public class ResetPasswordHandler : IRequestHandler<ResetPasswordCommand, ResetPasswordResponse>
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+
+    public ResetPasswordHandler(UserManager<ApplicationUser> userManager)
+    {
+        _userManager = userManager;
+    }
+
+    public async Task<ResetPasswordResponse> Handle(ResetPasswordCommand request, CancellationToken cancellationToken)
+    {
+        var user = await _userManager.FindByIdAsync(request.Data.UserId);
+        if (user == null)
+        {
+            throw new Exception("User not found.");
+        }
+
+        var decodedCode = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(request.Data.Code));
+        var result = await _userManager.ResetPasswordAsync(user, decodedCode, request.Data.NewPassword);
+
+        if (!result.Succeeded)
+        {
+            var errors = result.Errors.Select(x => x.Description).ToList();
+            throw new Exception(string.Join(", ", errors));
+        }
+
+        return new ResetPasswordResponse { Message = "Password has been reset successfully." };
+    }
+}

Features/Account/TenantSelection/Components/TenantSelectionPage.razor

@@ -0,0 +1,131 @@
+@page "/account/tenant-selection"
+@layout AuthenticationLayout
+@using Indotalent.Shared.Consts
+@attribute [Authorize]
+@using Microsoft.AspNetCore.Authorization
+@using Microsoft.JSInterop
+@inject NavigationManager Navigation
+@inject ISnackbar Snackbar
+@inject IJSRuntime JSRuntime
+
+<PageTitle>Select Tenant - @GlobalConsts.AppInitial</PageTitle>
+
+<div class="d-flex flex-column align-center justify-center mb-6 w-100">
+    <MudText Typo="Typo.h5" Align="Align.Center" Style="font-weight: 800; width: 100%;">Select Tenant</MudText>
+    <MudText Typo="Typo.body2" Align="Align.Center" Class="text-muted" Style="width: 100%;">Please select a tenant to continue</MudText>
+</div>
+
+<div class="w-100 px-2">
+    @if (isLoading)
+    {
+        <div class="d-flex justify-center my-8">
+            <MudProgressCircular Color="Color.Primary" Indeterminate="true" Size="Size.Large" />
+        </div>
+    }
+    else if (!myTenants.Any())
+    {
+        <MudAlert Severity="Severity.Error" Variant="Variant.Outlined" Class="my-4" Style="border-radius: 8px;">
+            You don't have access to any tenant. Please contact your Administrator.
+        </MudAlert>
+    }
+    else
+    {
+        <div style="max-height: 320px; overflow-y: auto; padding-right: 4px;">
+            <MudList T="TenantDto" Clickable="true" SelectionMode="SelectionMode.SingleSelection" Class="pa-0">
+                @foreach (var item in myTenants)
+                {
+                    <MudListItem OnClick="() => HandleSelectTenant(item.TenantId)"
+                                 Icon="@Icons.Material.Filled.Business"
+                                 IconColor="Color.Primary"
+                                 Class="py-3 my-2"
+                                 Style="border: 1px solid var(--mud-palette-divider); border-radius: 8px; background-color: var(--mud-palette-background-grey); transition: all 0.2s ease-in-out;">
+                        <ChildContent>
+                            <div class="d-flex flex-column">
+                                <MudText Typo="Typo.subtitle1" Style="font-weight: 700; color: var(--mud-palette-text-primary);">
+                                    @item.TenantName
+                                </MudText>
+                                @if (!string.IsNullOrEmpty(item.Description))
+                                {
+                                    <MudText Typo="Typo.caption" Style="color: var(--mud-palette-text-secondary);">
+                                        @item.Description
+                                    </MudText>
+                                }
+                            </div>
+                        </ChildContent>
+                    </MudListItem>
+                }
+            </MudList>
+        </div>
+    }
+</div>
+
+<div class="text-center mt-6">
+    <MudText Typo="Typo.body2">
+        Want to sign in with another account?
+        <MudLink Href="/account/logout" Color="Color.Primary" Style="font-weight: 700;">Sign Out</MudLink>
+    </MudText>
+</div>
+
+@code {
+    private bool isLoading = true;
+    private List<TenantDto> myTenants = new();
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            myTenants = await JSRuntime.InvokeAsync<List<TenantDto>>("apiAccountFetchMyTenants");
+            isLoading = false;
+            StateHasChanged();
+        }
+    }
+
+    private async Task HandleSelectTenant(string tenantId)
+    {
+        var result = await JSRuntime.InvokeAsync<ApiResult>("apiAccountConfirmTenant", tenantId);
+
+        if (result.Success)
+        {
+            Snackbar.Add("Tenant workspace loaded successfully.", Severity.Success);
+            Navigation.NavigateTo("/home", forceLoad: true);
+        }
+        else
+        {
+            Snackbar.Add("Failed to assign tenant workspace.", Severity.Error);
+        }
+    }
+
+    public class TenantDto { public string TenantId { get; set; } = ""; public string TenantName { get; set; } = ""; public string? Description { get; set; } }
+    public class ApiResult { public bool Success { get; set; } }
+}
+
+<script>
+    window.apiAccountFetchMyTenants = async () => {
+        try {
+            const response = await fetch('/api/account/my-tenants', {
+                method: 'GET',
+                credentials: 'include'
+            });
+            if (response.status === 200) {
+                return await response.json();
+            }
+            return [];
+        } catch (error) {
+            return [];
+        }
+    };
+
+    window.apiAccountConfirmTenant = async (tenantId) => {
+        try {
+            const response = await fetch('/api/account/confirm-tenant', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ tenantId }),
+                credentials: 'include'
+            });
+            return await response.json();
+        } catch (error) {
+            return { success: false };
+        }
+    };
+</script>

Features/Account/TenantSelection/Cqrs/TenantSelectionHandler.cs

@@ -0,0 +1,67 @@
+using Indotalent.Data.Entities;
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Account.TenantSelection.Cqrs;
+
+public record GetTenantsQuery(string UserId) : IRequest<List<TenantLookupDto>>;
+
+public class TenantLookupDto
+{
+    public string TenantId { get; set; } = string.Empty;
+    public string TenantName { get; set; } = string.Empty;
+    public string? Description { get; set; }
+}
+
+public class GetTenantsHandler : IRequestHandler<GetTenantsQuery, List<TenantLookupDto>>
+{
+    private readonly AppDbContext _context;
+
+    public GetTenantsHandler(AppDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<List<TenantLookupDto>> Handle(GetTenantsQuery request, CancellationToken cancellationToken)
+    {
+        return await _context.Set<TenantUser>()
+            .IgnoreQueryFilters()
+            .Where(tu => tu.UserId == request.UserId && tu.IsActive)
+            .Select(tu => new TenantLookupDto
+            {
+                TenantId = tu.TenantId ?? string.Empty,
+                TenantName = tu.Tenant != null ? (tu.Tenant.Name ?? "Unknown") : "Unknown",
+                Description = tu.Tenant != null ? (tu.Tenant.Description ?? "") : ""
+            })
+            .ToListAsync(cancellationToken);
+    }
+}
+
+public record ConfirmTenantRequest(string TenantId);
+public record ConfirmTenantResponse(bool Success, string Message);
+public record ConfirmTenantCommand(string UserId, ConfirmTenantRequest Data) : IRequest<ConfirmTenantResponse>;
+
+public class ConfirmTenantHandler : IRequestHandler<ConfirmTenantCommand, ConfirmTenantResponse>
+{
+    private readonly AppDbContext _context;
+
+    public ConfirmTenantHandler(AppDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<ConfirmTenantResponse> Handle(ConfirmTenantCommand request, CancellationToken cancellationToken)
+    {
+        var hasAccess = await _context.Set<TenantUser>()
+            .IgnoreQueryFilters()
+            .AnyAsync(tu => tu.UserId == request.UserId && tu.TenantId == request.Data.TenantId && tu.IsActive, cancellationToken);
+
+        if (!hasAccess)
+        {
+            return new ConfirmTenantResponse(false, "Access denied to the selected organization.");
+        }
+
+        return new ConfirmTenantResponse(true, "Tenant authorized.");
+    }
+}

Features/Account/_Imports.razor

@@ -0,0 +1,7 @@
+@using MudBlazor
+@using Microsoft.AspNetCore.Components.Forms
+@using Microsoft.AspNetCore.Components.Web
+@using System.ComponentModel.DataAnnotations
+
+@inject NavigationManager Navigation
+@inject ISnackbar Snackbar

Features/AppSettings/Json/JsonPage.razor

@@ -0,0 +1,259 @@
+@page "/appsettings/json"
+@using Indotalent.Infrastructure.Authentication.Firebase
+@using Indotalent.Infrastructure.Authentication.Keycloak
+@using Microsoft.AspNetCore.Authorization
+@using Indotalent.Infrastructure.Authorization.Identity
+@attribute [Authorize(Roles = ApplicationRoles.Admin)]
+@using Indotalent.Infrastructure.Authentication.Identity
+@using Indotalent.Infrastructure.Database
+@using Indotalent.Infrastructure.BackgroundJob
+@using Indotalent.Infrastructure.Email
+@using Indotalent.Infrastructure.File
+@using Indotalent.Infrastructure.Logging
+@using Indotalent.Infrastructure.Authentication
+@using MudBlazor
+@using System.Reflection
+@inject IdentityService IdentitySvc
+@inject DatabaseService DbSvc
+@inject BackgroundJobService JobSvc
+@inject EmailService EmailSvc
+@inject FileStorageService StorageSvc
+@inject LoggingService LogSvc
+@inject FirebaseService FirebaseSvc
+@inject KeycloakService KeycloakSvc
+
+<style>
+    .clean-white-tabs .mud-tabs-toolbar {
+        background-color: white !important;
+        border-bottom: 2px solid #DCEBFA;
+        border-radius: 0px !important;
+    }
+
+    .clean-white-tabs .mud-tab {
+        color: #94a3b8 !important;
+        text-transform: none;
+        font-weight: 500;
+        min-width: 140px;
+        border-radius: 0px !important;
+    }
+
+    .clean-white-tabs .mud-tab-active {
+        color: var(--mud-palette-primary) !important;
+        font-weight: 800;
+    }
+
+    .clean-white-tabs .mud-tabs-slider {
+        background-color: var(--mud-palette-primary) !important;
+        height: 3px !important;
+        bottom: 0;
+    }
+
+    .soltemp-info-card {
+        border: 1px solid #DCEBFA !important;
+        border-radius: 0px !important;
+        background-color: #ffffff;
+        margin-bottom: 24px;
+    }
+
+    .soltemp-info-header {
+        padding: 12px 16px !important;
+        background-color: #F0F7FF;
+        border-bottom: 1px solid #DCEBFA;
+    }
+
+    .soltemp-row-compact {
+        display: flex;
+        padding: 10px 16px;
+        align-items: center;
+        border-bottom: 1px solid #F0F7FF;
+    }
+
+    .soltemp-label-text {
+        width: 30%;
+        font-weight: 800;
+        color: #1a1a1a;
+        font-size: 0.75rem;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+    }
+
+    .soltemp-value-text {
+        width: 70%;
+        color: #4A5D75;
+        font-size: 0.85rem;
+        font-weight: 500;
+        font-family: 'Consolas', monospace;
+        word-break: break-all;
+    }
+
+    .status-chip {
+        font-weight: 900;
+        font-size: 10px;
+        border-radius: 0px !important;
+    }
+</style>
+
+<MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="mt-2 mb-8">
+    <div class="clean-white-tabs">
+        <MudTabs Elevation="0" TabPanelsClass="pt-4" Rounded="false" ApplyEffectsToContainer="true">
+
+            <MudTabPanel Text="Identity" Icon="@Icons.Material.Outlined.AdminPanelSettings">
+                @RenderIdentityProperties(IdentitySvc.GetConfiguration(), "Security & Identity")
+            </MudTabPanel>
+
+            <MudTabPanel Text="Database" Icon="@Icons.Material.Outlined.Storage">
+                @RenderObjectProperties(DbSvc.GetConfiguration(), "Database Engine")
+            </MudTabPanel>
+
+            <MudTabPanel Text="Jobs" Icon="@Icons.Material.Outlined.Schedule">
+                @RenderObjectProperties(JobSvc.GetConfiguration(), "Background Job Services")
+            </MudTabPanel>
+
+            <MudTabPanel Text="Email" Icon="@Icons.Material.Outlined.Email">
+                @RenderObjectProperties(EmailSvc.GetConfiguration(), "Email Providers")
+            </MudTabPanel>
+
+            <MudTabPanel Text="Storage" Icon="@Icons.Material.Outlined.CloudUpload">
+                @RenderObjectProperties(StorageSvc.GetConfiguration(), "File Storage Systems")
+            </MudTabPanel>
+
+            <MudTabPanel Text="Logging" Icon="@Icons.Material.Outlined.ListAlt">
+                @RenderObjectProperties(LogSvc.GetConfiguration(), "Diagnostic Logging")
+            </MudTabPanel>
+
+        </MudTabs>
+    </div>
+</MudContainer>
+
+@code {
+    private RenderFragment RenderIdentityProperties(IdentitySettingsModel settings, string sectionTitle)
+    {
+        return __builder =>
+        {
+            <MudPaper Elevation="0" Square="true" Class="pa-6 mb-6 d-flex align-center justify-space-between" Style="border: 1px solid #DCEBFA;">
+                <div>
+                    <MudText Typo="Typo.h5" Style="font-weight: 900; color: #1a1a1a;">@sectionTitle</MudText>
+                    <MudText Typo="Typo.body2" Style="color: #64748b;">Security Policy & Default Credentials</MudText>
+                </div>
+                <div class="d-flex align-center gap-2">
+                    <MudIcon Icon="@Icons.Material.Filled.Home" Size="Size.Small" Color="Color.Default" />
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">/</MudText>
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">System</MudText>
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">/</MudText>
+                    <MudText Typo="Typo.caption" Style="font-weight: 600; color: #1a1a1a;">@sectionTitle</MudText>
+                </div>
+            </MudPaper>
+
+            if (settings != null)
+            {
+                @RenderSectionCard("Password Policy", settings.Password)
+                @RenderSectionCard("Cookie Settings", settings.Cookies)
+                @RenderSectionCard("Default Admin", settings.DefaultAdmin)
+                @RenderSectionCard("SignIn Policy", settings.SignIn)
+                @RenderSectionCard("SSO Firebase", settings.SsoFirebase)
+                @RenderSectionCard("SSO Keycloak", settings.SsoKeycloak)
+            }
+        };
+    }
+
+    private RenderFragment RenderSectionCard(string title, object sectionValue)
+    {
+        return __builder =>
+        {
+            if (sectionValue == null) return;
+
+            <MudCard Elevation="0" Class="soltemp-info-card">
+                <div class="soltemp-info-header d-flex align-center justify-space-between">
+                    <MudText Typo="Typo.body1" Style="font-weight: 900; color: #1a1a1a;">@title</MudText>
+                    <MudChip T="string" Color="Color.Primary" Size="Size.Small" Variant="Variant.Filled" Class="status-chip">CONFIGURED</MudChip>
+                </div>
+                <MudCardContent Style="padding: 0;">
+                    @{
+                        var props = sectionValue.GetType().GetProperties();
+                        int i = 0;
+                    }
+                    @foreach (var p in props)
+                    {
+                        var val = p.GetValue(sectionValue);
+                        <div class="soltemp-row-compact" style="background-color: @(i++ % 2 == 0 ? "#ffffff" : "#F9FCFF");">
+                            <div class="soltemp-label-text">@p.Name</div>
+                            <div class="soltemp-value-text">
+                                @(MaskIfSensitive(p.Name, val?.ToString()))
+                            </div>
+                        </div>
+                    }
+                </MudCardContent>
+            </MudCard>
+        };
+    }
+
+    private RenderFragment RenderObjectProperties(object settingsObj, string sectionTitle)
+    {
+        return __builder =>
+        {
+            <MudPaper Elevation="0" Square="true" Class="pa-6 mb-6 d-flex align-center justify-space-between" Style="border: 1px solid #DCEBFA;">
+                <div>
+                    <MudText Typo="Typo.h5" Style="font-weight: 900; color: #1a1a1a;">@sectionTitle</MudText>
+                    <MudText Typo="Typo.body2" Style="color: #64748b;">Configuration discovery (Full Inspection Mode)</MudText>
+                </div>
+                <div class="d-flex align-center gap-2">
+                    <MudIcon Icon="@Icons.Material.Filled.Home" Size="Size.Small" Color="Color.Default" />
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">/</MudText>
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">System</MudText>
+                    <MudText Typo="Typo.caption" Style="color: #94a3b8;">/</MudText>
+                    <MudText Typo="Typo.caption" Style="font-weight: 600; color: #1a1a1a;">@sectionTitle</MudText>
+                </div>
+            </MudPaper>
+
+            if (settingsObj != null)
+            {
+                var providers = settingsObj.GetType().GetProperties();
+                foreach (var provider in providers)
+                {
+                    var providerValue = provider.GetValue(settingsObj);
+                    if (providerValue == null) continue;
+
+                    <MudCard Elevation="0" Class="soltemp-info-card">
+                        <div class="soltemp-info-header d-flex align-center justify-space-between">
+                            <MudText Typo="Typo.body1" Style="font-weight: 900; color: #1a1a1a;">@provider.Name</MudText>
+                            @{
+                                var isUsedProp = providerValue.GetType().GetProperty("IsUsed");
+                                bool isUsed = (bool)(isUsedProp?.GetValue(providerValue) ?? false);
+                            }
+                            <MudChip T="string" Color="@(isUsed? Color.Success: Color.Default)" Size="Size.Small" Variant="Variant.Filled" Class="status-chip">
+                                @(isUsed ? "ACTIVE" : "DISABLED")
+                            </MudChip>
+                        </div>
+                        <MudCardContent Style="padding: 0;">
+                            @{
+                                var props = providerValue.GetType().GetProperties();
+                                int i = 0;
+                            }
+                            @foreach (var p in props)
+                            {
+                                if (p.Name == "IsUsed") continue;
+                                <div class="soltemp-row-compact" style="background-color: @(i++ % 2 == 0 ? "#ffffff" : "#F9FCFF");">
+                                    <div class="soltemp-label-text">@p.Name</div>
+                                    <div class="soltemp-value-text">
+                                        @(MaskIfSensitive(p.Name, p.GetValue(providerValue)?.ToString()))
+                                    </div>
+                                </div>
+                            }
+                        </MudCardContent>
+                    </MudCard>
+                }
+            }
+        };
+    }
+
+    private string MaskIfSensitive(string propertyName, string value)
+    {
+        if (string.IsNullOrEmpty(value)) return "-";
+        var sensitiveKeys = new[] { "Password", "Secret", "Key", "Token", "ApiKey" };
+        if (sensitiveKeys.Any(k => propertyName.Contains(k, StringComparison.OrdinalIgnoreCase)))
+        {
+            return "•••••••••••••••• (Encrypted)";
+        }
+        return value;
+    }
+}

Features/FeaturesDI.cs

@@ -0,0 +1,81 @@
+using Indotalent.Features.Leave.LeaveBalance;
+using Indotalent.Features.Leave.LeaveCategory;
+using Indotalent.Features.Leave.LeaveRequest;
+using Indotalent.Features.Multitenant.Tenant;
+using Indotalent.Features.Multitenant.TenantUser;
+using Indotalent.Features.Organization.Branch;
+using Indotalent.Features.Organization.Department;
+using Indotalent.Features.Organization.Designation;
+using Indotalent.Features.Organization.Employee;
+using Indotalent.Features.Payroll.Deduction;
+using Indotalent.Features.Payroll.Grade;
+using Indotalent.Features.Payroll.Income;
+using Indotalent.Features.Payroll.Payrolls;
+using Indotalent.Features.Performance.Appraisal;
+using Indotalent.Features.Performance.Evaluation;
+using Indotalent.Features.Performance.Promotion;
+using Indotalent.Features.Performance.Transfer;
+using Indotalent.Features.Profile.Avatar;
+using Indotalent.Features.Profile.Password;
+using Indotalent.Features.Profile.PersonalInformation;
+using Indotalent.Features.Root.Home;
+using Indotalent.Features.Serilogs;
+using Indotalent.Features.Setting.AutoNumberSequence;
+using Indotalent.Features.Setting.Company;
+using Indotalent.Features.Setting.Currency;
+using Indotalent.Features.Setting.SystemUser;
+using Indotalent.Features.Setting.Tax;
+
+namespace Indotalent.Features;
+
+public static class FeaturesDI
+{
+    public static IServiceCollection AddFeaturesDI(this IServiceCollection services)
+    {
+        //Setting
+        services.AddScoped<SerilogsService>();
+        services.AddScoped<CurrencyService>();
+        services.AddScoped<AutoNumberSequenceService>();
+        services.AddScoped<SystemUserService>();
+        services.AddScoped<CompanyService>();
+        services.AddScoped<TaxService>();
+
+
+        //organization
+        services.AddScoped<BranchService>();
+        services.AddScoped<DepartmentService>();
+        services.AddScoped<DesignationService>();
+        services.AddScoped<EmployeeService>();
+
+        //profile
+        services.AddScoped<PersonalInformationService>();
+        services.AddScoped<PasswordService>();
+        services.AddScoped<AvatarService>();
+
+        //leave
+        services.AddScoped<LeaveCategoryService>();
+        services.AddScoped<LeaveRequestService>();
+        services.AddScoped<LeaveBalanceService>();
+
+        //performance
+        services.AddScoped<EvaluationService>();
+        services.AddScoped<AppraisalService>();
+        services.AddScoped<PromotionService>();
+        services.AddScoped<TransferService>();
+
+        //payroll
+        services.AddScoped<IncomeService>();
+        services.AddScoped<DeductionService>();
+        services.AddScoped<GradeService>();
+        services.AddScoped<PayrollsService>();
+
+        //root
+        services.AddScoped<HomeService>();
+
+        //multitenant
+        services.AddScoped<TenantService>();
+        services.AddScoped<TenantUserService>();
+
+        return services;
+    }
+}

Features/FeaturesEndpointMap.cs

@@ -0,0 +1,80 @@
+using Indotalent.Features.Leave.LeaveBalance;
+using Indotalent.Features.Leave.LeaveCategory;
+using Indotalent.Features.Leave.LeaveRequest;
+using Indotalent.Features.Multitenant.Tenant;
+using Indotalent.Features.Multitenant.TenantUser;
+using Indotalent.Features.Organization.Branch;
+using Indotalent.Features.Organization.Department;
+using Indotalent.Features.Organization.Designation;
+using Indotalent.Features.Organization.Employee;
+using Indotalent.Features.Payroll.Deduction;
+using Indotalent.Features.Payroll.Grade;
+using Indotalent.Features.Payroll.Income;
+using Indotalent.Features.Payroll.Payrolls;
+using Indotalent.Features.Performance.Appraisal;
+using Indotalent.Features.Performance.Evaluation;
+using Indotalent.Features.Performance.Promotion;
+using Indotalent.Features.Performance.Transfer;
+using Indotalent.Features.Profile.Avatar;
+using Indotalent.Features.Profile.Password;
+using Indotalent.Features.Profile.PersonalInformation;
+using Indotalent.Features.Root.Home;
+using Indotalent.Features.Serilogs;
+using Indotalent.Features.Setting.AutoNumberSequence;
+using Indotalent.Features.Setting.Company;
+using Indotalent.Features.Setting.Currency;
+using Indotalent.Features.Setting.SystemUser;
+using Indotalent.Features.Setting.Tax;
+
+namespace Indotalent.Features;
+
+public static class FeaturesEndpointMap
+{
+    public static IEndpointRouteBuilder MapFeaturesEndpoint(this IEndpointRouteBuilder app)
+    {
+        //setting
+        app.MapSerilogsEndpoints();
+        app.MapCurrencyEndpoints();
+        app.MapAutoNumberSequenceEndpoints();
+        app.MapSystemUserEndpoints();
+        app.MapCompanyEndpoints();
+        app.MapTaxEndpoints();
+
+        //organization
+        app.MapBranchEndpoints();
+        app.MapDepartmentEndpoints();
+        app.MapDesignationEndpoints();
+        app.MapEmployeeEndpoints();
+
+        //profile
+        app.MapPersonalInformationEndpoints();
+        app.MapPasswordEndpoints();
+        app.MapAvatarEndpoints();
+
+        //leave
+        app.MapLeaveCategoryEndpoints();
+        app.MapLeaveRequestEndpoints();
+        app.MapLeaveBalanceEndpoints();
+
+        //performance
+        app.MapEvaluationEndpoints();
+        app.MapAppraisalEndpoints();
+        app.MapPromotionEndpoints();
+        app.MapTransferEndpoints();
+
+        //payroll
+        app.MapIncomeEndpoints();
+        app.MapDeductionEndpoints();
+        app.MapGradeEndpoints();
+        app.MapPayrollsEndpoints();
+
+        //root
+        app.MapHomeEndpoints();
+
+        //multitenant
+        app.MapTenantEndpoints();
+        app.MapTenantUserEndpoints();
+
+        return app;
+    }
+}

Features/Leave/LeaveBalance/Components/LeaveBalancePage.razor

@@ -0,0 +1,46 @@
+@page "/leave/leave-balance"
+@using Indotalent.Features.Leave.LeaveBalance.Components
+@using Indotalent.Features.Leave.LeaveBalance.Cqrs
+@using MudBlazor
+
+@if (_currentView == ViewMode.Create)
+{
+    <_LeaveBalanceCreateForm OnCancel="BackToTable" OnSuccess="HandleSuccess" />
+}
+else if (_currentView == ViewMode.Update || _currentView == ViewMode.View)
+{
+    <_LeaveBalanceUpdateForm Data="_selectedData!" ReadOnly="@(_currentView == ViewMode.View)" OnCancel="BackToTable" OnSuccess="HandleSuccess" />
+}
+else
+{
+    <_LeaveBalanceDataTable OnAdd="() => ShowCreate()" OnEdit="(item) => ShowUpdate(item, false)" OnView="(item) => ShowUpdate(item, true)" />
+}
+
+@code {
+    private enum ViewMode { Table, Create, Update, View }
+    private ViewMode _currentView = ViewMode.Table;
+    private UpdateLeaveBalanceRequest? _selectedData;
+
+    private void ShowCreate()
+    {
+        _currentView = ViewMode.Create;
+    }
+
+    private void ShowUpdate(UpdateLeaveBalanceRequest data, bool isReadOnly)
+    {
+        _selectedData = data;
+        _currentView = isReadOnly ? ViewMode.View : ViewMode.Update;
+    }
+
+    private void BackToTable()
+    {
+        _currentView = ViewMode.Table;
+        _selectedData = null;
+    }
+
+    private void HandleSuccess()
+    {
+        _currentView = ViewMode.Table;
+        _selectedData = null;
+    }
+}

Features/Leave/LeaveBalance/Components/_LeaveBalanceCreateForm.razor

@@ -0,0 +1,106 @@
+@using Indotalent.Features.Leave.LeaveBalance
+@using Indotalent.Features.Leave.LeaveBalance.Cqrs
+@using Indotalent.Features.Leave.LeaveRequest.Cqrs 
+@using Indotalent.Features.Leave.LeaveRequest
+@using Indotalent.Features.Leave.LeaveCategory
+@using Indotalent.Features.Leave.LeaveCategory.Cqrs
+@using Indotalent.Shared.Utils
+@using MudBlazor
+@inject LeaveBalanceService LeaveBalanceService
+@inject LeaveRequestService LeaveRequestService
+@inject LeaveCategoryService LeaveCategoryService
+@inject ISnackbar Snackbar
+
+<MudPaper Elevation="0" Square="true" Class="pa-6 mb-3 d-flex align-center justify-space-between" Style="border: 1px solid #DCEBFA;">
+    <div class="d-flex align-center gap-4">
+        <MudIconButton Icon="@Icons.Material.Filled.ArrowBack" OnClick="() => OnCancel.InvokeAsync()" />
+        <div>
+            <MudText Typo="Typo.h5" Style="font-weight: 900; color: #1a1a1a;">Create Leave Balance</MudText>
+            <MudText Typo="Typo.body2" Style="color: #64748b;">Initialize new leave quota for an employee.</MudText>
+        </div>
+    </div>
+</MudPaper>
+
+<MudPaper Elevation="0" Outlined="true" Class="pa-8" Style="border-radius: 0px; border: 1px solid #DCEBFA;">
+    <MudForm @ref="_form" Model="_model">
+        <MudGrid Spacing="3">
+            <MudItem xs="12" sm="6">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Employee</MudText>
+                <MudSelect T="string" @bind-Value="_model.EmployeeId" For="@(() => _model.EmployeeId)" Variant="Variant.Outlined" Margin="Margin.Dense" AnchorOrigin="Origin.BottomLeft" TransformOrigin="Origin.TopLeft">
+                    @foreach (var emp in _employees)
+                    {
+                        <MudSelectItem Value="@emp.Id">@emp.FullName (@emp.Code)</MudSelectItem>
+                    }
+                </MudSelect>
+            </MudItem>
+            <MudItem xs="12" sm="6">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Leave Type</MudText>
+                <MudSelect T="string" @bind-Value="_model.LeaveCategoryId" For="@(() => _model.LeaveCategoryId)" Variant="Variant.Outlined" Margin="Margin.Dense" AnchorOrigin="Origin.BottomLeft" TransformOrigin="Origin.TopLeft">
+                    @foreach (var cat in _categories)
+                    {
+                        <MudSelectItem Value="@cat.Id">@cat.Name</MudSelectItem>
+                    }
+                </MudSelect>
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Year</MudText>
+                <MudNumericField @bind-Value="_model.Year" Variant="Variant.Outlined" Margin="Margin.Dense" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Entitlement (Quota)</MudText>
+                <MudNumericField @bind-Value="_model.Entitlement" Variant="Variant.Outlined" Margin="Margin.Dense" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Carry Forward</MudText>
+                <MudNumericField @bind-Value="_model.CarryForward" Variant="Variant.Outlined" Margin="Margin.Dense" />
+            </MudItem>
+            <MudItem xs="12" sm="6">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Valid From</MudText>
+                <MudDatePicker @bind-Date="_validFrom" Variant="Variant.Outlined" Margin="Margin.Dense" />
+            </MudItem>
+            <MudItem xs="12" sm="6">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Valid To</MudText>
+                <MudDatePicker @bind-Date="_validTo" Variant="Variant.Outlined" Margin="Margin.Dense" />
+            </MudItem>
+        </MudGrid>
+        <div class="d-flex justify-end gap-2 mt-8">
+            <MudButton OnClick="() => OnCancel.InvokeAsync()" Variant="Variant.Outlined" Disabled="_processing" Style="border: 1px solid #e0e0e0;">Cancel</MudButton>
+            <MudButton Color="Color.Warning" Variant="Variant.Filled" OnClick="Submit" Disabled="_processing" Style="color:white; font-weight:700;">Create Balance</MudButton>
+        </div>
+    </MudForm>
+</MudPaper>
+
+@code {
+    [Parameter] public EventCallback OnCancel { get; set; }
+    [Parameter] public EventCallback OnSuccess { get; set; }
+    private MudForm _form = default!;
+    private CreateLeaveBalanceValidator _validator = new();
+    private CreateLeaveBalanceRequest _model = new() { Year = DateTime.Today.Year, ValidFrom = new DateTime(DateTime.Today.Year, 1, 1), ValidTo = new DateTime(DateTime.Today.Year, 12, 31) };
+    private List<EmployeeLeaveReferenceResponse> _employees = new();
+    private List<GetLeaveCategoryListResponse> _categories = new();
+    private bool _processing = false;
+    private DateTime? _validFrom { get => _model.ValidFrom; set => _model.ValidFrom = value ?? DateTime.Today; }
+    private DateTime? _validTo { get => _model.ValidTo; set => _model.ValidTo = value ?? DateTime.Today; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        var empRes = await LeaveRequestService.GetEmployeeReferenceAsync();
+        if (empRes?.IsSuccess == true) _employees = empRes.Value ?? new();
+        var catRes = await LeaveCategoryService.GetLeaveCategoryListAsync();
+        if (catRes?.IsSuccess == true) _categories = catRes.Value ?? new();
+    }
+
+    private async Task Submit()
+    {
+        await _form.Validate(); if (!_form.IsValid) return;
+        _processing = true;
+        try
+        {
+            _model.Remaining = (_model.Entitlement + _model.CarryForward) - _model.Used;
+            var res = await LeaveBalanceService.CreateLeaveBalanceAsync(_model);
+            await Task.Delay(500);
+            if (res?.IsSuccess == true) { Snackbar.Add("Balance created", Severity.Success); await OnSuccess.InvokeAsync(); }
+        }
+        finally { _processing = false; }
+    }
+}

Features/Leave/LeaveBalance/Components/_LeaveBalanceDataTable.razor

@@ -0,0 +1,447 @@
+@using Indotalent.ConfigBackEnd.Extensions
+@using Indotalent.Features.Leave.LeaveBalance
+@using Indotalent.Features.Leave.LeaveBalance.Cqrs
+@using Microsoft.AspNetCore.Components.Web
+@using Microsoft.JSInterop
+@using MudBlazor
+@using Features.Root.Shared
+@using ClosedXML.Excel
+@using System.IO
+@inject LeaveBalanceService LeaveBalanceService
+@inject IDialogService DialogService
+@inject ISnackbar Snackbar
+@inject IJSRuntime JSRuntime
+
+<MudPaper Elevation="0" Square="true" Class="pa-6 mb-3 d-flex align-center justify-space-between" Style="border: 1px solid #E5E7EB; border-radius: 12px;">
+    <div>
+        <MudText Typo="Typo.h5" Style="font-weight: 700; color: #111827;">Leave Balances</MudText>
+        <MudText Typo="Typo.body2" Style="color: #9CA3AF;">Review employee leave entitlements, usage, and remaining days for the current period.</MudText>
+    </div>
+    <div class="d-flex align-center gap-2">
+        <MudIcon Icon="@Icons.Material.Filled.Home" Size="Size.Small" Color="Color.Default" />
+        <MudText Typo="Typo.caption" Style="color: #9CA3AF;">/</MudText>
+        <MudText Typo="Typo.caption" Style="color: #9CA3AF;">Leave</MudText>
+        <MudText Typo="Typo.caption" Style="color: #9CA3AF;">/</MudText>
+        <MudText Typo="Typo.caption" Style="font-weight: 600; color: #111827;">Balance</MudText>
+    </div>
+</MudPaper>
+
+<MudPaper Elevation="0" Outlined="true" Style="border-radius: 12px; overflow: hidden; background-color: #ffffff; border: 1px solid #E5E7EB;">
+
+    <div style="padding: 20px 24px; border-bottom: 1px solid #E5E7EB; display: flex; justify-content: space-between; align-items: center; background-color: #F8FAFC; min-height: 80px;">
+        
+        <div style="display: flex; align-items: center; gap: 8px;">
+            <MudTextField @bind-Value="_searchString" 
+                          Placeholder="Search..." 
+                          Adornment="Adornment.Start" 
+                          AdornmentIcon="@Icons.Material.Filled.Search" 
+                          IconSize="Size.Small" 
+                          Class="mt-0"
+                          Variant="Variant.Outlined"
+                          Margin="Margin.Dense"
+                          Style="background-color: white; width: 280px; border-radius: 8px;"
+                          OnKeyDown="@HandleSearchKeyDown" />
+            
+            <MudButton Variant="Variant.Filled" 
+                       Color="Color.Primary" 
+                       OnClick="OnSearchClick" 
+                       Size="Size.Small" 
+                       Style="text-transform: none; font-weight: 500; border-radius: 6px; height: 34px; box-shadow: none;">
+                Search
+            </MudButton>
+        </div>
+
+        <div style="display: flex; gap: 8px; align-items: center;">
+            <MudButton Variant="Variant.Outlined" 
+                       Color="Color.Success" 
+                       OnClick="ExportToExcel" 
+                       Size="Size.Small" 
+                       Disabled="_isExporting"
+                       StartIcon="@(_isExporting ? null : Icons.Custom.FileFormats.FileExcel)" 
+                       Style="border: 1px solid #D1D5DB; background: white; font-weight: 500; border-radius: 6px; text-transform: none; height: 34px; color: #6B7280;">
+                @if (_isExporting)
+                {
+                    <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+                    <MudText Class="ms-2" Typo="Typo.button" Style="text-transform: none !important;">Processing...</MudText>
+                }
+                else
+                {
+                    <MudText Typo="Typo.button" Style="text-transform: none !important;">Excel</MudText>
+                }
+            </MudButton>
+
+            <MudButton Variant="Variant.Outlined" 
+                       Color="Color.Primary" 
+                       OnClick="LoadData" 
+                       Size="Size.Small" 
+                       StartIcon="@(_isRefreshing ? null : Icons.Material.Filled.Refresh)" 
+                       Disabled="_isRefreshing" 
+                       Style="border: 1px solid #D1D5DB; background: white; font-weight: 500; border-radius: 6px; text-transform: none; height: 34px; color: #6B7280;">
+                @if (_isRefreshing)
+                {
+                    <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+                    <MudText Class="ms-2" Typo="Typo.button" Style="text-transform: none !important;">Refreshing...</MudText>
+                }
+                else
+                {
+                    <MudText Typo="Typo.button" Style="text-transform: none !important;">Refresh</MudText>
+                }
+            </MudButton>
+
+            @if (_selectedBalance != null)
+            {
+                <MudButton Variant="Variant.Outlined" Color="Color.Info" StartIcon="@Icons.Material.Filled.Visibility" OnClick="InvokeView" Size="Size.Small" Style="border: 1px solid #D1D5DB; text-transform: none; font-weight: 500; border-radius: 6px; background: white; color: #6B7280;">View</MudButton>
+                <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.Edit" OnClick="InvokeEdit" Size="Size.Small" Style="text-transform: none; font-weight: 500; border-radius: 6px;">Adjust Balance</MudButton>
+                <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small" OnClick="OnDelete" />
+                <MudIconButton Icon="@Icons.Material.Filled.Close" Size="Size.Small" OnClick="() => _selectedBalance = null" />
+            }
+            else
+            {
+                <MudButton Variant="Variant.Filled" Color="Color.Info" StartIcon="@Icons.Material.Filled.Calculate" OnClick="OnSyncAll" Size="Size.Small" Style="text-transform: none; font-weight: 500; border-radius: 6px; height: 34px;">
+                    Recalculate All
+                </MudButton>
+                <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add" OnClick="() => OnAdd.InvokeAsync()" Size="Size.Small" Style="text-transform: none; font-weight: 500; border-radius: 6px; height: 34px;">
+                    Create Manual Balance
+                </MudButton>
+            }
+        </div>
+    </div>
+
+    <MudTable Items="@GetPagedData()" Hover="true" Striped="true" Class="mud-table-styled" Elevation="0" CustomHeader="true" Dense="true" T="GetLeaveBalanceListResponse" OnRowClick="@((args) => _selectedBalance = args.Item)" Loading="@_isRefreshing">
+        <HeaderContent>
+            <MudTh Style="width: 50px; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB;"></MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; white-space: nowrap;">
+                <MudTableSortLabel SortBy="new Func<GetLeaveBalanceListResponse, object>(x => x.EmployeeName!)">Employee</MudTableSortLabel>
+            </MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; white-space: nowrap;">
+                <MudTableSortLabel SortBy="new Func<GetLeaveBalanceListResponse, object>(x => x.LeaveCategoryName!)">Leave Type</MudTableSortLabel>
+            </MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; white-space: nowrap;">
+                <MudTableSortLabel SortBy="new Func<GetLeaveBalanceListResponse, object>(x => x.Year)">Year</MudTableSortLabel>
+            </MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; text-align: center;">ENTITLEMENT</MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; text-align: center;">USED</MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; text-align: center;">PENDING</MudTh>
+            <MudTh Style="font-weight: 600; color: #6B7280; text-transform: uppercase; font-size: 0.6875rem; letter-spacing: 0.05em; background-color: #F9FAFB; border-bottom: 1px solid #E5E7EB; text-align: center;">REMAINING</MudTh>
+        </HeaderContent>
+        <RowTemplate>
+            <MudTd>
+                <MudCheckBox T="bool" Value="@(_selectedBalance?.Id == context.Id)" Color="Color.Primary" Dense="true" Size="Size.Small" ReadOnly="true" />
+            </MudTd>
+            <MudTd>
+                <div class="d-flex align-center">
+                    <MudAvatar Color="@GetRandomColor(context.EmployeeName!)" Size="Size.Small" Class="mr-3" Style="font-weight: 600; font-size: 0.7rem;">
+                        @(!string.IsNullOrWhiteSpace(context.EmployeeName) ? context.EmployeeName.Substring(0, 2).ToUpper() : "??")
+                    </MudAvatar>
+                    <div>
+                        <MudText Typo="Typo.body2" Style="font-weight: 700;">@context.EmployeeName</MudText>
+                        <MudText Typo="Typo.caption" Style="color: #9CA3AF;">@context.EmployeeCode</MudText>
+                    </div>
+                </div>
+            </MudTd>
+            <MudTd>
+                <MudText Typo="Typo.body2" Style="font-size: 0.8rem;">@context.LeaveCategoryName</MudText>
+            </MudTd>
+            <MudTd>
+                <MudText Typo="Typo.body2" Style="font-weight: 600;">@context.Year</MudText>
+            </MudTd>
+            <MudTd Style="text-align: center;">
+                <MudText Typo="Typo.body2" Style="font-weight: 600;">@context.Entitlement Days</MudText>
+            </MudTd>
+            <MudTd Style="text-align: center;">
+                <MudText Typo="Typo.body2" Style="color: #ef4444; font-weight: 600;">@context.Used</MudText>
+            </MudTd>
+            <MudTd Style="text-align: center;">
+                <MudText Typo="Typo.body2" Style="color: #f59e0b; font-weight: 600;">@context.Pending</MudText>
+            </MudTd>
+            <MudTd Style="text-align: center;">
+                <MudChip T="string" Size="Size.Small" Variant="Variant.Filled" Color="Color.Success" Style="font-weight: 700; border-radius: 6px; min-width: 60px;">
+                    @context.Remaining
+                </MudChip>
+            </MudTd>
+        </RowTemplate>
+    </MudTable>
+
+    <div style="display: flex; justify-content: space-between; align-items: center; padding: 12px 24px; background-color: #F8FAFC; border-top: 2px solid #E5E7EB;">
+        <div style="display: flex; align-items: center; gap: 12px;">
+            <MudText Typo="Typo.caption" Style="font-weight: 700; color: #1e293b;">Rows per page:</MudText>
+            
+            <MudSelect T="int" 
+                       Value="@_top" 
+                       ValueChanged="OnPageSizeChanged" 
+                       Dense="true" 
+                       Margin="Margin.Dense" 
+                       Style="width: 80px; background-color: white; font-size: 0.75rem; font-weight: 500;" 
+                       Variant="Variant.Outlined"
+                       Class="mt-0 custom-select-dense">
+                <MudSelectItem Value="5" />
+                <MudSelectItem Value="10" />
+                <MudSelectItem Value="50" />
+                <MudSelectItem Value="500" />
+                <MudSelectItem Value="1000" />
+            </MudSelect>
+
+            <MudText Typo="Typo.caption" Style="color: #64748b; margin-left: 12px;">
+                Showing @(GetFilteredData().Count() == 0 ? 0 : _skip + 1)-@Math.Min(_skip + _top, GetFilteredData().Count()) of @GetFilteredData().Count()
+            </MudText>
+        </div>
+
+        <div style="display: flex; gap: 8px; align-items: center;">
+            <MudIconButton Icon="@Icons.Material.Filled.FirstPage" Size="Size.Small" OnClick="@(() => OnPageChanged(1))" Disabled="@(_currentPage == 1)" Style="@(_currentPage == 1 ? "color: #D1D5DB; background: transparent;" : "color: #6B7280; background: white; border: 1px solid #D1D5DB; border-radius: 6px;")"  />
+            <MudButton OnClick="@(() => OnPageChanged(_currentPage - 1))" Disabled="@(_currentPage == 1)" Variant="Variant.Text" StartIcon="@Icons.Material.Filled.ChevronLeft" Size="Size.Small" Style="@(_currentPage == 1 ? "text-transform: none; font-weight: 500; background: white; border: 1px solid #D1D5DB; border-radius: 6px; height: 34px; color: #6B7280;" : "text-transform: none; font-weight: 500; background: white; border: 1px solid #D1D5DB; border-radius: 6px; height: 34px; color: #6B7280;")">Prev</MudButton>
+            @{
+    var totalPages = _totalPage == 0 ? 1 : _totalPage;
+    var maxVisible = 5;
+    var startPage = Math.Max(1, _currentPage - maxVisible / 2);
+    var endPage = Math.Min(totalPages, startPage + maxVisible - 1);
+    if (endPage - startPage < maxVisible - 1) { startPage = Math.Max(1, endPage - maxVisible + 1); }
+}
+@for (int i = startPage; i <= endPage; i++)
+{
+    var pageNum = i;
+    var isActive = pageNum == _currentPage;
+    <MudButton OnClick="@(() => OnPageChanged(pageNum))"
+               Variant="Variant.Text" Size="Size.Small"
+               Style="@(isActive ? "min-width: 34px; padding: 4px 8px; font-size: 0.75rem; font-weight: 600; background: #3B82F6; color: white; border: 1px solid #3B82F6; border-radius: 6px; text-transform: none;" : "min-width: 34px; padding: 4px 8px; font-size: 0.75rem; font-weight: 500; color: #374151; background: white; border: 1px solid #D1D5DB; border-radius: 6px; text-transform: none;")">@pageNum</MudButton>
+}
+            <MudButton OnClick="@(() => OnPageChanged(_currentPage + 1))" Disabled="@(_currentPage == _totalPage || _totalPage == 0)" Variant="Variant.Text" EndIcon="@Icons.Material.Filled.ChevronRight" Size="Size.Small" Style="@(_currentPage == _totalPage || _totalPage == 0 ? "text-transform: none; font-weight: 500; background: white; border: 1px solid #D1D5DB; border-radius: 6px; height: 34px; color: #6B7280;" : "text-transform: none; font-weight: 500; background: white; border: 1px solid #D1D5DB; border-radius: 6px; height: 34px; color: #6B7280;")">Next</MudButton>
+            <MudIconButton Icon="@Icons.Material.Filled.LastPage" Size="Size.Small" OnClick="@(() => OnPageChanged(_totalPage))" Disabled="@(_currentPage == _totalPage || _totalPage == 0)" Style="@(_currentPage == _totalPage || _totalPage == 0 ? "color: #D1D5DB; background: transparent;" : "color: #6B7280; background: white; border: 1px solid #D1D5DB; border-radius: 6px;")"  />
+        </div>
+    </div>
+</MudPaper>
+
+<script>
+    function downloadFile(fileName, contentType, base64String) {
+        const link = document.createElement('a');
+        link.download = fileName;
+        link.href = `data:${contentType};base64,${base64String}`;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+</script>
+
+<style>
+    .mud-input-outlined-border { border-radius: 8px !important; }
+    .custom-select-dense .mud-input-control { margin-top: 0 !important; }
+    .custom-select-dense .mud-input-slot { padding-top: 4px !important; padding-bottom: 4px !important; padding-left: 8px !important; font-size: 12px !important; }
+.mud-table-styled .mud-table-row:hover { background-color: #F9FAFB !important; }
+</style>
+
+@code {
+    [Parameter] public EventCallback OnAdd { get; set; }
+    [Parameter] public EventCallback<UpdateLeaveBalanceRequest> OnEdit { get; set; }
+    [Parameter] public EventCallback<UpdateLeaveBalanceRequest> OnView { get; set; }
+
+    private List<GetLeaveBalanceListResponse> _balances = new();
+    private GetLeaveBalanceListResponse? _selectedBalance;
+    private string _searchString = "";
+    private int _skip = 0;
+    private int _top = 5;
+    private int _totalPage => GetFilteredData().Count() == 0 ? 0 : (int)Math.Ceiling((double)GetFilteredData().Count() / (_top == 0 ? 1 : _top));
+    private int _currentPage => (_top >= GetFilteredData().Count() || _top == 0) ? 1 : (_skip / _top) + 1;
+    private bool _isRefreshing = false;
+    private bool _isExporting = false;
+
+    protected override async Task OnInitializedAsync() => await LoadData();
+
+    private async Task LoadData()
+    {
+        _isRefreshing = true; _selectedBalance = null;
+        StateHasChanged();
+        try
+        {
+            var response = await LeaveBalanceService.GetLeaveBalanceListAsync();
+            await Task.Delay(800);
+            if (response != null && response.IsSuccess)
+            {
+                _balances = response.Value ?? new();
+            }
+        }
+        finally
+        {
+            _isRefreshing = false;
+            StateHasChanged();
+        }
+    }
+
+    private IEnumerable<GetLeaveBalanceListResponse> GetFilteredData()
+    {
+        if (string.IsNullOrWhiteSpace(_searchString)) return _balances;
+        return _balances.Where(x => 
+            (x.EmployeeName?.Contains(_searchString, StringComparison.OrdinalIgnoreCase) ?? false) ||
+            (x.EmployeeCode?.Contains(_searchString, StringComparison.OrdinalIgnoreCase) ?? false) ||
+            (x.LeaveCategoryName?.Contains(_searchString, StringComparison.OrdinalIgnoreCase) ?? false) ||
+            (x.Year.ToString().Contains(_searchString))
+        );
+    }
+
+    private IEnumerable<GetLeaveBalanceListResponse> GetPagedData() => GetFilteredData().Skip(_skip).Take(_top);
+
+    private async Task ExportToExcel()
+    {
+        _isExporting = true;
+        StateHasChanged();
+        try
+        {
+            await Task.Delay(1000);
+            using (var workbook = new XLWorkbook())
+            {
+                var worksheet = workbook.Worksheets.Add("LeaveBalances");
+                var currentRow = 1;
+
+                worksheet.Cell(currentRow, 1).Value = "Employee Name";
+                worksheet.Cell(currentRow, 2).Value = "Employee Code";
+                worksheet.Cell(currentRow, 3).Value = "Leave Type";
+                worksheet.Cell(currentRow, 4).Value = "Year";
+                worksheet.Cell(currentRow, 5).Value = "Entitlement";
+                worksheet.Cell(currentRow, 6).Value = "Used";
+                worksheet.Cell(currentRow, 7).Value = "Pending";
+                worksheet.Cell(currentRow, 8).Value = "Remaining";
+
+                var headerRange = worksheet.Range(1, 1, 1, 8);
+                headerRange.Style.Font.Bold = true;
+                headerRange.Style.Fill.BackgroundColor = XLColor.FromHtml("#0D47A1");
+                headerRange.Style.Font.FontColor = XLColor.White;
+
+                foreach (var item in GetFilteredData())
+                {
+                    currentRow++;
+                    worksheet.Cell(currentRow, 1).Value = item.EmployeeName;
+                    worksheet.Cell(currentRow, 2).Value = item.EmployeeCode;
+                    worksheet.Cell(currentRow, 3).Value = item.LeaveCategoryName;
+                    worksheet.Cell(currentRow, 4).Value = item.Year;
+                    worksheet.Cell(currentRow, 5).Value = item.Entitlement;
+                    worksheet.Cell(currentRow, 6).Value = item.Used;
+                    worksheet.Cell(currentRow, 7).Value = item.Pending;
+                    worksheet.Cell(currentRow, 8).Value = item.Remaining;
+                }
+
+                worksheet.Columns().AdjustToContents();
+
+                using (var stream = new MemoryStream())
+                {
+                    workbook.SaveAs(stream);
+                    var content = Convert.ToBase64String(stream.ToArray());
+                    await JSRuntime.InvokeVoidAsync("downloadFile", "Leave_Balance_Report.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", content);
+                    Snackbar.Add("Excel exported successfully", Severity.Success);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Export failed: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _isExporting = false;
+            StateHasChanged();
+        }
+    }
+
+    private void OnSearchClick()
+    {
+        _skip = 0;
+        _selectedBalance = null;
+        StateHasChanged();
+    }
+
+    private void HandleSearchKeyDown(KeyboardEventArgs e)
+    {
+        if (e.Key == "Enter") OnSearchClick();
+    }
+
+    private void OnPageChanged(int page)
+    {
+        if (page >= 1 && page <= _totalPage)
+        {
+            _skip = (page - 1) * _top;
+            _selectedBalance = null;
+            StateHasChanged();
+        }
+    }
+
+    private void OnPageSizeChanged(int size)
+    {
+        _top = size;
+        _skip = 0;
+        _selectedBalance = null;
+        StateHasChanged();
+    }
+
+    private Color GetRandomColor(string name)
+    {
+        int hash = name.GetHashCode();
+        var colors = new[] { Color.Primary, Color.Secondary, Color.Tertiary, Color.Info, Color.Success, Color.Warning, Color.Dark };
+        return colors[Math.Abs(hash) % colors.Length];
+    }
+
+    private async Task OnSyncAll()
+    {
+        _isRefreshing = true;
+        StateHasChanged();
+        try
+        {
+            var success = await LeaveBalanceService.SyncAllLeaveBalancesAsync();
+            if (success)
+            {
+                Snackbar.Add("All balances recalculated successfully", Severity.Success);
+                await LoadData();
+            }
+        }
+        finally
+        {
+            _isRefreshing = false;
+            StateHasChanged();
+        }
+    }
+
+    private async Task InvokeEdit()
+    {
+        if (_selectedBalance != null)
+        {
+            var res = await LeaveBalanceService.GetLeaveBalanceByIdAsync(_selectedBalance.Id!);
+            if (res?.Value != null) await OnEdit.InvokeAsync(MapToUpdate(res.Value));
+        }
+    }
+
+    private async Task InvokeView()
+    {
+        if (_selectedBalance != null)
+        {
+            var res = await LeaveBalanceService.GetLeaveBalanceByIdAsync(_selectedBalance.Id!);
+            if (res?.Value != null) await OnView.InvokeAsync(MapToUpdate(res.Value));
+        }
+    }
+
+    private UpdateLeaveBalanceRequest MapToUpdate(GetLeaveBalanceByIdResponse d) => new UpdateLeaveBalanceRequest
+    {
+        Id = d.Id,
+        EmployeeId = d.EmployeeId!,
+        EmployeeName = d.EmployeeName,
+        LeaveCategoryId = d.LeaveCategoryId!,
+        LeaveCategoryName = d.LeaveCategoryName,
+        Entitlement = d.Entitlement,
+        Used = d.Used,
+        Pending = d.Pending,
+        Remaining = d.Remaining,
+        Year = d.Year,
+        ValidFrom = d.ValidFrom,
+        ValidTo = d.ValidTo,
+        CarryForward = d.CarryForward,
+        CreatedAt = d.CreatedAt,
+        CreatedBy = d.CreatedBy,
+        UpdatedAt = d.UpdatedAt,
+        UpdatedBy = d.UpdatedBy
+    };
+
+    private async Task OnDelete()
+    {
+        if (_selectedBalance == null) return;
+        var dialog = await DialogService.ShowAsync<Features.Root.Shared._DeleteConfirmation>("", new DialogParameters<Features.Root.Shared._DeleteConfirmation> { { x => x.ContentText, $"Balance for {_selectedBalance.EmployeeName}" } });
+        if (!(await dialog.Result).Canceled)
+        {
+            if (await LeaveBalanceService.DeleteLeaveBalanceByIdAsync(_selectedBalance.Id!)) { await LoadData(); Snackbar.Add("Balance removed", Severity.Success); }
+        }
+    }
+}

Features/Leave/LeaveBalance/Components/_LeaveBalanceUpdateForm.razor

@@ -0,0 +1,198 @@
+@using Indotalent.ConfigBackEnd.Extensions
+@using Indotalent.Features.Leave.LeaveBalance
+@using Indotalent.Features.Leave.LeaveBalance.Cqrs
+@using Indotalent.Features.Leave.LeaveRequest
+@using Indotalent.Features.Leave.LeaveRequest.Cqrs
+@using Indotalent.Features.Leave.LeaveCategory
+@using Indotalent.Features.Leave.LeaveCategory.Cqrs
+@using Indotalent.Shared.Utils
+@using MudBlazor
+@inject LeaveBalanceService LeaveBalanceService
+@inject LeaveRequestService LeaveRequestService
+@inject LeaveCategoryService LeaveCategoryService
+@inject ISnackbar Snackbar
+
+<MudPaper Elevation="0" Square="true" Class="pa-6 mb-3 d-flex align-center justify-space-between" Style="border: 1px solid #DCEBFA;">
+    <div class="d-flex align-center gap-4">
+        <MudIconButton Icon="@Icons.Material.Filled.ArrowBack" OnClick="() => OnCancel.InvokeAsync()" />
+        <div>
+            <MudText Typo="Typo.h5" Style="font-weight: 900; color: #1a1a1a;">@(ReadOnly ? "Balance Details" : "Adjust Balance")</MudText>
+            <MudText Typo="Typo.body2" Style="color: #64748b;">Review or modify employee leave quota for the specified period.</MudText>
+        </div>
+    </div>
+</MudPaper>
+
+<MudPaper Elevation="0" Outlined="true" Class="pa-8" Style="border-radius: 0px; border: 1px solid #DCEBFA;">
+    @if (_isInitialLoading)
+    {
+        <div class="d-flex flex-column align-center justify-center pa-10">
+            <MudProgressCircular Color="Color.Info" Indeterminate="true" Size="Size.Large" />
+            <MudText Typo="Typo.body2" Class="mt-4">Loading balance configuration...</MudText>
+        </div>
+    }
+    else
+    {
+        <MudForm @ref="_form" Model="_model">
+            <MudGrid Spacing="3">
+                <MudItem xs="12" sm="6">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Employee</MudText>
+                    <MudSelect T="string" @bind-Value="_model.EmployeeId"
+                               ReadOnly="ReadOnly"
+                               Variant="Variant.Outlined" Margin="Margin.Dense"
+                               AnchorOrigin="Origin.BottomLeft" TransformOrigin="Origin.TopLeft">
+                        @foreach (var emp in _employees)
+                        {
+                            <MudSelectItem Value="@emp.Id">@emp.FullName (@emp.Code)</MudSelectItem>
+                        }
+                    </MudSelect>
+                </MudItem>
+                <MudItem xs="12" sm="6">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Leave Type</MudText>
+                    <MudSelect T="string" @bind-Value="_model.LeaveCategoryId"
+                               ReadOnly="ReadOnly"
+                               Variant="Variant.Outlined" Margin="Margin.Dense"
+                               AnchorOrigin="Origin.BottomLeft" TransformOrigin="Origin.TopLeft">
+                        @foreach (var cat in _categories)
+                        {
+                            <MudSelectItem Value="@cat.Id">@cat.Name</MudSelectItem>
+                        }
+                    </MudSelect>
+                </MudItem>
+
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Year</MudText>
+                    <MudNumericField @bind-Value="_model.Year" ReadOnly="ReadOnly" Variant="Variant.Outlined" Margin="Margin.Dense" />
+                </MudItem>
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Entitlement (Base Quota)</MudText>
+                    <MudNumericField @bind-Value="_model.Entitlement" ReadOnly="ReadOnly" Variant="Variant.Outlined" Margin="Margin.Dense" />
+                </MudItem>
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Carry Forward</MudText>
+                    <MudNumericField @bind-Value="_model.CarryForward" ReadOnly="ReadOnly" Variant="Variant.Outlined" Margin="Margin.Dense" />
+                </MudItem>
+
+                <MudItem xs="12" sm="6">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Validity Period (From)</MudText>
+                    <MudDatePicker @bind-Date="_validFrom" ReadOnly="ReadOnly" Variant="Variant.Outlined" Margin="Margin.Dense" />
+                </MudItem>
+                <MudItem xs="12" sm="6">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Validity Period (To)</MudText>
+                    <MudDatePicker @bind-Date="_validTo" ReadOnly="ReadOnly" Variant="Variant.Outlined" Margin="Margin.Dense" />
+                </MudItem>
+
+                <MudItem xs="12" Class="mt-4">
+                    <MudText Typo="Typo.button" Color="Color.Info" Style="font-weight: 800;">Calculation Summary</MudText>
+                    <MudDivider Class="mt-2 mb-4" />
+                </MudItem>
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Used (Days)</MudText>
+                    <MudNumericField @bind-Value="_model.Used" ReadOnly="true" Variant="Variant.Filled" Margin="Margin.Dense" />
+                </MudItem>
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Pending (Days)</MudText>
+                    <MudNumericField @bind-Value="_model.Pending" ReadOnly="true" Variant="Variant.Filled" Margin="Margin.Dense" />
+                </MudItem>
+                <MudItem xs="12" sm="4">
+                    <MudText Typo="Typo.subtitle2" Class="mb-1">Remaining Balance</MudText>
+                    <MudNumericField Value="@((_model.Entitlement + _model.CarryForward) - _model.Used - _model.Pending)"
+                                     ReadOnly="true" Variant="Variant.Filled" Margin="Margin.Dense"
+                                     Style="font-weight: 900; color: #2e7d32;" />
+                </MudItem>
+
+                <MudItem xs="12" Class="mt-4">
+                    <MudText Typo="Typo.button" Color="Color.Primary" Style="font-weight: 800;">Audit History</MudText>
+                    <MudDivider Class="mt-2 mb-4" />
+                </MudItem>
+                <MudItem xs="12" sm="6">
+                    <MudGrid Spacing="2">
+                        <MudItem xs="12">
+                            <MudText Typo="Typo.subtitle2" Class="mb-1">Created By</MudText>
+                            <MudText Typo="Typo.body2" Style="color: #1a1a1a; font-weight: 600;">@(!string.IsNullOrEmpty(_model.CreatedBy) ? _model.CreatedBy : "System")</MudText>
+                        </MudItem>
+                        <MudItem xs="12">
+                            <MudText Typo="Typo.subtitle2" Class="mb-1">Updated By</MudText>
+                            <MudText Typo="Typo.body2" Style="color: #1a1a1a; font-weight: 600;">@(!string.IsNullOrEmpty(_model.UpdatedBy) ? _model.UpdatedBy : "-")</MudText>
+                        </MudItem>
+                    </MudGrid>
+                </MudItem>
+                <MudItem xs="12" sm="6">
+                    <MudGrid Spacing="2">
+                        <MudItem xs="12">
+                            <MudText Typo="Typo.subtitle2" Class="mb-1">Created At</MudText>
+                            <MudText Typo="Typo.body2" Style="color: #1a1a1a; font-weight: 600;">@DateTimeExtensions.ToString(_model.CreatedAt)</MudText>
+                        </MudItem>
+                        <MudItem xs="12">
+                            <MudText Typo="Typo.subtitle2" Class="mb-1">Updated At</MudText>
+                            <MudText Typo="Typo.body2" Style="color: #1a1a1a; font-weight: 600;">@DateTimeExtensions.ToString(_model.UpdatedAt)</MudText>
+                        </MudItem>
+                    </MudGrid>
+                </MudItem>
+            </MudGrid>
+
+            <div class="d-flex justify-end gap-2 mt-10">
+                <MudButton OnClick="() => OnCancel.InvokeAsync()" Variant="Variant.Outlined" Disabled="_processing" Style="border: 1px solid #e0e0e0; border-radius: 4px; text-transform: none; font-weight: 700;">@(ReadOnly ? "Back to List" : "Cancel")</MudButton>
+                @if (!ReadOnly)
+                {
+                    <MudButton Color="Color.Info" Variant="Variant.Filled" OnClick="Submit" Disabled="_processing" Style="border-radius: 4px; text-transform: none; font-weight: 700; color: white;">
+                        @if (_processing)
+                        {
+                            <MudProgressCircular Size="Size.Small" Indeterminate="true" />
+                        }
+                        else
+                        {
+                            <MudText>Save Adjustments</MudText>
+                        }
+                    </MudButton>
+                }
+            </div>
+        </MudForm>
+    }
+</MudPaper>
+
+@code {
+    [Parameter] public UpdateLeaveBalanceRequest Data { get; set; } = new();
+    [Parameter] public bool ReadOnly { get; set; } = false;
+    [Parameter] public EventCallback OnCancel { get; set; }
+    [Parameter] public EventCallback OnSuccess { get; set; }
+
+    private MudForm _form = default!;
+    private UpdateLeaveBalanceValidator _validator = new();
+    private UpdateLeaveBalanceRequest _model = new();
+    private List<EmployeeLeaveReferenceResponse> _employees = new();
+    private List<GetLeaveCategoryListResponse> _categories = new();
+    private bool _processing = false;
+    private bool _isInitialLoading = true;
+
+    private DateTime? _validFrom { get => _model.ValidFrom; set => _model.ValidFrom = value ?? DateTime.Today; }
+    private DateTime? _validTo { get => _model.ValidTo; set => _model.ValidTo = value ?? DateTime.Today; }
+
+    protected override async Task OnInitializedAsync()
+    {
+        _isInitialLoading = true;
+        try
+        {
+            _model = Data;
+            var empRes = await LeaveRequestService.GetEmployeeReferenceAsync();
+            if (empRes?.IsSuccess == true) _employees = empRes.Value ?? new();
+            var catRes = await LeaveCategoryService.GetLeaveCategoryListAsync();
+            if (catRes?.IsSuccess == true) _categories = catRes.Value ?? new();
+        }
+        finally { _isInitialLoading = false; }
+    }
+
+    private async Task Submit()
+    {
+        if (ReadOnly) return;
+        await _form.Validate(); if (!_form.IsValid) return;
+        _processing = true;
+        try
+        {
+            _model.Remaining = (_model.Entitlement + _model.CarryForward) - _model.Used - _model.Pending;
+            var response = await LeaveBalanceService.UpdateLeaveBalanceAsync(_model);
+            await Task.Delay(500);
+            if (response?.IsSuccess == true) { Snackbar.Add("Balance adjusted successfully", Severity.Success); await OnSuccess.InvokeAsync(); }
+        }
+        finally { _processing = false; }
+    }
+}

Features/Leave/LeaveBalance/Cqrs/CreateLeaveBalanceHandler.cs

@@ -0,0 +1,81 @@
+using Indotalent.ConfigBackEnd.Exceptions;
+using Indotalent.ConfigBackEnd.Extensions;
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class CreateLeaveBalanceRequest
+{
+    public string EmployeeId { get; set; } = string.Empty;
+    public string LeaveCategoryId { get; set; } = string.Empty;
+    public int Entitlement { get; set; }
+    public int Used { get; set; }
+    public int Pending { get; set; }
+    public int Remaining { get; set; }
+    public int Year { get; set; }
+    public DateTime ValidFrom { get; set; }
+    public DateTime ValidTo { get; set; }
+    public int CarryForward { get; set; }
+}
+
+public class CreateLeaveBalanceResponse
+{
+    public string? Id { get; set; }
+    public string? AutoNumber { get; set; }
+}
+
+public record CreateLeaveBalanceCommand(CreateLeaveBalanceRequest Data) : IRequest<CreateLeaveBalanceResponse>;
+
+public class CreateLeaveBalanceHandler : IRequestHandler<CreateLeaveBalanceCommand, CreateLeaveBalanceResponse>
+{
+    private readonly AppDbContext _context;
+
+    public CreateLeaveBalanceHandler(AppDbContext context) => _context = context;
+
+    public async Task<CreateLeaveBalanceResponse> Handle(CreateLeaveBalanceCommand request, CancellationToken cancellationToken)
+    {
+        var isExists = await _context.LeaveBalance
+            .AnyAsync(x => x.EmployeeId == request.Data.EmployeeId &&
+                           x.LeaveCategoryId == request.Data.LeaveCategoryId &&
+                           x.Year == request.Data.Year, cancellationToken);
+
+        if (isExists)
+        {
+            throw new AlreadyExistsException("Leave Balance", $"{request.Data.EmployeeId} for Year {request.Data.Year}");
+        }
+
+        var entityName = nameof(Data.Entities.LeaveBalance);
+
+        var autoNo = await _context.GenerateAutoNumberAsync(
+            entityName: entityName,
+            prefixTemplate: $"{entityName.ToShortNameConsonant(3)}/{{Year}}/",
+            ct: cancellationToken
+        );
+
+        var entity = new Data.Entities.LeaveBalance
+        {
+            AutoNumber = autoNo,
+            EmployeeId = request.Data.EmployeeId,
+            LeaveCategoryId = request.Data.LeaveCategoryId,
+            Entitlement = request.Data.Entitlement,
+            Used = request.Data.Used,
+            Pending = request.Data.Pending,
+            Remaining = request.Data.Remaining,
+            Year = request.Data.Year,
+            ValidFrom = request.Data.ValidFrom,
+            ValidTo = request.Data.ValidTo,
+            CarryForward = request.Data.CarryForward
+        };
+
+        _context.LeaveBalance.Add(entity);
+        await _context.SaveChangesAsync(cancellationToken);
+
+        return new CreateLeaveBalanceResponse
+        {
+            Id = entity.Id,
+            AutoNumber = entity.AutoNumber
+        };
+    }
+}

Features/Leave/LeaveBalance/Cqrs/CreateLeaveBalanceValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class CreateLeaveBalanceValidator : AbstractValidator<CreateLeaveBalanceRequest>
+{
+    public CreateLeaveBalanceValidator()
+    {
+        RuleFor(x => x.EmployeeId).NotEmpty().WithMessage("Employee is required");
+        RuleFor(x => x.LeaveCategoryId).NotEmpty().WithMessage("Leave Category is required");
+        RuleFor(x => x.Year).GreaterThan(2000);
+        RuleFor(x => x.Entitlement).GreaterThanOrEqualTo(0);
+        RuleFor(x => x.ValidFrom).NotEmpty();
+        RuleFor(x => x.ValidTo).NotEmpty().GreaterThanOrEqualTo(x => x.ValidFrom);
+    }
+}

Features/Leave/LeaveBalance/Cqrs/DeleteLeaveBalanceByIdHandler.cs

@@ -0,0 +1,27 @@
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public record DeleteLeaveBalanceByIdRequest(string Id);
+
+public record DeleteLeaveBalanceByIdCommand(DeleteLeaveBalanceByIdRequest Data) : IRequest<bool>;
+
+public class DeleteLeaveBalanceByIdHandler : IRequestHandler<DeleteLeaveBalanceByIdCommand, bool>
+{
+    private readonly AppDbContext _context;
+
+    public DeleteLeaveBalanceByIdHandler(AppDbContext context) => _context = context;
+
+    public async Task<bool> Handle(DeleteLeaveBalanceByIdCommand request, CancellationToken cancellationToken)
+    {
+        var entity = await _context.LeaveBalance
+            .FirstOrDefaultAsync(x => x.Id == request.Data.Id, cancellationToken);
+
+        if (entity == null) return false;
+
+        _context.LeaveBalance.Remove(entity);
+        return await _context.SaveChangesAsync(cancellationToken) > 0;
+    }
+}

Features/Leave/LeaveBalance/Cqrs/GetLeaveBalanceByIdHandler.cs

@@ -0,0 +1,67 @@
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class GetLeaveBalanceByIdResponse
+{
+    public string? Id { get; set; }
+    public string? AutoNumber { get; set; }
+    public string? EmployeeId { get; set; }
+    public string? EmployeeName { get; set; }
+    public string? LeaveCategoryId { get; set; }
+    public string? LeaveCategoryName { get; set; }
+    public int Entitlement { get; set; }
+    public int Used { get; set; }
+    public int Pending { get; set; }
+    public int Remaining { get; set; }
+    public int Year { get; set; }
+    public DateTime ValidFrom { get; set; }
+    public DateTime ValidTo { get; set; }
+    public int CarryForward { get; set; }
+    public DateTimeOffset? CreatedAt { get; set; }
+    public string? CreatedBy { get; set; }
+    public DateTimeOffset? UpdatedAt { get; set; }
+    public string? UpdatedBy { get; set; }
+}
+
+public record GetLeaveBalanceByIdQuery(string Id) : IRequest<GetLeaveBalanceByIdResponse?>;
+
+public class GetLeaveBalanceByIdHandler : IRequestHandler<GetLeaveBalanceByIdQuery, GetLeaveBalanceByIdResponse?>
+{
+    private readonly AppDbContext _context;
+
+    public GetLeaveBalanceByIdHandler(AppDbContext context) => _context = context;
+
+    public async Task<GetLeaveBalanceByIdResponse?> Handle(GetLeaveBalanceByIdQuery request, CancellationToken cancellationToken)
+    {
+        return await _context.LeaveBalance
+            .AsNoTracking()
+            .Include(x => x.Employee)
+            .Include(x => x.LeaveCategory)
+            .Where(x => x.Id == request.Id)
+            .Select(x => new GetLeaveBalanceByIdResponse
+            {
+                Id = x.Id,
+                AutoNumber = x.AutoNumber,
+                EmployeeId = x.EmployeeId,
+                EmployeeName = x.Employee != null ? $"{x.Employee.FirstName} {x.Employee.LastName}" : string.Empty,
+                LeaveCategoryId = x.LeaveCategoryId,
+                LeaveCategoryName = x.LeaveCategory != null ? x.LeaveCategory.Name : string.Empty,
+                Entitlement = x.Entitlement,
+                Used = x.Used,
+                Pending = x.Pending,
+                Remaining = x.Remaining,
+                Year = x.Year,
+                ValidFrom = x.ValidFrom,
+                ValidTo = x.ValidTo,
+                CarryForward = x.CarryForward,
+                CreatedAt = x.CreatedAt,
+                CreatedBy = x.CreatedBy,
+                UpdatedAt = x.UpdatedAt,
+                UpdatedBy = x.UpdatedBy
+            })
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+}

Features/Leave/LeaveBalance/Cqrs/GetLeaveBalanceListHandler.cs

@@ -0,0 +1,58 @@
+using Indotalent.ConfigBackEnd.Extensions;
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class GetLeaveBalanceListResponse
+{
+    public string? Id { get; set; }
+    public string? AutoNumber { get; set; }
+    public string? EmployeeId { get; set; }
+    public string? EmployeeName { get; set; }
+    public string? EmployeeCode { get; set; }
+    public string? LeaveCategoryId { get; set; }
+    public string? LeaveCategoryName { get; set; }
+    public int Entitlement { get; set; }
+    public int Used { get; set; }
+    public int Pending { get; set; }
+    public int Remaining { get; set; }
+    public int Year { get; set; }
+}
+
+public record GetLeaveBalanceListQuery() : IRequest<List<GetLeaveBalanceListResponse>>;
+
+public class GetLeaveBalanceListHandler : IRequestHandler<GetLeaveBalanceListQuery, List<GetLeaveBalanceListResponse>>
+{
+    private readonly AppDbContext _context;
+
+    public GetLeaveBalanceListHandler(AppDbContext context) => _context = context;
+
+    public async Task<List<GetLeaveBalanceListResponse>> Handle(GetLeaveBalanceListQuery request, CancellationToken cancellationToken)
+    {
+        return await _context.LeaveBalance
+            .AsNoTracking()
+            .NotDeletedOnly()
+            .Include(x => x.Employee)
+            .Include(x => x.LeaveCategory)
+            .OrderByDescending(x => x.Year)
+            .ThenBy(x => x.Employee!.FirstName)
+            .Select(x => new GetLeaveBalanceListResponse
+            {
+                Id = x.Id,
+                AutoNumber = x.AutoNumber,
+                EmployeeId = x.EmployeeId,
+                EmployeeName = x.Employee != null ? $"{x.Employee.FirstName} {x.Employee.LastName}" : string.Empty,
+                EmployeeCode = x.Employee != null ? $"{x.Employee.Code}" : string.Empty,
+                LeaveCategoryId = x.LeaveCategoryId,
+                LeaveCategoryName = x.LeaveCategory != null ? x.LeaveCategory.Name : string.Empty,
+                Entitlement = x.Entitlement,
+                Used = x.Used,
+                Pending = x.Pending,
+                Remaining = x.Remaining,
+                Year = x.Year
+            })
+            .ToListAsync(cancellationToken);
+    }
+}

Features/Leave/LeaveBalance/Cqrs/SyncLeaveBalanceHandler.cs

@@ -0,0 +1,40 @@
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public record SyncLeaveBalanceCommand() : IRequest<bool>;
+
+public class SyncLeaveBalanceHandler : IRequestHandler<SyncLeaveBalanceCommand, bool>
+{
+    private readonly AppDbContext _context;
+
+    public SyncLeaveBalanceHandler(AppDbContext context) => _context = context;
+
+    public async Task<bool> Handle(SyncLeaveBalanceCommand request, CancellationToken cancellationToken)
+    {
+        var balances = await _context.LeaveBalance.ToListAsync(cancellationToken);
+
+        if (!balances.Any()) return true;
+
+        var allRequests = await _context.LeaveRequest
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+
+        foreach (var balance in balances)
+        {
+            var empRequests = allRequests
+                .Where(x => x.EmployeeId == balance.EmployeeId &&
+                            x.LeaveCategoryId == balance.LeaveCategoryId &&
+                            x.StartDate.Year == balance.Year)
+                .ToList();
+
+            balance.Used = (int)empRequests.Where(x => x.Status == "Approved").Sum(x => x.Days);
+            balance.Pending = (int)empRequests.Where(x => x.Status == "Pending").Sum(x => x.Days);
+            balance.Remaining = (balance.Entitlement + balance.CarryForward) - balance.Used;
+        }
+
+        return await _context.SaveChangesAsync(cancellationToken) > 0;
+    }
+}

Features/Leave/LeaveBalance/Cqrs/UpdateLeaveBalanceHandler.cs

@@ -0,0 +1,61 @@
+using Indotalent.Infrastructure.Database;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class UpdateLeaveBalanceRequest : CreateLeaveBalanceRequest
+{
+    public string? Id { get; set; }
+    public string? EmployeeName { get; set; }
+    public string? LeaveCategoryName { get; set; }
+    public DateTimeOffset? CreatedAt { get; set; }
+    public string? CreatedBy { get; set; }
+    public DateTimeOffset? UpdatedAt { get; set; }
+    public string? UpdatedBy { get; set; }
+}
+
+public class UpdateLeaveBalanceResponse
+{
+    public string? Id { get; set; }
+    public bool Success { get; set; }
+}
+
+public record UpdateLeaveBalanceCommand(UpdateLeaveBalanceRequest Data) : IRequest<UpdateLeaveBalanceResponse>;
+
+public class UpdateLeaveBalanceHandler : IRequestHandler<UpdateLeaveBalanceCommand, UpdateLeaveBalanceResponse>
+{
+    private readonly AppDbContext _context;
+
+    public UpdateLeaveBalanceHandler(AppDbContext context) => _context = context;
+
+    public async Task<UpdateLeaveBalanceResponse> Handle(UpdateLeaveBalanceCommand request, CancellationToken cancellationToken)
+    {
+        var entity = await _context.LeaveBalance
+            .FirstOrDefaultAsync(x => x.Id == request.Data.Id, cancellationToken);
+
+        if (entity == null)
+        {
+            return new UpdateLeaveBalanceResponse { Id = request.Data.Id, Success = false };
+        }
+
+        entity.EmployeeId = request.Data.EmployeeId;
+        entity.LeaveCategoryId = request.Data.LeaveCategoryId;
+        entity.Entitlement = request.Data.Entitlement;
+        entity.Used = request.Data.Used;
+        entity.Pending = request.Data.Pending;
+        entity.Remaining = request.Data.Remaining;
+        entity.Year = request.Data.Year;
+        entity.ValidFrom = request.Data.ValidFrom;
+        entity.ValidTo = request.Data.ValidTo;
+        entity.CarryForward = request.Data.CarryForward;
+
+        await _context.SaveChangesAsync(cancellationToken);
+
+        return new UpdateLeaveBalanceResponse
+        {
+            Id = entity.Id,
+            Success = true
+        };
+    }
+}

Features/Leave/LeaveBalance/Cqrs/UpdateLeaveBalanceValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace Indotalent.Features.Leave.LeaveBalance.Cqrs;
+
+public class UpdateLeaveBalanceValidator : AbstractValidator<UpdateLeaveBalanceRequest>
+{
+    public UpdateLeaveBalanceValidator()
+    {
+        RuleFor(x => x.Id).NotEmpty().WithMessage("ID is required for update");
+        RuleFor(x => x.EmployeeId).NotEmpty().WithMessage("Employee is required");
+        RuleFor(x => x.LeaveCategoryId).NotEmpty().WithMessage("Leave Category is required");
+        RuleFor(x => x.Year).GreaterThan(2000);
+        RuleFor(x => x.Entitlement).GreaterThanOrEqualTo(0);
+    }
+}

Features/Leave/LeaveBalance/LeaveBalanceEndpoint.cs

@@ -0,0 +1,62 @@
+using Indotalent.ConfigBackEnd.Extensions;
+using Indotalent.Features.Leave.LeaveBalance.Cqrs;
+using MediatR;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+
+namespace Indotalent.Features.Leave.LeaveBalance;
+
+public static class LeaveBalanceEndpoint
+{
+    public static void MapLeaveBalanceEndpoints(this IEndpointRouteBuilder app)
+    {
+        var group = app.MapGroup("/leave-balance").WithTags("Leave Balances")
+            .RequireAuthorization(policy => policy.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme)
+            .RequireAuthenticatedUser());
+
+        group.MapGet("/", async (IMediator mediator) =>
+        {
+            var result = await mediator.Send(new GetLeaveBalanceListQuery());
+            return result.ToApiResponse("Data leave balance retrieved successfully");
+        })
+        .WithName("GetLeaveBalanceList");
+
+        group.MapGet("/{id}", async (string id, IMediator mediator) =>
+        {
+            var result = await mediator.Send(new GetLeaveBalanceByIdQuery(id));
+            return result.ToApiResponse(result is not null
+                ? "Leave balance detail retrieved successfully"
+                : $"Leave balance with ID {id} not found");
+        })
+        .WithName("GetLeaveBalanceById");
+
+        group.MapPost("/", async (CreateLeaveBalanceRequest request, IMediator mediator) =>
+        {
+            var result = await mediator.Send(new CreateLeaveBalanceCommand(request));
+            return result.ToApiResponse("Leave balance has been created successfully", StatusCodes.Status201Created);
+        })
+        .WithName("CreateLeaveBalance");
+
+        group.MapPost("/update", async (UpdateLeaveBalanceRequest request, IMediator mediator) =>
+        {
+            var result = await mediator.Send(new UpdateLeaveBalanceCommand(request));
+            if (!result.Success) return ((object?)null).ToApiResponse("Update failed.");
+            return result.ToApiResponse("Leave balance has been updated successfully");
+        })
+        .WithName("UpdateLeaveBalance");
+
+        group.MapPost("/sync", async (IMediator mediator) =>
+        {
+            var result = await mediator.Send(new SyncLeaveBalanceCommand());
+            return result.ToApiResponse("All leave balances recalculated successfully");
+        })
+        .WithName("SyncLeaveBalance");
+
+        group.MapPost("/delete/{id}", async (string id, IMediator mediator) =>
+        {
+            var result = await mediator.Send(new DeleteLeaveBalanceByIdCommand(new DeleteLeaveBalanceByIdRequest(id)));
+            if (!result) return ((object?)null).ToApiResponse("Delete failed.");
+            return true.ToApiResponse("Leave balance has been deleted successfully");
+        })
+        .WithName("DeleteLeaveBalanceById");
+    }
+}

Features/Leave/LeaveBalance/LeaveBalanceService.cs

@@ -0,0 +1,61 @@
+using Indotalent.ConfigBackEnd.Interfaces;
+using Indotalent.ConfigFrontEnd.Common;
+using Indotalent.Features.Leave.LeaveBalance.Cqrs;
+using Indotalent.Infrastructure.Authentication.Identity;
+using Indotalent.Shared.Models;
+using Microsoft.AspNetCore.Components;
+using MudBlazor;
+using RestSharp;
+
+namespace Indotalent.Features.Leave.LeaveBalance;
+
+public class LeaveBalanceService : BaseService
+{
+    private readonly RestClient _client;
+
+    public LeaveBalanceService(IHttpClientFactory clientFactory, NavigationManager nav, ISnackbar snackbar, ICurrentUserService currentUserService, TokenProvider tokenProvider)
+            : base(clientFactory, nav, snackbar, currentUserService, tokenProvider)
+    {
+        _client = new RestClient(nav.BaseUri);
+    }
+
+    public async Task<ApiResponse<List<GetLeaveBalanceListResponse>>?> GetLeaveBalanceListAsync()
+    {
+        var request = new RestRequest("api/leave-balance", Method.Get);
+        return await ExecuteWithResponseAsync<List<GetLeaveBalanceListResponse>>(_client, request);
+    }
+
+    public async Task<ApiResponse<GetLeaveBalanceByIdResponse>?> GetLeaveBalanceByIdAsync(string id)
+    {
+        var request = new RestRequest($"api/leave-balance/{id}", Method.Get);
+        return await ExecuteWithResponseAsync<GetLeaveBalanceByIdResponse>(_client, request);
+    }
+
+    public async Task<ApiResponse<CreateLeaveBalanceResponse>?> CreateLeaveBalanceAsync(CreateLeaveBalanceRequest data)
+    {
+        var request = new RestRequest("api/leave-balance", Method.Post);
+        request.AddJsonBody(data);
+        return await ExecuteWithResponseAsync<CreateLeaveBalanceResponse>(_client, request);
+    }
+
+    public async Task<ApiResponse<UpdateLeaveBalanceResponse>?> UpdateLeaveBalanceAsync(UpdateLeaveBalanceRequest data)
+    {
+        var request = new RestRequest("api/leave-balance/update", Method.Post);
+        request.AddJsonBody(data);
+        return await ExecuteWithResponseAsync<UpdateLeaveBalanceResponse>(_client, request);
+    }
+
+    public async Task<bool> SyncAllLeaveBalancesAsync()
+    {
+        var request = new RestRequest("api/leave-balance/sync", Method.Post);
+        var response = await ExecuteWithResponseAsync<object>(_client, request);
+        return response?.IsSuccess ?? false;
+    }
+
+    public async Task<bool> DeleteLeaveBalanceByIdAsync(string id)
+    {
+        var request = new RestRequest($"api/leave-balance/delete/{id}", Method.Post);
+        var response = await ExecuteWithResponseAsync<object>(_client, request);
+        return response?.IsSuccess ?? false;
+    }
+}

Features/Leave/LeaveCategory/Components/LeaveCategoryPage.razor

@@ -0,0 +1,35 @@
+@page "/leave/leave-category"
+@using Indotalent.Features.Leave.LeaveCategory.Components
+@using Indotalent.Features.Leave.LeaveCategory.Cqrs
+@using MudBlazor
+
+@if (_currentView == ViewMode.Create)
+{
+    <_LeaveCategoryCreateForm OnCancel="BackToTable" OnSuccess="HandleSuccess" />
+}
+else if (_currentView == ViewMode.Update || _currentView == ViewMode.View)
+{
+    <_LeaveCategoryUpdateForm Data="_selectedData!" ReadOnly="@(_currentView == ViewMode.View)" OnCancel="BackToTable" OnSuccess="HandleSuccess" />
+}
+else
+{
+    <_LeaveCategoryDataTable OnAdd="() => ShowCreate()" OnEdit="(item) => ShowUpdate(item, false)" OnView="(item) => ShowUpdate(item, true)" />
+}
+
+@code {
+    private enum ViewMode { Table, Create, Update, View }
+    private ViewMode _currentView = ViewMode.Table;
+    private UpdateLeaveCategoryRequest? _selectedData;
+
+    private void ShowCreate() => _currentView = ViewMode.Create;
+
+    private void ShowUpdate(UpdateLeaveCategoryRequest data, bool isReadOnly)
+    {
+        _selectedData = data;
+        _currentView = isReadOnly ? ViewMode.View : ViewMode.Update;
+    }
+
+    private void BackToTable() { _currentView = ViewMode.Table; _selectedData = null; }
+
+    private void HandleSuccess() { _currentView = ViewMode.Table; _selectedData = null; }
+}

Features/Leave/LeaveCategory/Components/_LeaveCategoryCreateForm.razor

@@ -0,0 +1,117 @@
+@using Indotalent.Features.Leave.LeaveCategory
+@using Indotalent.Features.Leave.LeaveCategory.Cqrs
+@using Indotalent.Shared.Utils
+@using MudBlazor
+@inject LeaveCategoryService LeaveCategoryService
+@inject ISnackbar Snackbar
+
+<MudPaper Elevation="0" Square="true" Class="pa-6 mb-3 d-flex align-center justify-space-between" Style="border: 1px solid #DCEBFA;">
+    <div class="d-flex align-center gap-4">
+        <MudIconButton Icon="@Icons.Material.Filled.ArrowBack" OnClick="() => OnCancel.InvokeAsync()" />
+        <div>
+            <MudText Typo="Typo.h5" Style="font-weight: 900; color: #1a1a1a;">Add Leave Category</MudText>
+            <MudText Typo="Typo.body2" Style="color: #64748b;">Define new leave type and its entitlement rules.</MudText>
+        </div>
+    </div>
+</MudPaper>
+
+<MudPaper Elevation="0" Outlined="true" Class="pa-8" Style="border-radius: 0px; border: 1px solid #DCEBFA;">
+    <MudForm @ref="_form" Model="_model">
+        <MudGrid Spacing="3">
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Category Code</MudText>
+                <MudTextField @bind-Value="_model.Code"
+                              For="@(() => _model.Code)"
+                              Validation="@(_validator.ValidateValue())"
+                              Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" Placeholder="e.g. LV-AL" />
+            </MudItem>
+            <MudItem xs="12" sm="8">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Category Name</MudText>
+                <MudTextField @bind-Value="_model.Name"
+                              For="@(() => _model.Name)"
+                              Validation="@(_validator.ValidateValue())"
+                              Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" Placeholder="e.g. Annual Leave" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Quota (Days)</MudText>
+                <MudNumericField @bind-Value="_model.Quota" Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" Min="0" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Status</MudText>
+                <MudSelect @bind-Value="_model.Status" Variant="Variant.Outlined" Margin="Margin.Dense" AnchorOrigin="Origin.BottomCenter">
+                    <MudSelectItem Value="@("Active")">Active</MudSelectItem>
+                    <MudSelectItem Value="@("Inactive")">Inactive</MudSelectItem>
+                </MudSelect>
+            </MudItem>
+            <MudItem xs="12" sm="4" Class="d-flex align-center">
+                <MudCheckBox @bind-Value="_model.IsPaidLeave" Label="Paid Leave" Color="Color.Success" />
+            </MudItem>
+            <MudItem xs="12">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Description</MudText>
+                <MudTextField @bind-Value="_model.Description" Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" Lines="2" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudCheckBox @bind-Value="_model.AllowCarryForward" Label="Allow Carry Forward" Color="Color.Primary" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Max Carry Forward</MudText>
+                <MudNumericField @bind-Value="_model.MaxCarryForward" Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" Disabled="!_model.AllowCarryForward" />
+            </MudItem>
+            <MudItem xs="12" sm="4">
+                <MudText Typo="Typo.subtitle2" Class="mb-1">Min Service (Months)</MudText>
+                <MudNumericField @bind-Value="_model.MinServiceMonths" Variant="Variant.Outlined" Margin="Margin.Dense" FullWidth="true" />
+            </MudItem>
+        </MudGrid>
+
+        <div class="d-flex justify-end gap-2 mt-8">
+            <MudButton OnClick="() => OnCancel.InvokeAsync()" Variant="Variant.Outlined" Disabled="_processing" Style="border: 1px solid #e0e0e0; border-radius: 4px; text-transform: none; font-weight: 700;">Cancel</MudButton>
+            <MudButton Color="Color.Success" Variant="Variant.Filled" OnClick="Submit" Disabled="_processing" Style="border-radius: 4px; text-transform: none; font-weight: 700; color: white;">
+                @if (_processing)
+                {
+                    <MudProgressCircular Class="ms-n1" Size="Size.Small" Indeterminate="true" />
+                    <MudText Class="ms-2" Typo="Typo.button" Style="text-transform: none !important;">Processing...</MudText>
+                }
+                else
+                {
+                    <MudText>Create Category</MudText>
+                }
+            </MudButton>
+        </div>
+    </MudForm>
+</MudPaper>
+
+@code {
+    [Parameter] public EventCallback OnCancel { get; set; }
+    [Parameter] public EventCallback OnSuccess { get; set; }
+
+    private MudForm _form = default!;
+    private CreateLeaveCategoryValidator _validator = new();
+    private CreateLeaveCategoryRequest _model = new() { Status = "Active", IsPaidLeave = true };
+    private bool _processing = false;
+
+    private async Task Submit()
+    {
+        await _form.Validate();
+        if (!_form.IsValid) return;
+
+        _processing = true;
+        try
+        {
+            var response = await LeaveCategoryService.CreateLeaveCategoryAsync(_model);
+            await Task.Delay(500);
+            if (response != null && response.IsSuccess)
+            {
+                Snackbar.Add("Leave category created successfully", Severity.Success);
+                await OnSuccess.InvokeAsync();
+            }
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Error: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _processing = false;
+        }
+    }
+}