How To Use The Identity Framework With Refresh Token Validations

using Microsoft.AspNetCore.Identity;
using System.ComponentModel.DataAnnotations.Schema;
namespace WebApplication.DataLayer
{
    [Table("ApplicationUser")]
    public class ApplicationUser:IdentityUser
    {
        [Column("FirstName")]
        public string FirstName { get; set; }
        [Column("LastName")]
        public string LastName { get; set; }
        [Column("RefreshToken")]
        public string? RefreshToken { get; set; }
        [Column("RefreshTokenValidity")]
        public DateTime? RefreshTokenValidity { get; set; }
    }
}

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace WebApplication.DataLayer
{
    public class RefreshTokenDemoContext : IdentityDbContext<ApplicationUser>
    {
        public RefreshTokenDemoContext()
        {
        }
        public RefreshTokenDemoContext(DbContextOptions<RefreshTokenDemoContext> options) : base(options)
        {
        }
        public DbSet<ApplicationUser> applicationUsers { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {   
            modelBuilder.Entity<IdentityUserLogin<Guid>>().HasNoKey();
            modelBuilder.Entity<IdentityUserClaim<Guid>>().HasNoKey();
            modelBuilder.Entity<IdentityUserToken<Guid>>().HasNoKey();
            modelBuilder.Entity<IdentityRoleClaim<Guid>>().HasNoKey();
            base.OnModelCreating(modelBuilder);
        }
    }
}

"ConnectionStrings": {
    "RefreshTokenDB": "Host=localhost;Port=5432;Database=RefreshTokenDB;Username=postgres;Password=admin123"
  },

using Microsoft.Extensions.DependencyInjection;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using WebApplication.DataLayer;
using Microsoft.AspNetCore.Identity;

namespace WebApplication.Extensions
{
    public static class IdentityServicesExtensions
    {
        public static IServiceCollection AddIdentityServices(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddDbContext<RefreshTokenDemoContext>(options =>
                options.UseNpgsql(configuration.GetConnectionString("RefreshTokenDB")));

            services.AddIdentity<ApplicationUser, IdentityRole>()
                .AddDefaultTokenProviders()
                .AddEntityFrameworkStores<RefreshTokenDemoContext>();
            return services;
        }
    }
}

builder.Services.AddIdentityServices(builder.Configuration);

Run the Migration to create a database here we are using database code first migration to generate the database.

First Run the add-migration command to then update the database command.

To Run Migration open the Package manager console from Tool> Package manager > Package Manager Console.

Then Run Commands these will output like below.

And after successfully adding the migration run command to update the database it will create a database

Step 3 - Register User and Generate Refresh Token

In the Accounts, the controller adds a variable for DbContext class and UserManger like below.

private readonly JwtSettings jwtSettings;
private readonly UserManager<ApplicationUser> userManager;
private readonly RefreshTokenDemoContext refreshTokenDemoContext;

public AccountController(JwtSettings jwtSettings
    , UserManager<ApplicationUser> userManager
    , RefreshTokenDemoContext refreshTokenDemoContext)
{
    this.jwtSettings = jwtSettings;
    this.userManager = userManager;
    this.refreshTokenDemoContext = refreshTokenDemoContext;
}

Add a method to register a user with the following code.

[HttpPost]
public async Task<IActionResult> RegisterUser(Users users)
{
    try
    {
        var applicationUser = new ApplicationUser()
        {
            UserName = users.UserName,
            Email = users.EmailId,
            FirstName = users.FirstName,
            LastName = users.LastName,
            EmailConfirmed = true,
            TwoFactorEnabled = false,
            LockoutEnabled = false,

        };
        var result = await userManager.CreateAsync(applicationUser, users.Password);
        if (result.Succeeded)
        {
            return Ok("User created");
        }
        else
        {
            return BadRequest(result.Errors)
        }
    }
    catch (Exception)
    {
        throw;
    }
}

For generating token replace get token method with following code.

[HttpPost]
public async Task<IActionResult> GetToken(UserLogins userLogins)
{
    try
    {
        var Token = new UserTokens();
        var user = await userManager.FindByNameAsync(userLogins.UserName);
        if (user == null)
        {
            return BadRequest("User name is not valid");
        }
        var Valid = await userManager.CheckPasswordAsync(user, userLogins.Password);
        if (Valid)
        {
            var strToken = Guid.NewGuid().ToString();
            var validity = DateTime.UtcNow.AddDays(15);
            Token = JwtHelpers.JwtHelpers.GenTokenkey(new UserTokens()
            {
                EmailId = user.Email,
                GuidId = Guid.NewGuid(),
                UserName = user.UserName,
                Id = Guid.Parse(user.Id),
                RefreshToken = strToken,

            }, jwtSettings);
            var tokenupdate = refreshTokenDemoContext.Users.Where(x => x.Id == user.Id).FirstOrDefault();
            tokenupdate.RefreshToken = strToken;
            tokenupdate.RefreshTokenValidity = validity;
            refreshTokenDemoContext.Update(tokenupdate);
            refreshTokenDemoContext.SaveChanges();
            Token.RefreshToken = strToken;
        }
        else
        {
            return BadRequest($"wrong password");
        }
        return Ok(Token);
    }
    catch (Exception)
    {
        throw;
    }
}

For generating access token from refresh token add following method.

/// <summary>
/// Generate an Access token
/// </summary>
/// <param name="userLogins"></param>
/// <returns></returns>
[HttpPost]
public async Task<IActionResult> RefreshToken(RefreshTokenModel userLogins)
{
    try
    {
        var Token = new UserTokens();
        var user = await userManager.FindByNameAsync(userLogins.UserName);
        if (user == null)
        {
            return BadRequest("User name is not valid");
        }
        var Valid = refreshTokenDemoContext.Users.Where(x=>x.UserName==userLogins.UserName 
        && x.RefreshToken==userLogins.RefreshToken 
        && x.RefreshTokenValidity>DateTime.UtcNow).Count()>0;
        if (Valid)
        {
            var strToken = Guid.NewGuid().ToString();
            var validity = DateTime.UtcNow.AddDays(15);
            Token = JwtHelpers.JwtHelpers.GenTokenkey(new UserTokens()
            {
                EmailId = user.Email,
                GuidId = Guid.NewGuid(),
                UserName = user.UserName,
                Id = Guid.Parse(user.Id),
                RefreshToken = strToken,

            }, jwtSettings);
            var tokenupdate = refreshTokenDemoContext.Users.Where(x => x.Id == user.Id).FirstOrDefault();
            tokenupdate.RefreshToken = strToken;
            tokenupdate.RefreshTokenValidity = validity;
            refreshTokenDemoContext.Update(tokenupdate);
            refreshTokenDemoContext.SaveChanges();
        }
        else
        {
            return BadRequest($"wrong password");
        }
        return Ok(Token);
    }
    catch (Exception)
    {
        throw;
    }
}

Step 4 - Validate Refresh Token

The last step is checking your flow.

First, create a new User.

Get tokens by using a newly created user credential.

Now without validating the token string try to get the user list, and it will show an error.

Validate the token string

Now try to get the user list it will display the user list after the access token expired it will show an error like the below.

Generate new access token from refresh token bypassing access token and refresh token,

After regenerating the token validates the token so you get a list of users

Thank You. Happy Coding.

Summary

In this article, I discussed how we can create a JWT access token. We also saw how we can authorize the WEB API endpoint.