=== ApiScopeConfig.cs ===
namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public class ApiScopeConfig
    {
        public string Name { get; set; }
        public string DisplayName { get; set; }
    }
}

=== ClientConfig.cs ===
using IdentityServer4.Models;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public class ClientConfig
    {
        public ClientType ClientType { get; set; }
        public string ClientId { get; set; }
        public string ClientName { get; set; }
        public List<string> AllowedGrantTypes { get; set; }
        public bool RequireConsent { get; set; }
        public string ClientSecrets { get; set; }
        public List<string> RedirectUris { get; set; }
        public List<string> PostLogoutRedirectUris { get; set; }
        public List<string> AllowedScopes { get; set; }
        public bool AllowOfflineAccess { get; set; }
        public bool AlwaysSendClientClaims { get; set; }
        public int AccessTokenLifetime { get; set; }
        public bool RequireClientSecret { get; set; }
        public TokenUsage RefreshTokenUsage { get; set; }
        public TokenExpiration RefreshTokenExpiration { get; set; }
    }
}

=== IdentityConfig.cs ===
using IdentityModel;
using IdentityServer4;
using IdentityServer4.Models;
using System.ComponentModel;
using static IdentityServer4.IdentityServerConstants;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public static class IdentityConfig
    {
        public static IEnumerable<IdentityResource> GetIdentityResources()
        {
            return new List<IdentityResource>
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile(),
                new IdentityResource("roles",new []{"role"})

            };
        }

        public static IEnumerable<ApiResource> ApiResources =>
            new ApiResource[]
            {
                new ApiResource(LocalApi.ScopeName)
            };

        public static IEnumerable<ApiScope> GetApiScopes(IConfiguration configuration)
        {
            var apiScopes = new List<ApiScope>();
            apiScopes.Add(new ApiScope(LocalApi.ScopeName));
            var apiScopeConfigs = configuration.GetSection("ApiScopes").Get<List<ApiScopeConfig>>();

            if (apiScopeConfigs.Any())
            {
                foreach (var apiScopeConfig in apiScopeConfigs)
                {
                    apiScopes.Add(new ApiScope(apiScopeConfig.Name, apiScopeConfig.DisplayName));
                }
            }
            return apiScopes;
        }

        // clients want to access resources (aka scopes)
        public static IEnumerable<Client> GetClients(IConfiguration configuration)
        {
            var configClients = configuration.GetSection("Clients").Get<List<ClientConfig>>();

            if (!configClients.Any()) return new List<Client>();
            var clients = new List<Client>();
            foreach (var configClient in configClients)
            {
                var client = new Client();
                if (configClient.ClientType == ClientType.Website)
                {
                    client = new Client()
                    {
                        ClientId = configClient.ClientId,
                        AllowedGrantTypes = GrantTypes.Code,
                        ClientSecrets = { new Secret(configClient.ClientSecrets.ToSha256()) },
                        RedirectUris = configClient.RedirectUris,
                        PostLogoutRedirectUris = configClient.PostLogoutRedirectUris,
                        AllowedScopes = configClient.AllowedScopes,
                        AccessTokenLifetime = configClient.AccessTokenLifetime
                    };
                }
                else if (configClient.ClientType == ClientType.Api)
                {
                    client = new Client()
                    {
                        ClientId = configClient.ClientId,
                        AllowedGrantTypes = configClient.AllowedGrantTypes,
                        ClientSecrets = { new Secret(configClient.ClientSecrets.ToSha256()) },
                        AllowedScopes = configClient.AllowedScopes,
                        AllowOfflineAccess = true,
                        AccessTokenLifetime = configClient.AccessTokenLifetime

                    };
                }
                else if (configClient.ClientType == ClientType.MobileApp)

=== IdentityEnums.cs ===
using System.ComponentModel;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public enum ClientType
    {
        [Description("Website")]
        Website = 1,
        [Description("Api")]
        Api = 2,
        [Description("Mobile App")]
        MobileApp = 3,
        [Description("Cs")]
        Cs = 4
    }
}

=== LadaTokenRequestValidator.cs ===
using IdentityServer4.Extensions;
using IdentityServer4.Validation;
using Lada.Framework.Data.Domains.Identity;
using Microsoft.AspNetCore.Identity;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public class LadaTokenRequestValidator : ICustomTokenRequestValidator
    {
        private readonly UserManager<User> _userManager;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private const string errorMessage = "invalid_username_or_password";
        public LadaTokenRequestValidator(
              UserManager<User> userManager
            , IHttpContextAccessor httpContextAccessor)
        {
            _userManager = userManager;
            _httpContextAccessor = httpContextAccessor;
        }
        public async Task ValidateAsync(CustomTokenRequestValidationContext context)
        {
            if (context.Result.ValidatedRequest.GrantType == "refresh_token")
            {
                var userId = context.Result.ValidatedRequest.Subject.GetSubjectId();
                if (!string.IsNullOrEmpty(userId))
                {
                    var user = await _userManager.FindByIdAsync(userId);
                    if (user == null || (user.LockoutEnd != null && user.LockoutEnabled && user.LockoutEnd > DateTimeOffset.Now))
                    {
                        context.Result.IsError = true;
                        context.Result.Error = errorMessage;
                    }
                }
                else
                {
                    context.Result.IsError = true;
                    context.Result.Error = errorMessage;
                }
            }
            return;
        }

        private async Task<bool> IsValidLogin(CustomTokenRequestValidationContext context) {

            //Trong n…y x c d?nh xem user c¢ quy?n truy c?p v…o clientId da d?nh s?n hay ko
            var userId = context.Result.ValidatedRequest.Subject.GetSubjectId();
            if (!string.IsNullOrEmpty(userId))
            {
                var user = await _userManager.FindByIdAsync(userId);
                if (user == null || (user.LockoutEnd != null && user.LockoutEnabled && user.LockoutEnd > DateTimeOffset.Now))
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
            return true;
        }
        private async Task<bool> IsValidRefreshToken(CustomTokenRequestValidationContext context) {
            var userId = context.Result.ValidatedRequest.Subject.GetSubjectId();
            if (!string.IsNullOrEmpty(userId))
            {
                var user = await _userManager.FindByIdAsync(userId);
                if (user == null || (user.LockoutEnd != null && user.LockoutEnabled && user.LockoutEnd > DateTimeOffset.Now))
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
            return true;
        }


    }


=== ProfileService.cs ===
using IdentityServer4.Extensions;
using IdentityServer4.Models;
using IdentityServer4.Services;
using Lada.Framework.Data.Domains.Identity;
using Lada.Framework.Data.Enums;
using Lada.Framework.Data.Repositories;
using Microsoft.AspNetCore.Identity;
using System.Security.Claims;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public class ProfileService : IProfileService
    {
        private readonly IUserClaimsPrincipalFactory<User> _claimsFactory;
        private readonly UserManager<User> _userManager;
        private readonly IUserRepository<User> _userRepository;

        public ProfileService(IUserClaimsPrincipalFactory<User> claimsFactory, UserManager<User> userManager,
                                IUserRepository<User> userRepository)
        {
            _claimsFactory = claimsFactory;
            _userManager = userManager;
        }

        public async Task GetProfileDataAsync(ProfileDataRequestContext context)
        {
            var sub = context.Subject.GetSubjectId();
            var user = await _userManager.FindByIdAsync(sub);
            if (user == null)
            {
                throw new ArgumentException("");
            }

            var principal = await _claimsFactory.CreateAsync(user);
            var claims = principal.Claims.ToList();


            claims.Add(new Claim("UserType", ((int)user.UserType).ToString()));


            //Thˆm c c claim kh c t?i dƒy
            //claims.Add(new System.Security.Claims.Claim("MyProfileID", user.Id));
            switch (user.UserType)
            {
                case UserType.Staff:
                case UserType.Franchisee:
                    var roles = string.Join(',', (await _userManager.GetRolesAsync(user)).ToList());
                    claims.Add(new Claim("FullName", !string.IsNullOrEmpty(user.FullName) ? user.FullName : ""));
                    claims.Add(new Claim("Roles", roles));
                    break;
                case UserType.Customer:
                    claims.Add(new Claim("FullName", !string.IsNullOrEmpty(user.FullName) ? user.FullName : ""));
                    break;
                default:
                    break;
            }
            
            context.IssuedClaims = claims;
        }

        public async Task IsActiveAsync(IsActiveContext context)
        {
            var sub = context.Subject.GetSubjectId();
            var user = await _userManager.FindByIdAsync(sub);
            context.IsActive = user != null;
        }


    }
}

=== VietnamIdentityErrorDescriber.cs ===
using Microsoft.AspNetCore.Identity;
using static IdentityServer4.Models.IdentityResources;

namespace LadaIdentity.Infrastructures.IdentityConfigs
{
    public class VietnamIdentityErrorDescriber : IdentityErrorDescriber
    {
        public override IdentityError DefaultError() { return new IdentityError { Code = nameof(DefaultError), Description = $"L?i kh“ng x c d?nh" }; }
        public override IdentityError ConcurrencyFailure() { return new IdentityError { Code = nameof(ConcurrencyFailure), Description = "L?i tr—ng l?p, b?n ghi dang du?c c?p nh?t." }; }
        public override IdentityError PasswordMismatch() { return new IdentityError { Code = nameof(PasswordMismatch), Description = "M?t kh?u kh“ng h?p l?." }; }
        public override IdentityError InvalidToken() { return new IdentityError { Code = nameof(InvalidToken), Description = "Token kh“ng h?p l?." }; }
        public override IdentityError LoginAlreadyAssociated() { return new IdentityError { Code = nameof(LoginAlreadyAssociated), Description = "Th“ng tin dang nh?p da t?n t?i." }; }
        public override IdentityError InvalidUserName(string userName) { return new IdentityError { Code = nameof(InvalidUserName), Description = $"Tˆn dang nh?p '{userName}' kh“ng h?p l?, ch? du?c ch?a ch? c i ho?c ch? s?." }; }
        public override IdentityError InvalidEmail(string email) { return new IdentityError { Code = nameof(InvalidEmail), Description = $"Email '{email}' kh“ng h?p l?." }; }
        public override IdentityError DuplicateUserName(string userName) { return new IdentityError { Code = nameof(DuplicateUserName), Description = $"Tˆn dang nh?p '{userName}' da du?c dang ky." }; }
        public override IdentityError DuplicateEmail(string email) { return new IdentityError { Code = nameof(DuplicateEmail), Description = $"Email '{email}' da du?c dang ky." }; }
        public override IdentityError InvalidRoleName(string role) { return new IdentityError { Code = nameof(InvalidRoleName), Description = $"Role '{role}' kh“ng h?p l?." }; }
        public override IdentityError DuplicateRoleName(string role) { return new IdentityError { Code = nameof(DuplicateRoleName), Description = $"Role '{role}' da t?n t?i." }; }
        public override IdentityError UserAlreadyHasPassword() { return new IdentityError { Code = nameof(UserAlreadyHasPassword), Description = "Ngu?i d—ng da c¢ m?t kh?u." }; }
        public override IdentityError UserLockoutNotEnabled() { return new IdentityError { Code = nameof(UserLockoutNotEnabled), Description = "Kh¢a kh“ng du?c cho ph‚p v?i ngu?i d—ng n…y" }; }
        public override IdentityError UserAlreadyInRole(string role) { return new IdentityError { Code = nameof(UserAlreadyInRole), Description = $"Ngu?i d—ng da c¢ role '{role}'." }; }
        public override IdentityError UserNotInRole(string role) { return new IdentityError { Code = nameof(UserNotInRole), Description = $"Ngu?i d—ng kh“ng trong role '{role}'." }; }
        public override IdentityError PasswordTooShort(int length) { return new IdentityError { Code = nameof(PasswordTooShort), Description = $"M?t kh?u ph?i ch?a ¡t nh?t {length} ky t?." }; }
        public override IdentityError PasswordRequiresNonAlphanumeric() { return new IdentityError { Code = nameof(PasswordRequiresNonAlphanumeric), Description = "M?t kh?u ph?i ch?a ¡t nh?t m?t ky t? kh“ng ph?i ch? v… s?." }; }
        public override IdentityError PasswordRequiresDigit() { return new IdentityError { Code = nameof(PasswordRequiresDigit), Description = "M?t kh?u ph?i ch?a ¡t nh?t m?t ch? s? ('0'-'9')." }; }
        public override IdentityError PasswordRequiresLower() { return new IdentityError { Code = nameof(PasswordRequiresLower), Description = "M?t kh?u ph?i ch?a ¡t nh?t m?t ky t? ch? thu?ng ('a'-'z')." }; }
        public override IdentityError PasswordRequiresUpper() { return new IdentityError { Code = nameof(PasswordRequiresUpper), Description = "M?t kh?u ph?i ch?a ¡t nh?t m?t ky t? vi?t hoa ('A'-'Z')." }; }


    }
}