add identity integration

AutobusApi.Api/AutobusApi.Api.csproj

@@ -7,21 +7,20 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="HotChocolate.AspNetCore" Version="13.5.1" />
-    <PackageReference Include="HotChocolate.Types" Version="13.5.1" />
+    <PackageReference Include="MediatR" Version="12.1.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.13">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\AutobusApi.Application\AutobusApi.Application.csproj" />
     <ProjectReference Include="..\AutobusApi.Domain\AutobusApi.Domain.csproj" />
     <ProjectReference Include="..\AutobusApi.Infrastructure\AutobusApi.Infrastructure.csproj" />
-    <ProjectReference Include="..\AutobusApi.Persistence\AutobusApi.Persistence.csproj" />
   </ItemGroup>
 
 </Project>

AutobusApi.Api/Controllers/BaseController.cs

@@ -0,0 +1,12 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class BaseController : ControllerBase
+{
+    private IMediator _mediator;
+    protected IMediator Mediator => _mediator ??= HttpContext.RequestServices.GetService<IMediator>();
+}

AutobusApi.Api/Controllers/IdentityController.cs

@@ -0,0 +1,35 @@
+using AutobusApi.Application.Common.Models.Identity;
+using AutobusApi.Application.Identity.Commands.Register;
+using AutobusApi.Application.Identity.Commands.RenewAccessToken;
+using AutobusApi.Application.Identity.Commands.RevokeRefreshToken;
+using AutobusApi.Application.Identity.Queries.Login;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+public class IdentityController : BaseController
+{
+    [HttpPost("register")]
+    public async Task Register([FromBody] RegisterCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpPost("login")]
+    public async Task<TokensModel> Login([FromBody] LoginQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPost("renewAccessToken")]
+    public async Task<TokensModel> RenewAccessToken([FromBody] RenewAccessTokenCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpPost("revokeRefreshToken")]
+    public async Task RevokeRefreshToken([FromBody] RevokeRefreshTokenCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs

@@ -0,0 +1,129 @@
+using AutobusApi.Application.Common.Exceptions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Middlewares;
+
+public class GlobalExceptionHandlerMiddleware : IMiddleware
+{
+    private readonly Dictionary<Type, Func<HttpContext, Exception, Task>> _exceptionHandlers;
+
+    public GlobalExceptionHandlerMiddleware()
+    {
+        // Register known exception types and handlers.
+        _exceptionHandlers = new()
+        {
+            { typeof(ValidationException), HandleValidationException },
+            { typeof(RegistrationException), HandleRegistrationException },
+            { typeof(LoginException), HandleLoginException },
+            { typeof(RenewAccessTokenException), HandleRenewAccessTokenException },
+            { typeof(RevokeRefreshTokenException), HandleRevokeRefreshTokenException },
+        };
+    }
+
+    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+    {
+        try
+        {
+            await next(context);
+        }
+        catch (Exception exception)
+        {
+            var exceptionType = exception.GetType();
+
+            if (_exceptionHandlers.ContainsKey(exceptionType))
+            {
+                await _exceptionHandlers[exceptionType].Invoke(context, exception);
+                return;
+            }
+
+            await HandleUnhandledExceptionException(context, exception);
+        }
+    }
+
+    private async Task HandleValidationException(HttpContext context, Exception exception)
+    {
+        var ex = (ValidationException) exception;
+
+        context.Response.StatusCode = StatusCodes.Status400BadRequest;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new HttpValidationProblemDetails(ex.Errors)
+        {
+            Status = StatusCodes.Status400BadRequest,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1",
+            Detail = "Check provided information."
+        });
+    }
+
+    private async Task HandleRegistrationException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status400BadRequest;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status400BadRequest,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1",
+            Title = "Registration failed.",
+            Detail = "Check your credentials."
+        });
+    }
+
+    private async Task HandleLoginException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status400BadRequest;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status400BadRequest,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1",
+            Title = "Login failed.",
+            Detail = "Provided email and/or password are invalid."
+        });
+    }
+
+    private async Task HandleRenewAccessTokenException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status400BadRequest;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status400BadRequest,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1",
+            Title = "Access token renewal failed.",
+            Detail = "Check validity of your refresh token."
+        });
+    }
+
+    private async Task HandleRevokeRefreshTokenException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status400BadRequest;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status400BadRequest,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.1",
+            Title = "Refresh token revocation failed.",
+            Detail = "Check validity of your refresh token."
+        });
+    }
+
+    private async Task HandleUnhandledExceptionException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status500InternalServerError; 
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status500InternalServerError,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.6.1",
+            Title = "One or more internal server errors occured.",
+            Detail = "Report this error to service's support team.",
+        });
+
+        await Console.Error.WriteLineAsync(exception.StackTrace);
+    }
+}

AutobusApi.Api/Program.cs

@@ -1,16 +1,37 @@
-using AutoubsApi.Persistence.Contexts;
-using Microsoft.EntityFrameworkCore;
+using AutobusApi.Infrastructure;
+using AutobusApi.Application;
+using AutobusApi.Api.Middlewares;
+using AutoubsApi.Infrastructure.Data;
+using AutobusApi.Infrastructure.Identity;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddDbContext<PostgresContext>(options =>
-    options.UseNpgsql(
-        builder.Configuration.GetConnectionString("DefaultConnection"),
-        npgsqOptions => npgsqOptions.UseNetTopologySuite()
-    ));
+builder.Services.AddInfrastructure(builder.Configuration);
+builder.Services.AddApplication();
+
+builder.Services.AddControllers();
+
+builder.Services.AddSwaggerGen();
+
+builder.Services.AddTransient<GlobalExceptionHandlerMiddleware>();
 
 var app = builder.Build();
 
+// Initialize database
+var scope = app.Services.CreateScope();
+var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+var identityDbContext = scope.ServiceProvider.GetRequiredService<ApplicationIdentityDbContext>();
+DbInitializer.Initialize(dbContext, identityDbContext);
 
+app.UseAuthentication();
+
+app.MapControllers();
+
+app.UseSwagger();
+app.UseSwaggerUI();
+
+app.UseMiddleware<GlobalExceptionHandlerMiddleware>();
 
 app.Run();
+
+public partial class Program { }

AutobusApi.Api/appsettings.Development.json

@@ -1,5 +1,12 @@
 {
   "ConnectionStrings": {
     "DefaultConnection": "Host=10.0.0.20:5432;Database=autobus;Username=postgres;Password=12345678"
+  },
+  "Jwt": {
+    "Issuer": "",
+    "Audience": "",
+    "IssuerSigningKey": "a2c98dec80787a4e85ffb5bcbc24f7e4cc014d8a4fe43e9520480a50759164bc",
+    "AccessTokenValidityInMinutes": "5",
+    "RefreshTokenValidityInDays": "15",
   }
 }

AutobusApi.Application/AutobusApi.Application.csproj

@@ -8,6 +8,16 @@
 
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="12.0.1" />
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection">
+      <Version>12.0.1</Version>
+    </PackageReference>
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions">
+      <Version>11.8.0</Version>
+    </PackageReference>
+    <PackageReference Include="MediatR" Version="12.1.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore">
+      <Version>7.0.13</Version>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>

AutobusApi.Application/Common/Behaviours/ValidationBehaviour.cs

@@ -0,0 +1,43 @@
+using FluentValidation;
+using MediatR;
+using ValidationException = AutobusApi.Application.Common.Exceptions.ValidationException;
+
+namespace AutobusApi.Application.Common.Behaviours;
+
+public class ValidationBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+     where TRequest : notnull
+{
+    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
+                .Where(r => r.Errors.Any())
+                .SelectMany(r => r.Errors)
+                .ToList();
+
+            if (failures.Any())
+            {
+                throw new ValidationException(failures);
+            }
+        }
+
+        return await next();
+    }
+}

AutobusApi.Application/Common/Exceptions/LoginException.cs

@@ -0,0 +1,7 @@
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class LoginException : Exception
+{
+    public LoginException(string? message)
+        : base(message) { }
+}

AutobusApi.Application/Common/Exceptions/RegistrationException.cs

@@ -0,0 +1,7 @@
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class RegistrationException : Exception
+{
+    public RegistrationException(string? message)
+        : base(message) { }
+}

AutobusApi.Application/Common/Exceptions/RenewAccessTokenException.cs

@@ -0,0 +1,7 @@
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class RenewAccessTokenException : Exception
+{
+    public RenewAccessTokenException(string? errorMessage)
+        : base(errorMessage) { }
+}

AutobusApi.Application/Common/Exceptions/RevokeRefreshTokenException.cs

@@ -0,0 +1,7 @@
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class RevokeRefreshTokenException : Exception
+{
+    public RevokeRefreshTokenException(string? errorMessage)
+        : base(errorMessage) { }
+}

AutobusApi.Application/Common/Exceptions/ValidationException.cs

@@ -0,0 +1,22 @@
+using FluentValidation.Results;
+
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class ValidationException : Exception
+{
+    public ValidationException()
+        : base("One or more validation failures have occurred.")
+    {
+        Errors = new Dictionary<string, string[]>();
+    }
+
+    public ValidationException(IEnumerable<ValidationFailure> failures)
+        : this()
+    {
+        Errors = failures
+            .GroupBy(f => f.PropertyName, f => f.ErrorMessage)
+            .ToDictionary(fg => fg.Key, fg => fg.ToArray());
+    }
+
+    public IDictionary<string, string[]> Errors { get; }
+}

AutobusApi.Application/Common/Interfaces/IApplicationDbContext.cs

@@ -0,0 +1,55 @@
+using AutobusApi.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Common.Interfaces;
+
+public interface IApplicationDbContext
+{
+    DbSet<Country> Countries { get; }
+
+    DbSet<Region> Regions { get; }
+
+    DbSet<City> Cities { get; }
+
+    DbSet<Address> Addresses { get; }
+
+    DbSet<RouteAddress> RouteAddresses { get; }
+
+    DbSet<Route> Routes { get; }
+
+    DbSet<RouteAddressDetails> RouteAddressDetails { get; }
+
+    DbSet<VehicleEnrollment> VehicleEnrollments { get; }
+
+    DbSet<Vehicle> Vehicles { get; }
+
+    DbSet<Bus> Buses { get; }
+
+    DbSet<Aircraft> Aircraft { get; }
+
+    DbSet<Train> Trains { get; }
+
+    DbSet<TrainCarriage> TrainCarriages { get; }
+
+    DbSet<Carriage> Carriages { get; }
+
+    DbSet<Company> Companies { get; }
+
+    DbSet<Employee> Employees { get; }
+
+    DbSet<EmployeeDocument> EmployeeDocuments { get; }
+
+    DbSet<VehicleEnrollmentEmployee> vehicleEnrollmentEmployees { get; }
+
+    DbSet<User> ApplicationUsers { get; }
+
+    DbSet<TicketGroup> TicketGroups { get; }
+
+    DbSet<Ticket> Tickets { get; }
+
+    DbSet<TicketDocument> TicketDocuments { get; }
+
+    DbSet<Review> Reviews { get; }
+
+    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
+}

AutobusApi.Application/Common/Interfaces/IIdentityService.cs

@@ -0,0 +1,14 @@
+using AutobusApi.Application.Common.Models.Identity;
+
+namespace AutobusApi.Application.Common.Interfaces;
+
+public interface IIdentityService
+{
+    Task RegisterAsync(string email, string password, CancellationToken cancellationToken);
+
+    Task<TokensModel> LoginAsync(string email, string password, CancellationToken cancellationToken);
+
+    Task<TokensModel> RenewAccessTokenAsync(string refreshToken, CancellationToken cancellationToken);
+
+    Task RevokeRefreshTokenAsync(string refreshToken, CancellationToken cancellationToken);
+}

AutobusApi.Application/Common/Models/Identity/Roles.cs

@@ -0,0 +1,6 @@
+namespace AutobusApi.Application.Common.Models.Identity;
+
+public enum Roles
+{
+    User = 0,
+}

AutobusApi.Application/Common/Models/Identity/TokensModel.cs

@@ -0,0 +1,16 @@
+namespace AutobusApi.Application.Common.Models.Identity;
+
+public class TokensModel
+{
+    public TokensModel(
+        string accessToken,
+        string refreshToken)
+    {
+        AccessToken = accessToken;
+        RefreshToken = refreshToken;
+    }
+
+    public string AccessToken { get; set; }
+
+    public string RefreshToken { get; set; }
+}

AutobusApi.Application/DependencyInjection.cs

@@ -0,0 +1,23 @@
+using System.Reflection;
+using AutobusApi.Application.Common.Behaviours;
+using FluentValidation;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace AutobusApi.Application;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplication(this IServiceCollection services)
+    {
+        services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
+
+        services.AddMediatR(configuration =>
+        {
+            configuration.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
+            configuration.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehaviour<,>));
+        });
+
+        return services;
+    }
+}

AutobusApi.Application/Identity/Commands/Register/RegisterCommand.cs

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.Register;
+
+public record RegisterCommand : IRequest
+{
+    public required string Email { get; set; }
+
+    public required string Password { get; set; }
+}

AutobusApi.Application/Identity/Commands/Register/RegisterCommandHandler.cs

@@ -0,0 +1,21 @@
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.Register;
+
+public class RegisterCommandHandler : IRequestHandler<RegisterCommand>
+{
+    private readonly IIdentityService _identityService;
+
+    public RegisterCommandHandler(IIdentityService identityService)
+    {
+        _identityService = identityService;
+    }
+
+    public async Task Handle(
+        RegisterCommand command,
+        CancellationToken cancellationToken)
+    {
+        await _identityService.RegisterAsync(command.Email, command.Password, cancellationToken);
+    }
+}

AutobusApi.Application/Identity/Commands/Register/RegisterCommandValidator.cs

@@ -0,0 +1,22 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Identity.Commands.Register;
+
+public class RegisterCommandValidator : AbstractValidator<RegisterCommand>
+{
+    public RegisterCommandValidator()
+    {
+        RuleFor(v => v.Email)
+            .NotEmpty().WithMessage("Email address is required.")
+            .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b").WithMessage("Email address is invalid.");
+
+        RuleFor(v => v.Password)
+            .NotEmpty().WithMessage("Password is required.")
+            .MinimumLength(8).WithMessage("Password must be at least 8 characters long.")
+            .MaximumLength(64).WithMessage("Password must be at most 64 characters long.")
+            .Matches(@"(?=.*[A-Z]).*").WithMessage("Password must contain at least one uppercase letter.")
+            .Matches(@"(?=.*[a-z]).*").WithMessage("Password must contain at least one lowercase letter.")
+            .Matches(@"(?=.*[\d]).*").WithMessage("Password must contain at least one digit.")
+            .Matches(@"(?=.*[!@#$%^&*()]).*").WithMessage("Password must contain at least one of the following special charactters: !@#$%^&*().");
+    }
+}

AutobusApi.Application/Identity/Commands/RenewAccessToken/RenewAccessTokenCommand.cs

@@ -0,0 +1,9 @@
+using AutobusApi.Application.Common.Models.Identity;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.RenewAccessToken;
+
+public record RenewAccessTokenCommand : IRequest<TokensModel>
+{
+    public required string RefreshToken { get; set; }
+}

AutobusApi.Application/Identity/Commands/RenewAccessToken/RenewAccessTokenCommandHandler.cs

@@ -0,0 +1,22 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Models.Identity;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.RenewAccessToken;
+
+public class RenewAccessTokenCommandHandler : IRequestHandler<RenewAccessTokenCommand, TokensModel>
+{
+    private readonly IIdentityService _identityService;
+
+    public RenewAccessTokenCommandHandler(IIdentityService identityService)
+    {
+        _identityService = identityService;
+    }
+
+    public async Task<TokensModel> Handle(
+        RenewAccessTokenCommand command,
+        CancellationToken cancellationToken)
+    {
+        return await _identityService.RenewAccessTokenAsync(command.RefreshToken, cancellationToken);
+    }
+}

AutobusApi.Application/Identity/Commands/RenewAccessToken/RenewAccessTokenCommandValidator.cs

@@ -0,0 +1,12 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Identity.Commands.RenewAccessToken;
+
+public class RenewAccessTokenCommandValidator : AbstractValidator<RenewAccessTokenCommand>
+{
+    public RenewAccessTokenCommandValidator()
+    {
+        RuleFor(v => v.RefreshToken)
+            .NotEmpty();
+    }
+}

AutobusApi.Application/Identity/Commands/RevokeRefreshToken/RevokeRefreshTokenCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.RevokeRefreshToken;
+
+public record RevokeRefreshTokenCommand : IRequest 
+{
+    public required string RefreshToken { get; set; }
+}

AutobusApi.Application/Identity/Commands/RevokeRefreshToken/RevokeRefreshTokenCommandHandler.cs

@@ -0,0 +1,21 @@
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Commands.RevokeRefreshToken;
+
+public class RevokeRefreshTokenCommandHandler : IRequestHandler<RevokeRefreshTokenCommand>
+{
+    private readonly IIdentityService _identityService;
+
+    public RevokeRefreshTokenCommandHandler(IIdentityService identityService)
+    {
+        _identityService = identityService;
+    }
+
+    public async Task Handle(
+        RevokeRefreshTokenCommand command,
+        CancellationToken cancellationToken)
+    {
+        await _identityService.RevokeRefreshTokenAsync(command.RefreshToken, cancellationToken);
+    }
+}

AutobusApi.Application/Identity/Commands/RevokeRefreshToken/RevokeRefreshTokenCommandValidator.cs

@@ -0,0 +1,12 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Identity.Commands.RevokeRefreshToken;
+
+public class RevokeRefreshTokenCommandValidator : AbstractValidator<RevokeRefreshTokenCommand>
+{
+    public RevokeRefreshTokenCommandValidator()
+    {
+        RuleFor(v => v.RefreshToken)
+            .NotEmpty();
+    }
+}

AutobusApi.Application/Identity/Queries/Login/LoginQuery.cs

@@ -0,0 +1,11 @@
+using AutobusApi.Application.Common.Models.Identity;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Queries.Login;
+
+public record LoginQuery : IRequest<TokensModel>
+{
+    public required string Email { get; set; }
+
+    public required string Password { get; set; }
+}

AutobusApi.Application/Identity/Queries/Login/LoginQueryHandler.cs

@@ -0,0 +1,22 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Models.Identity;
+using MediatR;
+
+namespace AutobusApi.Application.Identity.Queries.Login;
+
+public class LoginQueryHandler : IRequestHandler<LoginQuery, TokensModel>
+{
+    private readonly IIdentityService _identityService;
+
+    public LoginQueryHandler(IIdentityService identityService)
+    {
+        _identityService = identityService;
+    }
+
+    public async Task<TokensModel> Handle(
+        LoginQuery query,
+        CancellationToken cancellationToken)
+    {
+        return await _identityService.LoginAsync(query.Email, query.Password, cancellationToken);
+    }
+}

AutobusApi.Application/Identity/Queries/Login/LoginQueryValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Identity.Queries.Login;
+
+public class LoginQueryValidator : AbstractValidator<LoginQuery>
+{
+    public LoginQueryValidator()
+    {
+        RuleFor(v => v.Email)
+            .NotEmpty().WithMessage("Email address is required.")
+            .EmailAddress().WithMessage("Email address is invalid.");
+
+        RuleFor(v => v.Password)
+            .NotEmpty().WithMessage("Password is required.");
+    }
+}

AutobusApi.Infrastructure/AutobusApi.Infrastructure.csproj

@@ -7,13 +7,20 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.12" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.13" />
+    <PackageReference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="7.0.3" />
     <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="7.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="7.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.13">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="7.0.11" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL.NetTopologySuite" Version="7.0.11" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\AutobusApi.Domain\AutobusApi.Domain.csproj" />
     <ProjectReference Include="..\AutobusApi.Application\AutobusApi.Application.csproj" />
   </ItemGroup>
 

AutobusApi.Infrastructure/DbInitializer.cs

@@ -0,0 +1,59 @@
+using AutobusApi.Domain.Enums;
+using AutobusApi.Infrastructure.Identity;
+using AutoubsApi.Infrastructure.Data;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Infrastructure;
+
+public static class DbInitializer
+{
+    public static void Initialize(ApplicationDbContext dbContext, ApplicationIdentityDbContext identityDbContext)
+    {
+        if (dbContext.Database.IsRelational())
+        {
+            var domainAppliedMigrations = dbContext.Database.GetAppliedMigrations();
+            var identityAppliedMigrations = identityDbContext.Database.GetAppliedMigrations();
+
+            if (domainAppliedMigrations.Count() == 0)
+            {
+                dbContext.Database.Migrate();
+                InitializeDomain(dbContext);
+            }
+
+            if (identityAppliedMigrations.Count() == 0)
+            {
+                identityDbContext.Database.Migrate();
+                InitializeIdentity(identityDbContext);
+            }
+        }
+        else
+        {
+            dbContext.Database.EnsureCreated();
+            InitializeDomain(dbContext);
+
+            identityDbContext.Database.EnsureCreated();
+            InitializeIdentity(identityDbContext);
+        }
+    }
+
+    private static void InitializeDomain(ApplicationDbContext dbContext)
+    {
+
+    }
+
+    private static void InitializeIdentity(ApplicationIdentityDbContext identityDbContext)
+    {
+        foreach (var role in Enum.GetValues(typeof(IdentityRoles)).Cast<IdentityRoles>())
+        {
+            identityDbContext.Roles.Add(new IdentityRole<int>
+            {
+                Name = role.ToString(),
+                NormalizedName = role.ToString().ToUpper(),
+                ConcurrencyStamp = Guid.NewGuid().ToString()
+            });
+        }
+
+        identityDbContext.SaveChanges();
+    }
+}

AutobusApi.Infrastructure/DependencyInjection.cs

@@ -0,0 +1,89 @@
+using System.Text;
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Infrastructure.Identity;
+using AutobusApi.Infrastructure.Services;
+using AutoubsApi.Infrastructure.Data;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
+
+namespace AutobusApi.Infrastructure;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddApplicationDbContext(configuration);
+        services.AddIdentity(configuration);
+        services.AddServices();
+        services.AddAuthentication();
+
+        return services;
+    }
+
+    private static IServiceCollection AddApplicationDbContext(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddDbContext<ApplicationDbContext>(options =>
+        {
+            options.UseNpgsql(
+                configuration.GetConnectionString("DefaultConnection"),
+                npgsqOptions => npgsqOptions.UseNetTopologySuite()
+            );
+        });
+
+        services.AddScoped<IApplicationDbContext, ApplicationDbContext>();
+
+        return services;
+    }
+
+    private static IServiceCollection AddIdentity(this IServiceCollection services, IConfiguration configuration)
+    {
+
+        services.AddDbContext<ApplicationIdentityDbContext>(options =>
+        {
+            options.UseNpgsql(configuration.GetConnectionString("DefaultConnection"));
+        });
+
+        services.AddIdentity<ApplicationUser, IdentityRole<int>>()
+            .AddEntityFrameworkStores<ApplicationIdentityDbContext>()
+            .AddDefaultTokenProviders();
+
+        return services;
+    }
+
+    private static IServiceCollection AddServices(this IServiceCollection services)
+    {
+        services.AddScoped<IIdentityService, IdentityService>();
+
+        return services;
+    }
+
+    private static IServiceCollection AddAuthenticationWithJwt(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddAuthentication(options =>
+        {
+            options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+            options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+            options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
+        })
+        .AddJwtBearer(options =>
+        {
+            options.SaveToken = true;
+            options.RequireHttpsMetadata = false;
+            options.TokenValidationParameters = new TokenValidationParameters()
+            {
+                ValidateIssuer = true,
+                ValidateAudience = true,
+                ValidAudience = configuration["Jwt:Audience"],
+                ValidIssuer = configuration["Jwt:Issuer"],
+                ClockSkew = TimeSpan.Zero,
+                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Jwt:IssuerSigningKey"]!))
+            };
+        });
+
+        return services;
+    }
+}

AutobusApi.Infrastructure/Identity/ApplicationIdentityDbContext.cs

@@ -0,0 +1,24 @@
+using System.Reflection;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Infrastructure.Identity;
+
+public class ApplicationIdentityDbContext : IdentityDbContext<ApplicationUser, IdentityRole<int>, int>
+{
+    public ApplicationIdentityDbContext(DbContextOptions<ApplicationIdentityDbContext> options)
+        : base(options) { }
+
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        base.OnModelCreating(builder);
+
+        builder.HasDefaultSchema("identity");
+
+        builder.ApplyConfigurationsFromAssembly(
+            Assembly.GetExecutingAssembly(),
+            t => t.Namespace == "AutobusApi.Infrastructure.Identity.Configurations"
+        );
+    }
+}

AutobusApi.Infrastructure/Identity/ApplicationUser.cs

@@ -0,0 +1,8 @@
+using Microsoft.AspNetCore.Identity;
+
+namespace AutobusApi.Infrastructure.Identity;
+
+public class ApplicationUser : IdentityUser<int>
+{
+    public ICollection<RefreshToken> RefreshTokens { get; set; } = null!;
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityRoleClaimConfiguration.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityRoleClaimConfiguration : IEntityTypeConfiguration<IdentityRoleClaim<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityRoleClaim<int>> builder)
+    {
+        builder
+            .ToTable("identity_role_claims");
+
+        builder
+            .Property(rc => rc.Id)
+            .HasColumnName("id");
+
+        builder
+            .Property(rc => rc.RoleId)
+            .HasColumnName("role_id");
+
+        builder
+            .Property(rc => rc.ClaimType)
+            .HasColumnName("claim_type");
+
+        builder
+            .Property(rc => rc.ClaimValue)
+            .HasColumnName("claim_value");
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityRoleConfiguration.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityRoleConfiguration : IEntityTypeConfiguration<IdentityRole<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityRole<int>> builder)
+    {
+        builder
+            .ToTable("identity_roles");
+
+        builder
+            .Property(r => r.Id)
+            .HasColumnName("id");
+
+        builder
+            .Property(r => r.Name)
+            .HasColumnName("name");
+
+        builder
+            .Property(r => r.NormalizedName)
+            .HasColumnName("normalized_name");
+
+        builder
+            .Property(r => r.ConcurrencyStamp)
+            .HasColumnName("concurrency_stamp");
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityUserClaimConfiguration.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityUserClaimConfiguration : IEntityTypeConfiguration<IdentityUserClaim<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityUserClaim<int>> builder)
+    {
+        builder
+            .ToTable("identity_user_claims");
+
+        builder
+            .Property(uc => uc.Id)
+            .HasColumnName("id");
+
+        builder
+            .Property(uc => uc.UserId)
+            .HasColumnName("user_id");
+
+        builder
+            .Property(uc => uc.ClaimType)
+            .HasColumnName("claim_type");
+
+        builder
+            .Property(uc => uc.ClaimValue)
+            .HasColumnName("claim_value");
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityUserConfiguration.cs

@@ -0,0 +1,123 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityUserConfiguration : IEntityTypeConfiguration<ApplicationUser>
+{
+    public void Configure(EntityTypeBuilder<ApplicationUser> builder)
+    {
+        builder
+            .ToTable("identity_users");
+
+        // builder
+        //     .Ignore(u => u.UserName);
+        //
+        // builder
+        //     .Ignore(u => u.NormalizedUserName);
+
+        builder
+            .Ignore(u => u.PhoneNumber);
+
+        builder
+            .Ignore(u => u.PhoneNumberConfirmed);
+
+        builder
+            .Property(u => u.Id)
+            .HasColumnName("id");
+
+        builder
+            .Property(u => u.Email)
+            .HasColumnName("email");
+
+        builder
+            .Property(u => u.NormalizedEmail)
+            .HasColumnName("normalized_email");
+
+        builder
+            .Property(u => u.EmailConfirmed)
+            .HasColumnName("email_confirmed");
+
+        builder
+            .Property(u => u.PasswordHash)
+            .HasColumnName("password_hash");
+
+        builder
+            .Property(u => u.SecurityStamp)
+            .HasColumnName("security_stamp");
+
+        builder
+            .Property(u => u.ConcurrencyStamp)
+            .HasColumnName("concurrency_stamp");
+
+        builder
+            .Property(u => u.TwoFactorEnabled)
+            .HasColumnName("two_factor_enabled");
+
+        builder
+            .Property(u => u.LockoutEnabled)
+            .HasColumnName("lockout_enabled");
+
+        builder
+            .Property(u => u.LockoutEnd)
+            .HasColumnName("lockout_end");
+
+        builder
+            .Property(u => u.AccessFailedCount)
+            .HasColumnName("access_failed_count");
+
+        builder
+            .OwnsMany(u => u.RefreshTokens,
+                refreshToken =>
+                {
+                    refreshToken
+                        .ToTable("identity_user_refresh_tokens");
+
+                    refreshToken
+                        .HasKey(rt => rt.Id)
+                        .HasName("id");
+
+                    refreshToken
+                        .WithOwner(rt => rt.ApplicationUser)
+                        .HasForeignKey(rt => rt.ApplicationUserId)
+                        .HasConstraintName("fk_identityUserRefreshTokens_identityUser_userId");
+
+                    refreshToken
+                        .Property(rt => rt.Id)
+                        .HasColumnName("id")
+                        .HasColumnType("int")
+                        .IsRequired();
+
+                    refreshToken
+                        .Property(rt => rt.ApplicationUserId)
+                        .HasColumnName("identity_user_id")
+                        .HasColumnType("int")
+                        .IsRequired();
+
+                    refreshToken
+                        .Property(rt => rt.Value)
+                        .HasColumnName("value")
+                        .HasColumnType("varchar(256)")
+                        .IsRequired();
+
+                    refreshToken
+                        .Property(rt => rt.CreationDateTimeUtc)
+                        .HasColumnName("creation_timestamp_utc")
+                        .HasColumnType("timestamptz")
+                        .IsRequired();
+
+                    refreshToken
+                        .Property(rt => rt.ExpirationDateTimeUtc)
+                        .HasColumnName("expiration_timestamp_utc")
+                        .HasColumnType("timestamptz")
+                        .IsRequired();
+
+                    refreshToken
+                        .Property(rt => rt.RevokationDateTimeUtc)
+                        .HasColumnName("revokation_timestamp_utc")
+                        .HasColumnType("timestamptz")
+                        .IsRequired(false);
+                }
+            );
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityUserLoginConfigurations.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityUserLoginConfiguration : IEntityTypeConfiguration<IdentityUserLogin<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityUserLogin<int>> builder)
+    {
+        builder
+            .ToTable("identity_user_logins");
+
+        builder
+            .Property(ul => ul.LoginProvider)
+            .HasColumnName("login_provider");
+
+        builder
+            .Property(ul => ul.ProviderKey)
+            .HasColumnName("provider_key");
+
+        builder
+            .Property(ul => ul.ProviderDisplayName)
+            .HasColumnName("provider_display_name");
+
+        builder
+            .Property(ul => ul.UserId)
+            .HasColumnName("user_id");
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityUserRoleConfiguration.cs

@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityUserRoleConfiguration : IEntityTypeConfiguration<IdentityUserRole<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityUserRole<int>> builder)
+    {
+        builder
+            .ToTable("identity_user_roles");
+
+        builder
+            .Property(ur => ur.UserId)
+            .HasColumnName("user_id");
+
+        builder
+            .Property(ur => ur.RoleId)
+            .HasColumnName("role_id");
+    }
+}

AutobusApi.Infrastructure/Identity/Configurations/IdentityUserTokenConfiguration.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace AutobusApi.Infrastructure.Identity.Configurations;
+
+public class IdentityUserTokenConfiguration : IEntityTypeConfiguration<IdentityUserToken<int>>
+{
+    public void Configure(EntityTypeBuilder<IdentityUserToken<int>> builder)
+    {
+        builder
+            .ToTable("identity_user_tokens");
+
+        builder
+            .Property(ut => ut.UserId)
+            .HasColumnName("user_id");
+
+        builder
+            .Property(ut => ut.LoginProvider)
+            .HasColumnName("login_provider");
+
+        builder
+            .Property(ut => ut.Name)
+            .HasColumnName("name");
+
+        builder
+            .Property(ut => ut.Value)
+            .HasColumnName("value");
+    }
+}

AutobusApi.Infrastructure/Identity/Migrations/20231113193302_InitialCreate.Designer.cs

@@ -0,0 +1,357 @@
+// <auto-generated />
+using System;
+using AutobusApi.Infrastructure.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace AutobusApi.Infrastructure.Identity.Migrations
+{
+    [DbContext(typeof(ApplicationIdentityDbContext))]
+    [Migration("20231113193302_InitialCreate")]
+    partial class InitialCreate
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("identity")
+                .HasAnnotation("ProductVersion", "7.0.13")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AutobusApi.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer")
+                        .HasColumnName("access_failed_count");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text")
+                        .HasColumnName("concurrency_stamp");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("email");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean")
+                        .HasColumnName("email_confirmed");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("lockout_enabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("lockout_end");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("normalized_email");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text")
+                        .HasColumnName("password_hash");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text")
+                        .HasColumnName("security_stamp");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("two_factor_enabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("identity_users", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text")
+                        .HasColumnName("concurrency_stamp");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("normalized_name");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("identity_roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_type");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_value");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("identity_role_claims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_type");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_value");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("identity_user_claims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text")
+                        .HasColumnName("login_provider");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text")
+                        .HasColumnName("provider_key");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text")
+                        .HasColumnName("provider_display_name");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("identity_user_logins", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<int>", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("identity_user_roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text")
+                        .HasColumnName("login_provider");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text")
+                        .HasColumnName("value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("identity_user_tokens", "identity");
+                });
+
+            modelBuilder.Entity("AutobusApi.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.OwnsMany("AutobusApi.Infrastructure.Identity.RefreshToken", "RefreshTokens", b1 =>
+                        {
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasColumnName("id");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<int>("ApplicationUserId")
+                                .HasColumnType("int")
+                                .HasColumnName("identity_user_id");
+
+                            b1.Property<DateTime>("CreationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("creation_timestamp_utc");
+
+                            b1.Property<DateTime>("ExpirationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("expiration_timestamp_utc");
+
+                            b1.Property<DateTime?>("RevokationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("revokation_timestamp_utc");
+
+                            b1.Property<string>("Value")
+                                .IsRequired()
+                                .HasColumnType("varchar(256)")
+                                .HasColumnName("value");
+
+                            b1.HasKey("Id")
+                                .HasName("id");
+
+                            b1.HasIndex("ApplicationUserId");
+
+                            b1.ToTable("identity_user_refresh_tokens", "identity");
+
+                            b1.WithOwner("ApplicationUser")
+                                .HasForeignKey("ApplicationUserId")
+                                .HasConstraintName("fk_identityUserRefreshTokens_identityUser_userId");
+
+                            b1.Navigation("ApplicationUser");
+                        });
+
+                    b.Navigation("RefreshTokens");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<int>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<int>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<int>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

AutobusApi.Infrastructure/Identity/Migrations/20231113193302_InitialCreate.cs

@@ -0,0 +1,288 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace AutobusApi.Infrastructure.Identity.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialCreate : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "identity");
+
+            migrationBuilder.CreateTable(
+                name: "identity_roles",
+                schema: "identity",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    normalized_name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    concurrency_stamp = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_roles", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_users",
+                schema: "identity",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    normalized_email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    email_confirmed = table.Column<bool>(type: "boolean", nullable: false),
+                    password_hash = table.Column<string>(type: "text", nullable: true),
+                    security_stamp = table.Column<string>(type: "text", nullable: true),
+                    concurrency_stamp = table.Column<string>(type: "text", nullable: true),
+                    two_factor_enabled = table.Column<bool>(type: "boolean", nullable: false),
+                    lockout_end = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    lockout_enabled = table.Column<bool>(type: "boolean", nullable: false),
+                    access_failed_count = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_users", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_role_claims",
+                schema: "identity",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    role_id = table.Column<int>(type: "integer", nullable: false),
+                    claim_type = table.Column<string>(type: "text", nullable: true),
+                    claim_value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_role_claims", x => x.id);
+                    table.ForeignKey(
+                        name: "FK_identity_role_claims_identity_roles_role_id",
+                        column: x => x.role_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_roles",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_user_claims",
+                schema: "identity",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    user_id = table.Column<int>(type: "integer", nullable: false),
+                    claim_type = table.Column<string>(type: "text", nullable: true),
+                    claim_value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_user_claims", x => x.id);
+                    table.ForeignKey(
+                        name: "FK_identity_user_claims_identity_users_user_id",
+                        column: x => x.user_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_users",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_user_logins",
+                schema: "identity",
+                columns: table => new
+                {
+                    login_provider = table.Column<string>(type: "text", nullable: false),
+                    provider_key = table.Column<string>(type: "text", nullable: false),
+                    provider_display_name = table.Column<string>(type: "text", nullable: true),
+                    user_id = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_user_logins", x => new { x.login_provider, x.provider_key });
+                    table.ForeignKey(
+                        name: "FK_identity_user_logins_identity_users_user_id",
+                        column: x => x.user_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_users",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_user_refresh_tokens",
+                schema: "identity",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    value = table.Column<string>(type: "varchar(256)", nullable: false),
+                    creation_timestamp_utc = table.Column<DateTime>(type: "timestamptz", nullable: false),
+                    expiration_timestamp_utc = table.Column<DateTime>(type: "timestamptz", nullable: false),
+                    revokation_timestamp_utc = table.Column<DateTime>(type: "timestamptz", nullable: true),
+                    identity_user_id = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("id", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_identityUserRefreshTokens_identityUser_userId",
+                        column: x => x.identity_user_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_users",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_user_roles",
+                schema: "identity",
+                columns: table => new
+                {
+                    user_id = table.Column<int>(type: "integer", nullable: false),
+                    role_id = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_user_roles", x => new { x.user_id, x.role_id });
+                    table.ForeignKey(
+                        name: "FK_identity_user_roles_identity_roles_role_id",
+                        column: x => x.role_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_roles",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_identity_user_roles_identity_users_user_id",
+                        column: x => x.user_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_users",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "identity_user_tokens",
+                schema: "identity",
+                columns: table => new
+                {
+                    user_id = table.Column<int>(type: "integer", nullable: false),
+                    login_provider = table.Column<string>(type: "text", nullable: false),
+                    name = table.Column<string>(type: "text", nullable: false),
+                    value = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_identity_user_tokens", x => new { x.user_id, x.login_provider, x.name });
+                    table.ForeignKey(
+                        name: "FK_identity_user_tokens_identity_users_user_id",
+                        column: x => x.user_id,
+                        principalSchema: "identity",
+                        principalTable: "identity_users",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_identity_role_claims_role_id",
+                schema: "identity",
+                table: "identity_role_claims",
+                column: "role_id");
+
+            migrationBuilder.CreateIndex(
+                name: "RoleNameIndex",
+                schema: "identity",
+                table: "identity_roles",
+                column: "normalized_name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_identity_user_claims_user_id",
+                schema: "identity",
+                table: "identity_user_claims",
+                column: "user_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_identity_user_logins_user_id",
+                schema: "identity",
+                table: "identity_user_logins",
+                column: "user_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_identity_user_refresh_tokens_identity_user_id",
+                schema: "identity",
+                table: "identity_user_refresh_tokens",
+                column: "identity_user_id");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_identity_user_roles_role_id",
+                schema: "identity",
+                table: "identity_user_roles",
+                column: "role_id");
+
+            migrationBuilder.CreateIndex(
+                name: "EmailIndex",
+                schema: "identity",
+                table: "identity_users",
+                column: "normalized_email");
+
+            migrationBuilder.CreateIndex(
+                name: "UserNameIndex",
+                schema: "identity",
+                table: "identity_users",
+                column: "NormalizedUserName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "identity_role_claims",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_user_claims",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_user_logins",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_user_refresh_tokens",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_user_roles",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_user_tokens",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_roles",
+                schema: "identity");
+
+            migrationBuilder.DropTable(
+                name: "identity_users",
+                schema: "identity");
+        }
+    }
+}

AutobusApi.Infrastructure/Identity/Migrations/ApplicationIdentityDbContextModelSnapshot.cs

@@ -0,0 +1,354 @@
+// <auto-generated />
+using System;
+using AutobusApi.Infrastructure.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace AutobusApi.Infrastructure.Identity.Migrations
+{
+    [DbContext(typeof(ApplicationIdentityDbContext))]
+    partial class ApplicationIdentityDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("identity")
+                .HasAnnotation("ProductVersion", "7.0.13")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AutobusApi.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer")
+                        .HasColumnName("access_failed_count");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text")
+                        .HasColumnName("concurrency_stamp");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("email");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean")
+                        .HasColumnName("email_confirmed");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("lockout_enabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("lockout_end");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("normalized_email");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text")
+                        .HasColumnName("password_hash");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text")
+                        .HasColumnName("security_stamp");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("two_factor_enabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("identity_users", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text")
+                        .HasColumnName("concurrency_stamp");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("normalized_name");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("identity_roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_type");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_value");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("identity_role_claims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_type");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text")
+                        .HasColumnName("claim_value");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("identity_user_claims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text")
+                        .HasColumnName("login_provider");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text")
+                        .HasColumnName("provider_key");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text")
+                        .HasColumnName("provider_display_name");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("identity_user_logins", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<int>", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("identity_user_roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text")
+                        .HasColumnName("login_provider");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text")
+                        .HasColumnName("value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("identity_user_tokens", "identity");
+                });
+
+            modelBuilder.Entity("AutobusApi.Infrastructure.Identity.ApplicationUser", b =>
+                {
+                    b.OwnsMany("AutobusApi.Infrastructure.Identity.RefreshToken", "RefreshTokens", b1 =>
+                        {
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int")
+                                .HasColumnName("id");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<int>("ApplicationUserId")
+                                .HasColumnType("int")
+                                .HasColumnName("identity_user_id");
+
+                            b1.Property<DateTime>("CreationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("creation_timestamp_utc");
+
+                            b1.Property<DateTime>("ExpirationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("expiration_timestamp_utc");
+
+                            b1.Property<DateTime?>("RevokationDateTimeUtc")
+                                .HasColumnType("timestamptz")
+                                .HasColumnName("revokation_timestamp_utc");
+
+                            b1.Property<string>("Value")
+                                .IsRequired()
+                                .HasColumnType("varchar(256)")
+                                .HasColumnName("value");
+
+                            b1.HasKey("Id")
+                                .HasName("id");
+
+                            b1.HasIndex("ApplicationUserId");
+
+                            b1.ToTable("identity_user_refresh_tokens", "identity");
+
+                            b1.WithOwner("ApplicationUser")
+                                .HasForeignKey("ApplicationUserId")
+                                .HasConstraintName("fk_identityUserRefreshTokens_identityUser_userId");
+
+                            b1.Navigation("ApplicationUser");
+                        });
+
+                    b.Navigation("RefreshTokens");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<int>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<int>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<int>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole<int>", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<int>", b =>
+                {
+                    b.HasOne("AutobusApi.Infrastructure.Identity.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

AutobusApi.Infrastructure/Identity/RefreshToken.cs

@@ -0,0 +1,22 @@
+namespace AutobusApi.Infrastructure.Identity;
+
+public class RefreshToken
+{
+    public int Id { get; set; }
+
+    public string Value { get; set; } = null!;
+
+    public DateTime CreationDateTimeUtc { get; set; }
+
+    public DateTime ExpirationDateTimeUtc { get; set; }
+
+    public DateTime? RevokationDateTimeUtc { get; set; }
+
+    public bool IsExpired => DateTime.UtcNow >= ExpirationDateTimeUtc;
+
+    public bool IsActive => RevokationDateTimeUtc is null && !IsExpired;
+
+    public int ApplicationUserId { get; set; }
+
+    public ApplicationUser ApplicationUser { get; set; } = null!;
+}

AutobusApi.Infrastructure/Services/IdentityService.cs

@@ -0,0 +1,174 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Security.Cryptography;
+using System.Text;
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Models.Identity;
+using AutobusApi.Domain.Enums;
+using AutobusApi.Infrastructure.Identity;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.IdentityModel.Tokens;
+
+namespace AutobusApi.Infrastructure.Services;
+
+public class IdentityService : IIdentityService 
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly IConfiguration _configuration;
+
+    public IdentityService(
+        UserManager<ApplicationUser> userManager,
+        IConfiguration configuration)
+    {
+        _userManager = userManager;
+        _configuration = configuration;
+    }
+
+    public async Task RegisterAsync(
+        string email,
+        string password,
+        CancellationToken cancellationToken)
+    {
+        var userWithSameEmail = await _userManager.FindByEmailAsync(email);
+        if (userWithSameEmail is not null)
+        {
+            throw new RegistrationException("User with given email already registered.");
+        }
+
+        var newUser = new ApplicationUser
+        {
+            UserName = email,
+            Email = email
+        };
+
+        var createUserResult = await _userManager.CreateAsync(newUser, password);
+        var addToRoleResult = await _userManager.AddToRoleAsync(newUser, IdentityRoles.User.ToString());
+    }
+
+    public async Task<TokensModel> LoginAsync(
+        string email,
+        string password,
+        CancellationToken cancellationToken)
+    {
+        var user = await _userManager.FindByEmailAsync(email);
+        if (user is null)
+        {
+            throw new LoginException("No users registered with given email.");
+        }
+
+        var isPasswordCorrect = await _userManager.CheckPasswordAsync(user, password);
+        if (!isPasswordCorrect)
+        {
+            throw new LoginException("Given password is incorrect.");
+        }
+
+        var jwtSecurityToken = await CreateJwtAsync(user, cancellationToken);
+        var accessToken = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
+
+        var refreshToken = user.RefreshTokens.FirstOrDefault(t => t.IsActive);
+        if (refreshToken is null)
+        {
+            refreshToken = CreateRefreshToken();
+            user.RefreshTokens.Add(refreshToken);
+            await _userManager.UpdateAsync(user);
+        }
+
+        return new TokensModel(accessToken, refreshToken.Value);
+    }
+
+    public async Task<TokensModel> RenewAccessTokenAsync(
+        string refreshToken,
+        CancellationToken cancellationToken)
+    {
+        var user = await _userManager.Users.SingleOrDefaultAsync(u => u.RefreshTokens.Any(rt => rt.Value == refreshToken));
+        if (user is null)
+        {
+            throw new RenewAccessTokenException($"Refresh token {refreshToken} was not found.");
+        }
+
+        var refreshTokenObject = user.RefreshTokens.Single(rt => rt.Value == refreshToken);
+        if (!refreshTokenObject.IsActive)
+        {
+            throw new RenewAccessTokenException("Refresh token is inactive.");
+        }
+
+        var jwtSecurityToken = await CreateJwtAsync(user, cancellationToken);
+        var accessToken = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
+
+        return new TokensModel(accessToken, refreshToken);
+    }
+
+    public async Task RevokeRefreshTokenAsync(
+        string refreshToken,
+        CancellationToken cancellationToken)
+    {
+        var user = await _userManager.Users.SingleOrDefaultAsync(u => u.RefreshTokens.Any(t => t.Value == refreshToken));
+        if (user is null)
+        {
+            throw new RevokeRefreshTokenException("Invalid refreshToken");
+        }
+
+        var refreshTokenObject = user.RefreshTokens.Single(x => x.Value == refreshToken);
+        if (!refreshTokenObject.IsActive)
+        {
+            throw new RevokeRefreshTokenException("RefreshToken already revoked");
+        }
+
+        refreshTokenObject.RevokationDateTimeUtc = DateTime.UtcNow;
+        await _userManager.UpdateAsync(user);
+    }
+
+    private async Task<JwtSecurityToken> CreateJwtAsync(
+        ApplicationUser user,
+        CancellationToken cancellationToken)
+    {
+        var userClaims = await _userManager.GetClaimsAsync(user);
+
+        var roles = await _userManager.GetRolesAsync(user);
+        var roleClaims = new List<Claim>();
+        foreach (var role in roles)
+        {
+            roleClaims.Add(new Claim("roles", role));
+        }
+
+        var claims = new List<Claim>()
+        {
+            new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
+            new Claim(JwtRegisteredClaimNames.Email, user.Email)
+        }
+        .Union(userClaims)
+        .Union(roleClaims);
+
+        var jwtExpirationDateTimeUtc = DateTime.UtcNow.AddMinutes(Double.Parse(_configuration["Jwt:AccessTokenValidityInMinutes"]));
+
+        var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:IssuerSigningKey"]));
+        var signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256);
+
+        var jwtSecurityToken = new JwtSecurityToken(
+            issuer: _configuration["Jwt:Issuer"],
+            audience: _configuration["Jwt:Audience"],
+            claims: claims,
+            expires: jwtExpirationDateTimeUtc,
+            signingCredentials: signingCredentials);
+
+        return jwtSecurityToken;
+    }
+
+    private RefreshToken CreateRefreshToken()
+    {
+        var randomNumber = new byte[32];
+
+        using var rng = RandomNumberGenerator.Create();
+        rng.GetNonZeroBytes(randomNumber);
+
+        return new RefreshToken
+        {
+            Value = Convert.ToBase64String(randomNumber),
+            CreationDateTimeUtc = DateTime.UtcNow,
+            ExpirationDateTimeUtc = DateTime.UtcNow.AddDays(Double.Parse(_configuration["Jwt:RefreshTokenValidityInDays"]))
+        };
+    }
+}

AutobusApi.IntegrationTests/AutobusApi.IntegrationTests.csproj

@@ -1,24 +1,28 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
-    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-  </ItemGroup>
-
-</Project>
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.13" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.13" />
+
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.6.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AutobusApi.Api\AutobusApi.Api.csproj" />
+  </ItemGroup>
+
+</Project>

AutobusApi.IntegrationTests/CustomWebApplicationFactory.cs

@@ -0,0 +1,46 @@
+using System.Data.Common;
+using AutobusApi.Infrastructure.Identity;
+using AutoubsApi.Infrastructure.Data;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.IntegrationTests;
+
+public class CustomWebApplicationFactory<TProgram>
+    : WebApplicationFactory<TProgram> where TProgram : class
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.ConfigureServices(services =>
+        {
+            var dbContextDescriptor = services.SingleOrDefault(
+                d => d.ServiceType ==
+                    typeof(DbContextOptions<ApplicationDbContext>));
+
+            services.Remove(dbContextDescriptor);
+
+            var identityDbContextDescriptor = services.SingleOrDefault(
+                d => d.ServiceType ==
+                    typeof(DbContextOptions<ApplicationIdentityDbContext>));
+
+            services.Remove(identityDbContextDescriptor);
+
+            var dbConnectionDescriptor = services.SingleOrDefault(
+                d => d.ServiceType ==
+                    typeof(DbConnection));
+
+            services.Remove(dbConnectionDescriptor);
+
+            services.AddDbContext<ApplicationDbContext>((container, options) =>
+            {
+                options.UseInMemoryDatabase("autobus");
+            });
+
+            services.AddDbContext<ApplicationIdentityDbContext>((container, options) =>
+            {
+                options.UseInMemoryDatabase("autobus");
+            });
+        });
+
+        builder.UseEnvironment("Development");
+    }}

AutobusApi.IntegrationTests/DbInitializer.cs

@@ -0,0 +1,24 @@
+using AutobusApi.Infrastructure.Identity;
+using AutoubsApi.Infrastructure.Data;
+
+namespace AutobusApi.IntegrationTests;
+
+public static class DbInitializer
+{
+    public static void Initialize(ApplicationDbContext dbContext, ApplicationIdentityDbContext identityDbContext)
+    {
+        AutobusApi.Infrastructure.DbInitializer.Initialize(dbContext, identityDbContext);
+        InitializeDomain(dbContext);
+        InitializeIdentity(identityDbContext);
+    }
+
+    private static void InitializeDomain(ApplicationDbContext dbContext)
+    {
+
+    }
+
+    private static void InitializeIdentity(ApplicationIdentityDbContext identityDbContext)
+    {
+        
+    }
+}

AutobusApi.IntegrationTests/Tests/IdentityTests.cs

@@ -0,0 +1,203 @@
+using System.Net;
+using Newtonsoft.Json;
+
+namespace AutobusApi.IntegrationTests.Tests;
+
+public class IdentityTests : TestsBase
+{
+    public IdentityTests(CustomWebApplicationFactory<Program> factory)
+        : base(factory) {}
+
+    [Theory]
+    [InlineData("valid@email.xyz", "12qw!@QW")]
+    [InlineData("address@gmail.com", "123qwe!@#QWE")]
+    public async Task Register_ValidCredentials_Returns200Ok(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var response = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("email.xyz", "12qw!@QW")]
+    [InlineData("invalid.email.xyz", "12qw!@QW")]
+    [InlineData("invalid@email", "12qw!@QW")]
+    [InlineData("invalid@email.", "12qw!@QW")]
+    [InlineData("invalid@email.c", "12qw!@QW")]
+    [InlineData("@email.xyz", "12qw!@QW")]
+    public async Task Register_InvalidEmail_Returns400BadRequest(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var response = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("address@email.xyz", "1q!Q")] // Length is less than minimum (8)
+    [InlineData("address@email.xyz", "12qw!@QW12qw!@QW12qw!@QW12qw!@QW12qw!@QW12qw!@QW12qw!@QW12qw!@QW_")] // Length is greater than maximum (64)
+    [InlineData("address@email.xyz", "123456Qq")] // No special characters
+    [InlineData("address@email.xyz", "123456q#")] // No uppercase letters characters
+    [InlineData("address@email.xyz", "123456Q#")] // No lowercase letters characters
+    public async Task Register_InvalidPassword_Returns400BadRequest(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var response = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("some.address@gmail.com", "Vw35Vpn*A&lzX&)(ghAEX9\"@/Xt\"ip+0")]
+    [InlineData("mail@mydomain.xyz", "Pa$$w0rD")]
+    public async Task RegisterAndLogin_ValidCredentials_Returns200OK(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var registrationResponse = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+        Assert.Equal(HttpStatusCode.OK, registrationResponse.StatusCode);
+
+        var loginResponse = await _httpClient.PostAsJsonAsync("identity/login", credentials);
+        Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
+
+        var loginResponseContent = JsonConvert.DeserializeObject<dynamic>(await loginResponse.Content.ReadAsStringAsync());
+        Assert.NotNull(loginResponseContent);
+        Assert.NotNull(loginResponseContent!.accessToken);
+        Assert.NotEmpty((string) loginResponseContent!.accessToken);
+        Assert.NotNull(loginResponseContent!.refreshToken);
+        Assert.NotEmpty((string) loginResponseContent!.refreshToken);
+    }
+
+    [Theory]
+    [InlineData("not.registered@email.xyz", "12qw!@QW")]
+    public async Task Login_InvalidCredentials_Returns400BadRequest(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var response = await _httpClient.PostAsJsonAsync("identity/login", credentials);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("some.address@gmail.com", "Vw35Vpn*A&lzX&)(ghAEX9\"@/Xt\"ip+0", 10)]
+    public async Task RegisterThenLoginThenRenewAccessToken_ValidCredentials_Returns200OK(string email, string password, int renewCout)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var registrationResponse = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+        Assert.Equal(HttpStatusCode.OK, registrationResponse.StatusCode);
+
+        var loginResponse = await _httpClient.PostAsJsonAsync("identity/login", credentials);
+        Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
+
+        var loginResponseContent = JsonConvert.DeserializeObject<dynamic>(await loginResponse.Content.ReadAsStringAsync());
+        Assert.NotNull(loginResponseContent);
+        Assert.NotNull(loginResponseContent!.accessToken);
+        Assert.NotEmpty((string) loginResponseContent!.accessToken);
+        Assert.NotNull(loginResponseContent!.refreshToken);
+        Assert.NotEmpty((string) loginResponseContent!.refreshToken);
+
+        for (int i = 0; i < renewCout; i++)
+        {
+            var renewAccessTokenRequestBody = new { refreshToken = (string) loginResponseContent!.refreshToken };
+            var renewAccessTokenResponse = await _httpClient.PostAsJsonAsync("identity/renewAccessToken", renewAccessTokenRequestBody);
+            Assert.Equal(HttpStatusCode.OK, renewAccessTokenResponse.StatusCode);
+
+            var renewAccessTokenResponseContent =
+                JsonConvert.DeserializeObject<dynamic>(await renewAccessTokenResponse.Content.ReadAsStringAsync());
+            Assert.NotNull(renewAccessTokenResponseContent);
+            Assert.NotNull(renewAccessTokenResponseContent!.accessToken);
+            Assert.NotEmpty((string) renewAccessTokenResponseContent!.accessToken);
+            Assert.NotNull(renewAccessTokenResponseContent!.refreshToken);
+            Assert.NotEmpty((string) renewAccessTokenResponseContent!.refreshToken);
+        }
+    }
+
+    [Theory]
+    [InlineData("some.address@gmail.com", "Vw35Vpn*A&lzX&)(ghAEX9\"@/Xt\"ip+0")]
+    public async Task RegisterThenLoginThenRevokeRefreshToken_ValidCredentials_Returns200OK(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var registrationResponse = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+        Assert.Equal(HttpStatusCode.OK, registrationResponse.StatusCode);
+
+        var loginResponse = await _httpClient.PostAsJsonAsync("identity/login", credentials);
+        Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
+
+        var loginResponseContent = JsonConvert.DeserializeObject<dynamic>(await loginResponse.Content.ReadAsStringAsync());
+        Assert.NotNull(loginResponseContent);
+        Assert.NotNull(loginResponseContent!.accessToken);
+        Assert.NotEmpty((string) loginResponseContent!.accessToken);
+        Assert.NotNull(loginResponseContent!.refreshToken);
+        Assert.NotEmpty((string) loginResponseContent!.refreshToken);
+
+        var revokeRefreshTokenRequestBody = new { refreshToken = (string) loginResponseContent!.refreshToken };
+        var revokeRefreshTokenResponse = await _httpClient.PostAsJsonAsync("identity/revokeRefreshToken", revokeRefreshTokenRequestBody);
+        Assert.Equal(HttpStatusCode.OK, revokeRefreshTokenResponse.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("some.address@gmail.com", "Vw35Vpn*A&lzX&)(ghAEX9\"@/Xt\"ip+0")]
+    public async Task RegisterThenLoginThenRevokeRefreshTokenTwice_ValidCredentials_Returns400BadRequest(string email, string password)
+    {
+        var credentials = new
+        {
+            Email = email,
+            Password = password
+        };
+
+        var registrationResponse = await _httpClient.PostAsJsonAsync("identity/register", credentials);
+        Assert.Equal(HttpStatusCode.OK, registrationResponse.StatusCode);
+
+        var loginResponse = await _httpClient.PostAsJsonAsync("identity/login", credentials);
+        Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
+
+        var loginResponseContent = JsonConvert.DeserializeObject<dynamic>(await loginResponse.Content.ReadAsStringAsync());
+        Assert.NotNull(loginResponseContent);
+        Assert.NotNull(loginResponseContent!.accessToken);
+        Assert.NotEmpty((string) loginResponseContent!.accessToken);
+        Assert.NotNull(loginResponseContent!.refreshToken);
+        Assert.NotEmpty((string) loginResponseContent!.refreshToken);
+
+        var revokeRefreshTokenRequestBody = new { refreshToken = (string) loginResponseContent!.refreshToken };
+        var revokeRefreshTokenResponse = await _httpClient.PostAsJsonAsync("identity/revokeRefreshToken", revokeRefreshTokenRequestBody);
+        Assert.Equal(HttpStatusCode.OK, revokeRefreshTokenResponse.StatusCode);
+
+        revokeRefreshTokenResponse = await _httpClient.PostAsJsonAsync("identity/revokeRefreshToken", revokeRefreshTokenRequestBody);
+        Assert.Equal(HttpStatusCode.BadRequest, revokeRefreshTokenResponse.StatusCode);
+    }
+}

AutobusApi.IntegrationTests/Tests/TestsBase.cs

@@ -0,0 +1,28 @@
+using AutobusApi.Infrastructure.Identity;
+using AutoubsApi.Infrastructure.Data;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace AutobusApi.IntegrationTests.Tests;
+
+public class TestsBase : IClassFixture<CustomWebApplicationFactory<Program>>
+{
+    protected readonly HttpClient _httpClient;
+
+    private readonly CustomWebApplicationFactory<Program> _factory;
+
+    public TestsBase(CustomWebApplicationFactory<Program> factory)
+    {
+        _factory = factory;
+        _httpClient = factory.CreateClient(new WebApplicationFactoryClientOptions
+        {
+            AllowAutoRedirect = false
+        });
+
+        var scope = _factory.Services.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+        var identityDbContext = scope.ServiceProvider.GetRequiredService<ApplicationIdentityDbContext>();
+        dbContext.Database.EnsureDeleted();
+        identityDbContext.Database.EnsureDeleted();
+        AutobusApi.IntegrationTests.DbInitializer.Initialize(dbContext, identityDbContext);
+    }
+}

AutobusApi.IntegrationTests/UnitTest1.cs

@@ -1,10 +0,0 @@
-namespace AutobusApi.IntegrationTests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-
-    }
-}

AutobusApi.UnitTests/AutobusApi.UnitTests.csproj

@@ -9,14 +9,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="Moq" Version="4.20.69" />
-    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+    <PackageReference Include="xunit" Version="2.6.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

AutobusApi.UnitTests/UnitTest1.cs

@@ -1,10 +0,0 @@
-namespace AutobusApi.UnitTests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-
-    }
-}