delete script.sh

Reviewed-on: https://git.cuqmbr.xyz/Autobus/autobus-api/pulls/20

AutobusApi.Api/AutobusApi.Api.csproj

@@ -6,4 +6,21 @@
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="MediatR" Version="12.2.0" />
+    <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="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.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" />
+  </ItemGroup>
+
 </Project>

AutobusApi.Api/Controllers/AddressController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Addresses.Commands.CreateAddress;
+using AutobusApi.Application.Addresses.Commands.DeleteAddress;
+using AutobusApi.Application.Addresses.Commands.UpdateAddress;
+using AutobusApi.Application.Addresses.Queries;
+using AutobusApi.Application.Addresses.Queries.GetAddressesWithPagination;
+using AutobusApi.Application.Addresses.Queries.GetAddress;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("addresses")]
+public class AddressController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateAddressCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<AddressDto>> GetPage([FromQuery] GetAddressesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<AddressDto> Get(int id, /* [FromQuery] GetAddressQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetAddressQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateAddressCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteAddressCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteAddressCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/BaseController.cs

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

AutobusApi.Api/Controllers/BusController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Buses.Commands.CreateBus;
+using AutobusApi.Application.Buses.Commands.DeleteBus;
+using AutobusApi.Application.Buses.Commands.UpdateBus;
+using AutobusApi.Application.Buses.Queries;
+using AutobusApi.Application.Buses.Queries.GetBusesWithPagination;
+using AutobusApi.Application.Buses.Queries.GetBus;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("vehicle/buses")]
+public class BusController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateBusCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<BusDto>> GetPage([FromQuery] GetBusesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<BusDto> Get(int id, /* [FromQuery] GetBusQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetBusQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateBusCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteBusCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteBusCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/CityController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Cities.Commands.CreateCity;
+using AutobusApi.Application.Cities.Commands.DeleteCity;
+using AutobusApi.Application.Cities.Commands.UpdateCity;
+using AutobusApi.Application.Cities.Queries;
+using AutobusApi.Application.Cities.Queries.GetCitiesWithPagination;
+using AutobusApi.Application.Cities.Queries.GetCity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("cities")]
+public class CityController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateCityCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<CityDto>> GetPage([FromQuery] GetCitiesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<CityDto> Get(int id, /* [FromQuery] GetCityQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetCityQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateCityCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteCityCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteCityCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/CompanyController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Companies.Commands.CreateCompany;
+using AutobusApi.Application.Companies.Commands.DeleteCompany;
+using AutobusApi.Application.Companies.Commands.UpdateCompany;
+using AutobusApi.Application.Companies.Queries;
+using AutobusApi.Application.Companies.Queries.GetCompaniesWithPagination;
+using AutobusApi.Application.Companies.Queries.GetCompany;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("companies")]
+public class CompanyController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateCompanyCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<CompanyDto>> GetPage([FromQuery] GetCompaniesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<CompanyDto> Get(int id, /* [FromQuery] GetCompanyQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetCompanyQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateCompanyCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteCompanyCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteCompanyCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/CountryController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Countries.Commands.CreateCountry;
+using AutobusApi.Application.Countries.Commands.DeleteCountry;
+using AutobusApi.Application.Countries.Commands.UpdateCountry;
+using AutobusApi.Application.Countries.Queries;
+using AutobusApi.Application.Countries.Queries.GetCountriesWithPagination;
+using AutobusApi.Application.Countries.Queries.GetCountry;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("countries")]
+public class CountryController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateCountryCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<CountryDto>> GetPage([FromQuery] GetCountriesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<CountryDto> Get(int id, /* [FromQuery] GetCountryQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetCountryQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateCountryCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteCountryCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteCountryCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/EmployeeController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Employees.Commands.CreateEmployee;
+using AutobusApi.Application.Employees.Commands.DeleteEmployee;
+using AutobusApi.Application.Employees.Commands.UpdateEmployee;
+using AutobusApi.Application.Employees.Queries;
+using AutobusApi.Application.Employees.Queries.GetEmployeesWithPagination;
+using AutobusApi.Application.Employees.Queries.GetEmployee;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("employees")]
+public class EmployeeController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateEmployeeCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<EmployeeDto>> GetPage([FromQuery] GetEmployeesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<EmployeeDto> Get(int id, /* [FromQuery] GetEmployeeQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetEmployeeQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateEmployeeCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteEmployeeCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteEmployeeCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/IdentityController.cs

@@ -0,0 +1,36 @@
+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;
+
+[Route("identity")]
+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/Controllers/RegionController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Regions.Commands.CreateRegion;
+using AutobusApi.Application.Regions.Commands.DeleteRegion;
+using AutobusApi.Application.Regions.Commands.UpdateRegion;
+using AutobusApi.Application.Regions.Queries;
+using AutobusApi.Application.Regions.Queries.GetRegionsWithPagination;
+using AutobusApi.Application.Regions.Queries.GetRegion;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("regions")]
+public class RegionController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateRegionCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<RegionDto>> GetPage([FromQuery] GetRegionsWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<RegionDto> Get(int id, /* [FromQuery] GetRegionQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetRegionQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateRegionCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteRegionCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteRegionCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/RouteController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.Routes.Commands.CreateRoute;
+using AutobusApi.Application.Routes.Commands.DeleteRoute;
+using AutobusApi.Application.Routes.Commands.UpdateRoute;
+using AutobusApi.Application.Routes.Queries;
+using AutobusApi.Application.Routes.Queries.GetRoutesWithPagination;
+using AutobusApi.Application.Routes.Queries.GetRoute;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("routes")]
+public class RouteController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateRouteCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<RouteDto>> GetPage([FromQuery] GetRoutesWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<RouteDto> Get(int id, /* [FromQuery] GetRouteQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetRouteQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateRouteCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteRouteCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteRouteCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/RouteSearchController.cs

@@ -0,0 +1,14 @@
+using AutobusApi.Application.RouteSearch;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("search")]
+public class RouteSearchController : BaseController
+{
+    [HttpPost]
+    public async Task<List<RouteWithTransfersDto>> Search([FromBody] RouteSearchQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/TicketGroupController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.TicketGroups.Commands.CreateTicketGroup;
+using AutobusApi.Application.TicketGroups.Commands.DeleteTicketGroup;
+using AutobusApi.Application.TicketGroups.Commands.UpdateTicketGroup;
+using AutobusApi.Application.TicketGroups.Queries;
+using AutobusApi.Application.TicketGroups.Queries.GetTicketGroupsWithPagination;
+using AutobusApi.Application.TicketGroups.Queries.GetTicketGroup;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("ticketgroups")]
+public class TicketGroupController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateTicketGroupCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<TicketGroupDto>> GetPage([FromQuery] GetTicketGroupsWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<TicketGroupDto> Get(int id, /* [FromQuery] GetTicketGroupQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetTicketGroupQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateTicketGroupCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteTicketGroupCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteTicketGroupCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Controllers/VehicleEnrollmentController.cs

@@ -0,0 +1,46 @@
+using AutobusApi.Application.Common.Models;
+using AutobusApi.Application.VehicleEnrollments.Commands.CreateVehicleEnrollment;
+using AutobusApi.Application.VehicleEnrollments.Commands.DeleteVehicleEnrollment;
+using AutobusApi.Application.VehicleEnrollments.Commands.UpdateVehicleEnrollment;
+using AutobusApi.Application.VehicleEnrollments.Queries;
+using AutobusApi.Application.VehicleEnrollments.Queries.GetVehicleEnrollmentsWithPagination;
+using AutobusApi.Application.VehicleEnrollments.Queries.GetVehicleEnrollment;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AutobusApi.Api.Controllers;
+
+[Route("vehicleenrollments")]
+public class VehicleEnrollmentController : BaseController
+{
+    [HttpPost]
+    public async Task<int> Create([FromBody] CreateVehicleEnrollmentCommand command, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpGet]
+    public async Task<PaginatedList<VehicleEnrollmentDto>> GetPage([FromQuery] GetVehicleEnrollmentsWithPaginationQuery query, CancellationToken cancellationToken)
+    {
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpGet("{id}")]
+    public async Task<VehicleEnrollmentDto> Get(int id, /* [FromQuery] GetVehicleEnrollmentQuery query, */ CancellationToken cancellationToken)
+    {
+        var query = new GetVehicleEnrollmentQuery() { Id = id };
+        return await Mediator.Send(query, cancellationToken);
+    }
+
+    [HttpPut]
+    public async Task Update([FromBody] UpdateVehicleEnrollmentCommand command, CancellationToken cancellationToken)
+    {
+        await Mediator.Send(command, cancellationToken);
+    }
+
+    [HttpDelete("{id}")]
+    public async Task Delete(int id, /* [FromBody] DeleteVehicleEnrollmentCommand command, */ CancellationToken cancellationToken)
+    {
+        var command = new DeleteVehicleEnrollmentCommand() { Id = id };
+        await Mediator.Send(command, cancellationToken);
+    }
+}

AutobusApi.Api/Middlewares/GlobalExceptionHandlerMiddleware.cs

@@ -0,0 +1,145 @@
+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 },
+            { typeof(NotFoundException), HandleNotFoundException },
+        };
+    }
+
+    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 HandleNotFoundException(HttpContext context, Exception exception)
+    {
+        context.Response.StatusCode = StatusCodes.Status404NotFound;
+        context.Response.ContentType = "application/problem+json";
+
+        await context.Response.WriteAsJsonAsync(new ProblemDetails()
+        {
+            Status = StatusCodes.Status404NotFound,
+            Type = "https://datatracker.ietf.org/doc/html/rfc7231#section-6.5.4",
+            // 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.Message);
+        await Console.Error.WriteLineAsync(exception.StackTrace);
+    }
+}

AutobusApi.Api/OpenApi/TimeSpanSchemaFilter.cs

@@ -0,0 +1,18 @@
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace AutobusApi.Api.OpenApi;
+
+public class TimeSpanSchemaFilter : ISchemaFilter
+{
+    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
+    {
+        if (context.Type == typeof(TimeSpan))
+        {
+            schema.Type = "string";
+            schema.Format = "time-span";
+            schema.Pattern = @"^\d{2}:\d{2}:\d{2}\.\d{3}$";
+        }
+    }
+}
+

AutobusApi.Api/Program.cs

@@ -1,6 +1,65 @@
+using AutobusApi.Infrastructure;
+using AutobusApi.Application;
+using AutobusApi.Api.Middlewares;
+using AutoubsApi.Infrastructure.Data;
+using AutobusApi.Infrastructure.Identity;
+using Microsoft.OpenApi.Models;
+using AutobusApi.Api.OpenApi;
+
 var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddInfrastructure(builder.Configuration);
+builder.Services.AddApplication();
+
+builder.Services.AddControllers();
+
+builder.Services.AddSwaggerGen(options =>
+{
+    options.SchemaFilter<TimeSpanSchemaFilter>();
+    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        Scheme = "Bearer",
+        BearerFormat = "Jwt",
+        In = ParameterLocation.Header,
+        Name = "Authorization",
+        Description = "Bearer Authentication With Jwt",
+        Type = SecuritySchemeType.Http
+    });
+    options.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Id = "Bearer",
+                    Type = ReferenceType.SecurityScheme
+                }
+            },
+            new List<string>()
+        }
+    });
+});
+
+builder.Services.AddTransient<GlobalExceptionHandlerMiddleware>();
+
 var app = builder.Build();
 
-app.MapGet("/", () => "Hello World!");
+// 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,8 +1,12 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
+  "ConnectionStrings": {
+    "DefaultConnection": "Host=10.0.1.20:5432;Database=autobus;Username=postgres;Password=12345678"
+  },
+  "Jwt": {
+    "Issuer": "",
+    "Audience": "",
+    "IssuerSigningKey": "a2c98dec80787a4e85ffb5bcbc24f7e4cc014d8a4fe43e9520480a50759164bc",
+    "AccessTokenValidityInMinutes": "60",
+    "RefreshTokenValidityInDays": "15",
   }
 }

AutobusApi.Application/Addresses/Commands/CreateAddress/CreateAddressCommand.cs

@@ -0,0 +1,16 @@
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Commands.CreateAddress;
+
+public record CreateAddressCommand : IRequest<int>
+{
+    public string Name { get; set; } = null!;
+
+    public int CityId { get; set; }
+
+    public double Latitude { get; set; }
+    
+    public double Longitude { get; set; }
+
+    public string VehicleType { get; set; } = null!;
+}

AutobusApi.Application/Addresses/Commands/CreateAddress/CreateAddressCommandHandler.cs

@@ -0,0 +1,36 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Domain.Entities;
+using AutobusApi.Domain.Enums;
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Commands.CreateAddress;
+
+public class CreateAddressCommandHandler : IRequestHandler<CreateAddressCommand, int>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public CreateAddressCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task<int> Handle(
+        CreateAddressCommand request,
+        CancellationToken cancellationToken)
+    {
+        var address = new Address();
+
+        address.Name = request.Name;
+        address.CityId = request.CityId;
+        // TODO: Fix abstraction problems
+        // address.Location.Latitude = request.Latitude;
+        // address.Location.Longitude = request.Longitude;
+        address.VehicleType = Enum.Parse<VehicleType>(request.VehicleType);
+
+        _dbContext.Addresses.Add(address);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        return address.Id;
+    }
+}

AutobusApi.Application/Addresses/Commands/CreateAddress/CreateAddressCommandValidator.cs

@@ -0,0 +1,20 @@
+using AutobusApi.Domain.Enums;
+using FluentValidation;
+
+namespace AutobusApi.Application.Addresses.Commands.CreateAddress;
+
+public class CreateAddressCommandValidator : AbstractValidator<CreateAddressCommand>
+{
+    public CreateAddressCommandValidator()
+    {
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.CityId).GreaterThan(0);
+
+        RuleFor(v => v.Latitude).GreaterThanOrEqualTo(-180).LessThanOrEqualTo(180);
+
+        RuleFor(v => v.Longitude).GreaterThanOrEqualTo(-180).LessThanOrEqualTo(180);
+
+        RuleFor(v => v.VehicleType).Must(value => Enum.TryParse<VehicleType>(value, true, out _));
+    }
+}

AutobusApi.Application/Addresses/Commands/DeleteAddress/DeleteAddressCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Commands.DeleteAddress;
+
+public record DeleteAddressCommand : IRequest
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Addresses/Commands/DeleteAddress/DeleteAddressCommandHandler.cs

@@ -0,0 +1,33 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Addresses.Commands.DeleteAddress;
+
+public class DeleteAddressCommandHandler : IRequestHandler<DeleteAddressCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public DeleteAddressCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        DeleteAddressCommand request,
+        CancellationToken cancellationToken)
+    {
+        var address = await _dbContext.Addresses
+            .SingleOrDefaultAsync(c => c.Id == request.Id, cancellationToken);
+
+        if (address == null)
+        {
+            throw new NotFoundException();
+        }
+
+        _dbContext.Addresses.Remove(address);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Addresses/Commands/DeleteAddress/DeleteAddressCommandValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Addresses.Commands.DeleteAddress;
+
+public class DeleteAddressCommandValidator : AbstractValidator<DeleteAddressCommand>
+{
+    public DeleteAddressCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Addresses/Commands/UpdateAddress/UpdateAddressCommand.cs

@@ -0,0 +1,18 @@
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Commands.UpdateAddress;
+
+public record UpdateAddressCommand : IRequest
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+
+    public int CityId { get; set; }
+
+    public double Latitude { get; set; }
+    
+    public double Longitude { get; set; }
+
+    public string VehicleType { get; set; } = null!;
+}

AutobusApi.Application/Addresses/Commands/UpdateAddress/UpdateAddressCommandHandler.cs

@@ -0,0 +1,38 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Domain.Enums;
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Commands.UpdateAddress;
+
+public class UpdateAddressCommandHandler : IRequestHandler<UpdateAddressCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public UpdateAddressCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        UpdateAddressCommand request,
+        CancellationToken cancellationToken)
+    {
+        var address = await _dbContext.Addresses
+            .FindAsync(new object[] { request.Id }, cancellationToken);
+
+        if (address == null)
+        {
+            throw new NotFoundException();
+        }
+
+        address.Name = request.Name;
+        address.CityId = request.CityId;
+        // TODO: Fix abstraction problems
+        // address.Location.Latitude = request.Latitude;
+        // address.Location.Longitude = request.Longitude;
+        address.VehicleType = Enum.Parse<VehicleType>(request.VehicleType);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Addresses/Commands/UpdateAddress/UpdateAddressCommandValidator.cs

@@ -0,0 +1,22 @@
+using AutobusApi.Domain.Enums;
+using FluentValidation;
+
+namespace AutobusApi.Application.Addresses.Commands.UpdateAddress;
+
+public class UpdateAddressCommandValidator : AbstractValidator<UpdateAddressCommand>
+{
+    public UpdateAddressCommandValidator()
+    {
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.Id).GreaterThan(0);
+
+        RuleFor(v => v.CityId).GreaterThan(0);
+
+        RuleFor(v => v.Latitude).GreaterThanOrEqualTo(-180).LessThanOrEqualTo(180);
+
+        RuleFor(v => v.Longitude).GreaterThanOrEqualTo(-180).LessThanOrEqualTo(180);
+
+        RuleFor(v => v.VehicleType).Must(value => Enum.TryParse<VehicleType>(value, true, out _));
+    }
+}

AutobusApi.Application/Addresses/Queries/AddressDto.cs

@@ -0,0 +1,44 @@
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Domain.Entities;
+using AutoMapper;
+
+namespace AutobusApi.Application.Addresses.Queries;
+
+public class AddressDto : IMapFrom<Address>
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+
+    public double Latitude { get; set; }
+
+    public double Longitude { get; set; }
+
+    public string VehicleType { get; set; } = null!;
+
+    public int CityId { get; set; }
+
+    public string CityName { get; set; } = null!;
+
+    public int RegionId { get; set; }
+
+    public string RegionName { get; set; } = null!;
+
+    public int CountryId { get; set; }
+
+    public string CountryName { get; set; } = null!;
+
+    public void Mapping(Profile profile)
+    {
+        profile.CreateMap<Address, AddressDto>()
+            .ForMember(d => d.CityId, opt => opt.MapFrom(s => s.CityId))
+            .ForMember(d => d.CityName, opt => opt.MapFrom(s => s.City.Name))
+            .ForMember(d => d.RegionId, opt => opt.MapFrom(s => s.City.RegionId))
+            .ForMember(d => d.RegionName, opt => opt.MapFrom(s => s.City.Region.Name))
+            .ForMember(d => d.CountryId, opt => opt.MapFrom(s => s.City.Region.CountryId))
+            .ForMember(d => d.CountryName, opt => opt.MapFrom(s => s.City.Region.Country.Name))
+            .ForMember(d => d.Latitude, opt => opt.MapFrom(s => s.Location.Latitude))
+            .ForMember(d => d.Longitude, opt => opt.MapFrom(s => s.Location.Longitude))
+            .ForMember(d => d.VehicleType, opt => opt.MapFrom(s => s.VehicleType.ToString()));
+    }
+}

AutobusApi.Application/Addresses/Queries/GetAddress/GetAddressQuery.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddress;
+
+public record GetAddressQuery : IRequest<AddressDto>
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Addresses/Queries/GetAddress/GetAddressQueryHandler.cs

@@ -0,0 +1,36 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutoMapper;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddress;
+
+public class GetAddressQueryHandler : IRequestHandler<GetAddressQuery, AddressDto>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetAddressQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<AddressDto> Handle(
+        GetAddressQuery request,
+        CancellationToken cancellationToken)
+    {
+        var address = await _dbContext.Addresses
+            .SingleOrDefaultAsync(c => c.Id == request.Id);
+
+        if (address == null)
+        {
+            throw new NotFoundException();
+        }
+
+        return _mapper.Map<AddressDto>(address);
+    }
+}

AutobusApi.Application/Addresses/Queries/GetAddress/GetAddressQueryValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddress;
+
+public class GetAddressQueryValidator : AbstractValidator<GetAddressQuery>
+{
+    public GetAddressQueryValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Addresses/Queries/GetAddressesWithPagination/GetAddressesWithPaginationQuery.cs

@@ -0,0 +1,13 @@
+using AutobusApi.Application.Common.Models;
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddressesWithPagination;
+
+public record GetAddressesWithPaginationQuery : IRequest<PaginatedList<AddressDto>>
+{
+    public string Sort { get; set; } = "";
+
+    public int PageNumber { get; set; } = 1;
+
+    public int PageSize { get; set; } = 10;
+}

AutobusApi.Application/Addresses/Queries/GetAddressesWithPagination/GetAddressesWithPaginationQueryHandler.cs

@@ -0,0 +1,32 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Application.Common.Models;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddressesWithPagination;
+
+public class GetAddressesWithPaginationQueryHandler : IRequestHandler<GetAddressesWithPaginationQuery, PaginatedList<AddressDto>>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetAddressesWithPaginationQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<PaginatedList<AddressDto>> Handle(
+        GetAddressesWithPaginationQuery request,
+        CancellationToken cancellationToken)
+    {
+        return await _dbContext.Addresses
+            .ProjectTo<AddressDto>(_mapper.ConfigurationProvider)
+            .ApplySort(request.Sort)
+            .PaginatedListAsync(request.PageNumber, request.PageSize);
+    }
+}

AutobusApi.Application/Addresses/Queries/GetAddressesWithPagination/GetAddressesWithPaginationQueryValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Addresses.Queries.GetAddressesWithPagination;
+
+public class GetAddressesWithPaginationQueryValidator : AbstractValidator<GetAddressesWithPaginationQuery>
+{
+    public GetAddressesWithPaginationQueryValidator()
+    {
+        RuleFor(v => v.PageNumber).GreaterThanOrEqualTo(1);
+
+        RuleFor(v => v.PageSize).GreaterThanOrEqualTo(1).LessThanOrEqualTo(50);
+    }
+}

AutobusApi.Application/AutobusApi.Application.csproj

@@ -6,4 +6,24 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <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.1</Version>
+    </PackageReference>
+    <PackageReference Include="MediatR" Version="12.2.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore">
+      <Version>7.0.14</Version>
+    </PackageReference>
+    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.3.7" />
+    <PackageReference Include="QuikGraph" Version="2.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AutobusApi.Domain\AutobusApi.Domain.csproj" />
+  </ItemGroup>
+
 </Project>

AutobusApi.Application/Buses/Commands/CreateBus/CreateBusCommand.cs

@@ -0,0 +1,24 @@
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Commands.CreateBus;
+
+public record CreateBusCommand : IRequest<int>
+{
+    public int CompanyId { get; set; }
+
+    public string Number { get; set; } = null!;
+
+    public string Model { get; set; } = null!;
+
+    public int Capacity { get; set; }
+
+    public bool HasClimateControl { get; set; }
+
+    public bool HasWiFi { get; set; }
+
+    public bool HasMultimedia { get; set; }
+
+    public bool HasWC { get; set; }
+
+    public bool HasOutlets { get; set; }
+}

AutobusApi.Application/Buses/Commands/CreateBus/CreateBusCommandHandler.cs

@@ -0,0 +1,38 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Domain.Entities;
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Commands.CreateBus;
+
+public class CreateBusCommandHandler : IRequestHandler<CreateBusCommand, int>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public CreateBusCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task<int> Handle(
+        CreateBusCommand request,
+        CancellationToken cancellationToken)
+    {
+        var bus = new Bus();
+
+        bus.CompanyId = request.CompanyId;
+        bus.Number = request.Number;
+        bus.Model = request.Model;
+        bus.Capacity = request.Capacity;
+        bus.HasClimateControl = request.HasClimateControl;
+        bus.HasWiFi = request.HasWiFi;
+        bus.HasMultimedia = request.HasMultimedia;
+        bus.HasWC = request.HasWC;
+        bus.HasOutlets = request.HasOutlets;
+
+        _dbContext.Vehicles.Add(bus);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        return bus.Id;
+    }
+}

AutobusApi.Application/Buses/Commands/CreateBus/CreateBusCommandValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Buses.Commands.CreateBus;
+
+public class CreateBusCommandValidator : AbstractValidator<CreateBusCommand>
+{
+    public CreateBusCommandValidator()
+    {
+        RuleFor(v => v.Number).MinimumLength(8).MaximumLength(8);
+
+        RuleFor(v => v.Model).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.Capacity).GreaterThan(0);
+    }
+}

AutobusApi.Application/Buses/Commands/DeleteBus/DeleteBusCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Commands.DeleteBus;
+
+public record DeleteBusCommand : IRequest
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Buses/Commands/DeleteBus/DeleteBusCommandHandler.cs

@@ -0,0 +1,33 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Buses.Commands.DeleteBus;
+
+public class DeleteBusCommandHandler : IRequestHandler<DeleteBusCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public DeleteBusCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        DeleteBusCommand request,
+        CancellationToken cancellationToken)
+    {
+        var bus = await _dbContext.Buses
+            .SingleOrDefaultAsync(c => c.Id == request.Id, cancellationToken);
+
+        if (bus == null)
+        {
+            throw new NotFoundException();
+        }
+
+        _dbContext.Buses.Remove(bus);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Buses/Commands/DeleteBus/DeleteBusCommandValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Buses.Commands.DeleteBus;
+
+public class DeleteBusCommandValidator : AbstractValidator<DeleteBusCommand>
+{
+    public DeleteBusCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Buses/Commands/UpdateBus/UpdateBusCommand.cs

@@ -0,0 +1,26 @@
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Commands.UpdateBus;
+
+public record UpdateBusCommand : IRequest
+{
+    public int Id { get; set; }
+
+    public int CompanyId { get; set; }
+
+    public string Number { get; set; } = null!;
+
+    public string Model { get; set; } = null!;
+
+    public int Capacity { get; set; }
+
+    public bool HasClimateControl { get; set; }
+
+    public bool HasWiFi { get; set; }
+
+    public bool HasMultimedia { get; set; }
+
+    public bool HasWC { get; set; }
+
+    public bool HasOutlets { get; set; }
+}

AutobusApi.Application/Buses/Commands/UpdateBus/UpdateBusCommandHandler.cs

@@ -0,0 +1,40 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Commands.UpdateBus;
+
+public class UpdateBusCommandHandler : IRequestHandler<UpdateBusCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public UpdateBusCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        UpdateBusCommand request,
+        CancellationToken cancellationToken)
+    {
+        var bus = await _dbContext.Buses
+            .FindAsync(new object[] { request.Id }, cancellationToken);
+
+        if (bus == null)
+        {
+            throw new NotFoundException();
+        }
+
+        bus.CompanyId = request.CompanyId;
+        bus.Number = request.Number;
+        bus.Model = request.Model;
+        bus.Capacity = request.Capacity;
+        bus.HasClimateControl = request.HasClimateControl;
+        bus.HasWiFi = request.HasWiFi;
+        bus.HasMultimedia = request.HasMultimedia;
+        bus.HasWC = request.HasWC;
+        bus.HasOutlets = request.HasOutlets;
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Buses/Commands/UpdateBus/UpdateBusCommandValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Buses.Commands.UpdateBus;
+
+public class UpdateBusCommandValidator : AbstractValidator<UpdateBusCommand>
+{
+    public UpdateBusCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+        
+        RuleFor(v => v.CompanyId).GreaterThan(0);
+
+        RuleFor(v => v.Number).MinimumLength(8).MaximumLength(8);
+
+        RuleFor(v => v.Model).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.Capacity).GreaterThan(0);
+    }
+}

AutobusApi.Application/Buses/Queries/BusDto.cs

@@ -0,0 +1,27 @@
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Domain.Entities;
+
+namespace AutobusApi.Application.Buses.Queries;
+
+public class BusDto : IMapFrom<Bus>
+{
+    public int Id { get; set; }
+
+    public int CompanyId { get; set; }
+
+    public string Number { get; set; } = null!;
+
+    public string Model { get; set; } = null!;
+
+    public int Capacity { get; set; }
+
+    public bool HasClimateControl { get; set; }
+
+    public bool HasWiFi { get; set; }
+
+    public bool HasMultimedia { get; set; }
+
+    public bool HasWC { get; set; }
+
+    public bool HasOutlets { get; set; }
+}

AutobusApi.Application/Buses/Queries/GetBus/GetBusQuery.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Queries.GetBus;
+
+public record GetBusQuery : IRequest<BusDto>
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Buses/Queries/GetBus/GetBusQueryHandler.cs

@@ -0,0 +1,38 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Buses.Queries.GetBus;
+
+public class GetBusQueryHandler : IRequestHandler<GetBusQuery, BusDto>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetBusQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<BusDto> Handle(
+        GetBusQuery request,
+        CancellationToken cancellationToken)
+    {
+        var bus = await _dbContext.Buses
+            .ProjectTo<BusDto>(_mapper.ConfigurationProvider)
+            .SingleOrDefaultAsync(c => c.Id == request.Id);
+
+        if (bus == null)
+        {
+            throw new NotFoundException();
+        }
+
+        return bus;
+    }
+}

AutobusApi.Application/Buses/Queries/GetBus/GetBusQueryValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Buses.Queries.GetBus;
+
+public class GetBusQueryValidator : AbstractValidator<GetBusQuery>
+{
+    public GetBusQueryValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Buses/Queries/GetBusesWithPagination/GetBusesWithPaginationQuery.cs

@@ -0,0 +1,13 @@
+using AutobusApi.Application.Common.Models;
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Queries.GetBusesWithPagination;
+
+public record GetBusesWithPaginationQuery : IRequest<PaginatedList<BusDto>>
+{
+    public string Sort { get; set; } = "";
+
+    public int PageNumber { get; set; } = 1;
+
+    public int PageSize { get; set; } = 10;
+}

AutobusApi.Application/Buses/Queries/GetBusesWithPagination/GetBusesWithPaginationQueryHandler.cs

@@ -0,0 +1,32 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Application.Common.Models;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+
+namespace AutobusApi.Application.Buses.Queries.GetBusesWithPagination;
+
+public class GetBusesWithPaginationQueryHandler : IRequestHandler<GetBusesWithPaginationQuery, PaginatedList<BusDto>>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetBusesWithPaginationQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<PaginatedList<BusDto>> Handle(
+        GetBusesWithPaginationQuery request,
+        CancellationToken cancellationToken)
+    {
+        return await _dbContext.Buses
+            .ProjectTo<BusDto>(_mapper.ConfigurationProvider)
+            .ApplySort(request.Sort)
+            .PaginatedListAsync(request.PageNumber, request.PageSize);
+    }
+}

AutobusApi.Application/Buses/Queries/GetBusesWithPagination/GetBusesWithPaginationQueryValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Buses.Queries.GetBusesWithPagination;
+
+public class GetBusesWithPaginationQueryValidator : AbstractValidator<GetBusesWithPaginationQuery>
+{
+    public GetBusesWithPaginationQueryValidator()
+    {
+        RuleFor(v => v.PageNumber).GreaterThanOrEqualTo(1);
+
+        RuleFor(v => v.PageSize).GreaterThanOrEqualTo(1).LessThanOrEqualTo(50);
+    }
+}

AutobusApi.Application/Cities/Commands/CreateCity/CreateCityCommand.cs

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Commands.CreateCity;
+
+public record CreateCityCommand : IRequest<int>
+{
+    public string Name { get; set; } = null!;
+
+    public int RegionId { get; set; }
+}

AutobusApi.Application/Cities/Commands/CreateCity/CreateCityCommandHandler.cs

@@ -0,0 +1,31 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Domain.Entities;
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Commands.CreateCity;
+
+public class CreateCityCommandHandler : IRequestHandler<CreateCityCommand, int>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public CreateCityCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task<int> Handle(
+        CreateCityCommand request,
+        CancellationToken cancellationToken)
+    {
+        var city = new City();
+
+        city.Name = request.Name;
+        city.RegionId = request.RegionId;
+
+        _dbContext.Cities.Add(city);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        return city.Id;
+    }
+}

AutobusApi.Application/Cities/Commands/CreateCity/CreateCityCommandValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Cities.Commands.CreateCity;
+
+public class CreateCityCommandValidator : AbstractValidator<CreateCityCommand>
+{
+    public CreateCityCommandValidator()
+    {
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.RegionId).GreaterThan(0);
+    }
+}

AutobusApi.Application/Cities/Commands/DeleteCity/DeleteCityCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Commands.DeleteCity;
+
+public record DeleteCityCommand : IRequest
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Cities/Commands/DeleteCity/DeleteCityCommandHandler.cs

@@ -0,0 +1,33 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Cities.Commands.DeleteCity;
+
+public class DeleteCityCommandHandler : IRequestHandler<DeleteCityCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public DeleteCityCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        DeleteCityCommand request,
+        CancellationToken cancellationToken)
+    {
+        var city = await _dbContext.Cities
+            .SingleOrDefaultAsync(c => c.Id == request.Id, cancellationToken);
+
+        if (city == null)
+        {
+            throw new NotFoundException();
+        }
+
+        _dbContext.Cities.Remove(city);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Cities/Commands/DeleteCity/DeleteCityCommandValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Cities.Commands.DeleteCity;
+
+public class DeleteCityCommandValidator : AbstractValidator<DeleteCityCommand>
+{
+    public DeleteCityCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Cities/Commands/UpdateCity/UpdateCityCommand.cs

@@ -0,0 +1,12 @@
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Commands.UpdateCity;
+
+public record UpdateCityCommand : IRequest
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+    
+    public int RegionId { get; set; }
+}

AutobusApi.Application/Cities/Commands/UpdateCity/UpdateCityCommandHandler.cs

@@ -0,0 +1,33 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Commands.UpdateCity;
+
+public class UpdateCityCommandHandler : IRequestHandler<UpdateCityCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public UpdateCityCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        UpdateCityCommand request,
+        CancellationToken cancellationToken)
+    {
+        var city = await _dbContext.Cities
+            .FindAsync(new object[] { request.Id }, cancellationToken);
+
+        if (city == null)
+        {
+            throw new NotFoundException();
+        }
+
+        city.Name = request.Name;
+        city.RegionId = request.RegionId;
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Cities/Commands/UpdateCity/UpdateCityCommandValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Cities.Commands.UpdateCity;
+
+public class UpdateCityCommandValidator : AbstractValidator<UpdateCityCommand>
+{
+    public UpdateCityCommandValidator()
+    {
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.Id).GreaterThan(0);
+
+        RuleFor(v => v.RegionId).GreaterThan(0);
+    }
+}

AutobusApi.Application/Cities/Queries/CityDto.cs

@@ -0,0 +1,27 @@
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Domain.Entities;
+using AutoMapper;
+
+namespace AutobusApi.Application.Cities.Queries;
+
+public class CityDto : IMapFrom<City>
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+
+    public int CountryId { get; set; }
+
+    public string CountryName { get; set; } = null!;
+
+    public int RegionId { get; set; }
+
+    public string RegionName { get; set; } = null!;
+
+    public void Mapping(Profile profile)
+    {
+        profile.CreateMap<City, CityDto>()
+            .ForMember(d => d.CountryId, opt => opt.MapFrom(s => s.Region.Country.Id))
+            .ForMember(d => d.CountryName, opt => opt.MapFrom(s => s.Region.Country.Name));
+    }
+}

AutobusApi.Application/Cities/Queries/GetCitiesWithPagination/GetCitiesWithPaginationQuery.cs

@@ -0,0 +1,13 @@
+using AutobusApi.Application.Common.Models;
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Queries.GetCitiesWithPagination;
+
+public record GetCitiesWithPaginationQuery : IRequest<PaginatedList<CityDto>>
+{
+    public string Sort { get; set; } = "";
+
+    public int PageNumber { get; set; } = 1;
+
+    public int PageSize { get; set; } = 10;
+}

AutobusApi.Application/Cities/Queries/GetCitiesWithPagination/GetCitiesWithPaginationQueryHandler.cs

@@ -0,0 +1,32 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Application.Common.Models;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Queries.GetCitiesWithPagination;
+
+public class GetCitiesWithPaginationQueryHandler : IRequestHandler<GetCitiesWithPaginationQuery, PaginatedList<CityDto>>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetCitiesWithPaginationQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<PaginatedList<CityDto>> Handle(
+        GetCitiesWithPaginationQuery request,
+        CancellationToken cancellationToken)
+    {
+        return await _dbContext.Cities
+            .ProjectTo<CityDto>(_mapper.ConfigurationProvider)
+            .ApplySort(request.Sort)
+            .PaginatedListAsync(request.PageNumber, request.PageSize);
+    }
+}

AutobusApi.Application/Cities/Queries/GetCitiesWithPagination/GetCitiesWithPaginationQueryValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Cities.Queries.GetCitiesWithPagination;
+
+public class GetCitiesWithPaginationQueryValidator : AbstractValidator<GetCitiesWithPaginationQuery>
+{
+    public GetCitiesWithPaginationQueryValidator()
+    {
+        RuleFor(v => v.PageNumber).GreaterThanOrEqualTo(1);
+
+        RuleFor(v => v.PageSize).GreaterThanOrEqualTo(1).LessThanOrEqualTo(50);
+    }
+}

AutobusApi.Application/Cities/Queries/GetCity/GetCityQuery.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Cities.Queries.GetCity;
+
+public record GetCityQuery : IRequest<CityDto>
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Cities/Queries/GetCity/GetCityQueryHandler.cs

@@ -0,0 +1,36 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutoMapper;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Cities.Queries.GetCity;
+
+public class GetCityQueryHandler : IRequestHandler<GetCityQuery, CityDto>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetCityQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<CityDto> Handle(
+        GetCityQuery request,
+        CancellationToken cancellationToken)
+    {
+        var city = await _dbContext.Cities
+            .SingleOrDefaultAsync(c => c.Id == request.Id);
+
+        if (city == null)
+        {
+            throw new NotFoundException();
+        }
+
+        return _mapper.Map<CityDto>(city);
+    }
+}

AutobusApi.Application/Cities/Queries/GetCity/GetCityQueryValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Cities.Queries.GetCity;
+
+public class GetCityQueryValidator : AbstractValidator<GetCityQuery>
+{
+    public GetCityQueryValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Common/Behaviours/LoggingBehaviour.cs

@@ -0,0 +1,22 @@
+using MediatR.Pipeline;
+using Microsoft.Extensions.Logging;
+
+namespace AutobusApi.Application.Common.Behaviours;
+
+public class LoggingBehaviour<TRequest> : IRequestPreProcessor<TRequest> where TRequest : notnull
+{
+    private readonly ILogger _logger;
+
+    public LoggingBehaviour(ILogger<TRequest> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task Process(TRequest request, CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+
+        _logger.LogInformation("Request: {Name} {@UserId} {@UserName} {@Request}",
+            requestName, request);
+    }
+}

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/NotFoundException.cs

@@ -0,0 +1,3 @@
+namespace AutobusApi.Application.Common.Exceptions;
+
+public class NotFoundException : Exception { }

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<int> 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/Mappings/IMapFrom.cs

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

AutobusApi.Application/Common/Mappings/MappingExtensions.cs

@@ -0,0 +1,156 @@
+using System.Reflection;
+using System.Linq.Dynamic.Core;
+using System.Text;
+using AutobusApi.Application.Common.Models;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using Microsoft.EntityFrameworkCore;
+using System.Dynamic;
+
+namespace AutobusApi.Application.Common.Mappings;
+
+public static class MappingExtensions
+{
+    public static Task<PaginatedList<T>> PaginatedListAsync<T>(
+            this IQueryable<T> queryable,
+            int pageNumber,
+            int pageSize)
+        where T : class
+    {
+        return PaginatedList<T>.CreateAsync(queryable.AsNoTracking(), pageNumber, pageSize);
+    }
+
+    public static Task<List<T>> ProjectToListAsync<T>(
+            this IQueryable queryable,
+            IConfigurationProvider configuration)
+        where T : class
+    {
+        return queryable.ProjectTo<T>(configuration).AsNoTracking().ToListAsync();
+    }
+
+    public static IQueryable<T> ApplySort<T>(
+        this IQueryable<T> entities,
+        string? orderByQueryString)
+    {
+        if (!entities.Any() || String.IsNullOrWhiteSpace(orderByQueryString))
+        {
+            return entities;
+        }
+
+        var orderParams = orderByQueryString.Trim().Split(",");
+        var propertyInfos = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+        var orderQueryBuilder = new StringBuilder();
+
+        foreach (var param in orderParams)
+        {
+            if (string.IsNullOrWhiteSpace(param))
+            {
+                continue;
+            }
+
+            var propertyFromQueryName = param[0] == '-' || param[0] == '+' ? param.Substring(1) : param;
+            var objectProperty = propertyInfos.FirstOrDefault(pi =>
+                pi.Name.Equals(propertyFromQueryName, StringComparison.InvariantCultureIgnoreCase));
+
+            if (objectProperty == null)
+            {
+                continue;
+            }
+
+            var sortingOrder = param[0] == '-' ? "descending" : "ascending";
+
+            orderQueryBuilder.Append($"{objectProperty.Name} {sortingOrder}, ");
+        }
+
+        var orderQuery = orderQueryBuilder.ToString().TrimEnd(',', ' ');
+
+        return entities.OrderBy(orderQuery);
+    }
+
+
+
+
+
+
+    public static IQueryable<ExpandoObject> ShapeData<T>(
+        this IQueryable<T> entities,
+        string? fieldsString)
+    {
+        var allProperties = GetAllProperties<T>();
+        var requiredProperties = GetRequiredProperties(fieldsString, allProperties);
+        return FetchData(entities, requiredProperties);
+    }
+    
+    public static ExpandoObject ShapeData<T>(
+        this T entity,
+        string? fieldsString)
+    {
+        var allProperties = GetAllProperties<T>();
+        var requiredProperties = GetRequiredProperties(fieldsString, allProperties);
+        return FetchDataForEntity(entity, requiredProperties);
+    }
+
+    private static IEnumerable<PropertyInfo> GetAllProperties<T>()
+    {
+        return typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+    }
+    
+    private static IEnumerable<PropertyInfo> GetRequiredProperties(
+        string? fieldsString,
+        IEnumerable<PropertyInfo> properties)
+    {
+        var requiredProperties = new List<PropertyInfo>();
+
+        if (!string.IsNullOrWhiteSpace(fieldsString))
+        {
+            var fields = fieldsString.Split(',', StringSplitOptions.RemoveEmptyEntries);
+
+            foreach (var field in fields)
+            {
+                var property = properties.FirstOrDefault(pi => pi.Name.Equals(field.Trim(), StringComparison.InvariantCultureIgnoreCase));
+
+                if (property == null)
+                    continue;
+
+                requiredProperties.Add(property);
+            }
+        }
+        else
+        {
+            requiredProperties = properties.ToList();
+        }
+
+        return requiredProperties;
+    }
+    
+    private static IQueryable<ExpandoObject> FetchData<T>(
+        IQueryable<T> entities,
+        IEnumerable<PropertyInfo> requiredProperties)
+    {
+        var shapedData = new List<ExpandoObject>();
+
+        foreach (var entity in entities)
+        {
+            var shapedObject = FetchDataForEntity(entity, requiredProperties);
+            shapedData.Add(shapedObject);
+        }
+
+        return shapedData.AsQueryable();
+    }
+    
+    private static ExpandoObject FetchDataForEntity<T>(
+        T entity,
+        IEnumerable<PropertyInfo> requiredProperties)
+    {
+        var shapedObject = new ExpandoObject();
+
+        foreach (var property in requiredProperties)
+        {
+            var objectPropertyValue = property.GetValue(entity);
+            shapedObject.TryAdd(property.Name, objectPropertyValue);
+        }
+
+        return shapedObject;
+    }
+
+}

AutobusApi.Application/Common/Mappings/MappingProfile.cs

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

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/Common/Models/PaginatedList.cs

@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Common.Models;
+
+public class PaginatedList<T>
+{
+    public IReadOnlyCollection<T> Items { get; }
+    public int PageNumber { get; }
+    public int TotalPages { get; }
+    public int TotalCount { get; }
+
+    public PaginatedList(IReadOnlyCollection<T> items, int count, int pageNumber, int pageSize)
+    {
+        PageNumber = pageNumber;
+        TotalPages = (int)Math.Ceiling(count / (double)pageSize);
+        TotalCount = count;
+        Items = items;
+    }
+
+    public bool HasPreviousPage => PageNumber > 1;
+
+    public bool HasNextPage => PageNumber < TotalPages;
+
+    public static async Task<PaginatedList<T>> CreateAsync(IQueryable<T> source, int pageNumber, int pageSize)
+    {
+        var count = await source.CountAsync();
+        var items = await source.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToListAsync();
+
+        return new PaginatedList<T>(items, count, pageNumber, pageSize);
+    }
+}

AutobusApi.Application/Companies/Commands/CreateCompany/CreateCompanyCommand.cs

@@ -0,0 +1,32 @@
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Commands.CreateCompany;
+
+public record CreateCompanyCommand : IRequest<int>
+{
+    public string Name { get; set; } = null!;
+
+    public string LegalAddress { get; set; } = null!;
+
+    public string ContactEmail { get; set; } = null!;
+
+    public string ContactPhoneNumber { get; set; } = null!;
+
+    public string OwnerEmail { get; set; } = null!;
+
+    public string OwnerPassword { get; set; } = null!;
+
+    public string OwnerFirstName { get; set; } = null!;
+
+    public string OwnerLastName { get; set; } = null!;
+
+    public string OwnerPatronymic { get; set; } = null!;
+
+    public string OwnerSex { get; set; } = null!;
+    
+    public DateOnly OwnerBirthDate { get; set; }
+
+    public string OwnerDocumentType { get; set; } = null!;
+
+    public string OwnerDocumentInformation { get; set; } = null!;
+}

AutobusApi.Application/Companies/Commands/CreateCompany/CreateCompanyCommandHandler.cs

@@ -0,0 +1,61 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Domain.Entities;
+using AutobusApi.Domain.Enums;
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Commands.CreateCompany;
+
+public class CreateCompanyCommandHandler : IRequestHandler<CreateCompanyCommand, int>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IIdentityService _identityService;
+
+    public CreateCompanyCommandHandler(
+        IApplicationDbContext dbContext,
+        IIdentityService identityService)
+    {
+        _dbContext = dbContext;
+        _identityService = identityService;
+    }
+
+    public async Task<int> Handle(
+        CreateCompanyCommand request,
+        CancellationToken cancellationToken)
+    {
+        var company = new Company();
+
+        company.Name = request.Name;
+        company.LegalAddress = request.LegalAddress;
+        company.ContactPhoneNumber = request.ContactPhoneNumber;
+        company.ContactEmail = request.ContactEmail;
+
+        var userId = await _identityService.RegisterAsync(request.OwnerEmail, request.OwnerPassword, cancellationToken);
+
+        company.Employees = new List<Employee>()
+        {
+            new Employee()
+            {
+                IdentityId = userId,
+                FirstName = request.OwnerFirstName,
+                LastName = request.OwnerLastName,
+                Patronymic = request.OwnerPatronymic,
+                Sex = Enum.Parse<Sex>(request.OwnerSex),
+                BirthDate = request.OwnerBirthDate,
+                Documents = new List<EmployeeDocument>()
+                {
+                    new EmployeeDocument()
+                    {
+                        Type = Enum.Parse<EmployeeDocumentType>(request.OwnerDocumentType),
+                        Information = request.OwnerDocumentInformation
+                    }
+                }
+            }
+        };
+
+        _dbContext.Companies.Add(company);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        return company.Id;
+    }
+}

AutobusApi.Application/Companies/Commands/CreateCompany/CreateCompanyCommandValidator.cs

@@ -0,0 +1,47 @@
+using AutobusApi.Domain.Enums;
+using FluentValidation;
+
+namespace AutobusApi.Application.Companies.Commands.CreateCompany;
+
+public class CreateCompanyCommandValidator : AbstractValidator<CreateCompanyCommand>
+{
+    public CreateCompanyCommandValidator()
+    {
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.LegalAddress).MinimumLength(2).MaximumLength(256);
+
+        RuleFor(v => v.ContactPhoneNumber)
+            .NotEmpty().WithMessage("Phone number is required.")
+            .Matches(@"^\s*(?:\+?(\d{1,3}))?([-. (]*(\d{3})[-. )]*)?((\d{3})[-. ]*(\d{2,4})(?:[-.x ]*(\d+))?)\s*$").WithMessage("Phone number is invalid.");
+
+        RuleFor(v => v.ContactEmail)
+            .NotEmpty().WithMessage("Email address is required.")
+            .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b").WithMessage("Email address is invalid.");
+
+        RuleFor(v => v.OwnerEmail)
+            .NotEmpty().WithMessage("Email address is required.")
+            .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b").WithMessage("Email address is invalid.");
+
+        RuleFor(v => v.OwnerPassword)
+            .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: !@#$%^&*().");
+
+        RuleFor(v => v.OwnerFirstName).MinimumLength(2).MaximumLength(32);
+        
+        RuleFor(v => v.OwnerLastName).MinimumLength(2).MaximumLength(32);
+
+        RuleFor(v => v.OwnerPatronymic).MinimumLength(2).MaximumLength(32);
+
+        RuleFor(v => v.OwnerSex).Must(value => Enum.TryParse<Sex>(value, true, out _));
+
+        RuleFor(v => v.OwnerDocumentType).Must(value => Enum.TryParse<EmployeeDocumentType>(value, true, out _));
+
+        RuleFor(v => v.OwnerDocumentInformation).MinimumLength(2).MaximumLength(256);
+    }
+}

AutobusApi.Application/Companies/Commands/DeleteCompany/DeleteCompanyCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Commands.DeleteCompany;
+
+public record DeleteCompanyCommand : IRequest
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Companies/Commands/DeleteCompany/DeleteCompanyCommandHandler.cs

@@ -0,0 +1,33 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Companies.Commands.DeleteCompany;
+
+public class DeleteCompanyCommandHandler : IRequestHandler<DeleteCompanyCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public DeleteCompanyCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        DeleteCompanyCommand request,
+        CancellationToken cancellationToken)
+    {
+        var company = await _dbContext.Companies
+            .SingleOrDefaultAsync(c => c.Id == request.Id, cancellationToken);
+
+        if (company == null)
+        {
+            throw new NotFoundException();
+        }
+
+        _dbContext.Companies.Remove(company);
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Companies/Commands/DeleteCompany/DeleteCompanyCommandValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Companies.Commands.DeleteCompany;
+
+public class DeleteCompanyCommandValidator : AbstractValidator<DeleteCompanyCommand>
+{
+    public DeleteCompanyCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Companies/Commands/UpdateCompany/UpdateCompanyCommand.cs

@@ -0,0 +1,16 @@
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Commands.UpdateCompany;
+
+public record UpdateCompanyCommand : IRequest
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+
+    public string LegalAddress { get; set; } = null!;
+
+    public string ContactEmail { get; set; } = null!;
+
+    public string ContactPhoneNumber { get; set; } = null!;
+}

AutobusApi.Application/Companies/Commands/UpdateCompany/UpdateCompanyCommandHandler.cs

@@ -0,0 +1,35 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Commands.UpdateCompany;
+
+public class UpdateCompanyCommandHandler : IRequestHandler<UpdateCompanyCommand>
+{
+    private readonly IApplicationDbContext _dbContext;
+
+    public UpdateCompanyCommandHandler(IApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    public async Task Handle(
+        UpdateCompanyCommand request,
+        CancellationToken cancellationToken)
+    {
+        var company = await _dbContext.Companies
+            .FindAsync(new object[] { request.Id }, cancellationToken);
+
+        if (company == null)
+        {
+            throw new NotFoundException();
+        }
+
+        company.Name = request.Name;
+        company.LegalAddress = request.LegalAddress;
+        company.ContactEmail = request.ContactEmail;
+        company.ContactPhoneNumber = request.ContactPhoneNumber;
+
+        await _dbContext.SaveChangesAsync(cancellationToken);
+    }
+}

AutobusApi.Application/Companies/Commands/UpdateCompany/UpdateCompanyCommandValidator.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Companies.Commands.UpdateCompany;
+
+public class UpdateCompanyCommandValidator : AbstractValidator<UpdateCompanyCommand>
+{
+    public UpdateCompanyCommandValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+
+        RuleFor(v => v.Name).MinimumLength(2).MaximumLength(64);
+
+        RuleFor(v => v.LegalAddress).MinimumLength(2).MaximumLength(256);
+
+        RuleFor(v => v.ContactPhoneNumber)
+            .NotEmpty().WithMessage("Phone number is required.")
+            .Matches(@"^\s*(?:\+?(\d{1,3}))?([-. (]*(\d{3})[-. )]*)?((\d{3})[-. ]*(\d{2,4})(?:[-.x ]*(\d+))?)\s*$").WithMessage("Phone number is invalid.");
+
+        RuleFor(v => v.ContactEmail)
+            .NotEmpty().WithMessage("Email address is required.")
+            .Matches(@"\b[\w\.-]+@[\w\.-]+\.\w{2,4}\b").WithMessage("Email address is invalid.");
+    }
+}

AutobusApi.Application/Companies/Queries/CompanyDto.cs

@@ -0,0 +1,17 @@
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Domain.Entities;
+
+namespace AutobusApi.Application.Companies.Queries;
+
+public class CompanyDto : IMapFrom<Company>
+{
+    public int Id { get; set; }
+
+    public string Name { get; set; } = null!;
+
+    public string LegalAddress { get; set; } = null!;
+
+    public string ContactEmail { get; set; } = null!;
+
+    public string ContactPhoneNumber { get; set; } = null!;
+}

AutobusApi.Application/Companies/Queries/GetCompaniesWithPagination/GetCompaniesWithPaginationQuery.cs

@@ -0,0 +1,13 @@
+using AutobusApi.Application.Common.Models;
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompaniesWithPagination;
+
+public record GetCompaniesWithPaginationQuery : IRequest<PaginatedList<CompanyDto>>
+{
+    public string Sort { get; set; } = "";
+
+    public int PageNumber { get; set; } = 1;
+
+    public int PageSize { get; set; } = 10;
+}

AutobusApi.Application/Companies/Queries/GetCompaniesWithPagination/GetCompaniesWithPaginationQueryHandler.cs

@@ -0,0 +1,32 @@
+using AutobusApi.Application.Common.Interfaces;
+using AutobusApi.Application.Common.Mappings;
+using AutobusApi.Application.Common.Models;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompaniesWithPagination;
+
+public class GetCompaniesWithPaginationQueryHandler : IRequestHandler<GetCompaniesWithPaginationQuery, PaginatedList<CompanyDto>>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetCompaniesWithPaginationQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<PaginatedList<CompanyDto>> Handle(
+        GetCompaniesWithPaginationQuery request,
+        CancellationToken cancellationToken)
+    {
+        return await _dbContext.Companies
+            .ProjectTo<CompanyDto>(_mapper.ConfigurationProvider)
+            .ApplySort(request.Sort)
+            .PaginatedListAsync(request.PageNumber, request.PageSize);
+    }
+}

AutobusApi.Application/Companies/Queries/GetCompaniesWithPagination/GetCompaniesWithPaginationQueryValidator.cs

@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompaniesWithPagination;
+
+public class GetCompaniesWithPaginationQueryValidator : AbstractValidator<GetCompaniesWithPaginationQuery>
+{
+    public GetCompaniesWithPaginationQueryValidator()
+    {
+        RuleFor(v => v.PageNumber).GreaterThanOrEqualTo(1);
+
+        RuleFor(v => v.PageSize).GreaterThanOrEqualTo(1).LessThanOrEqualTo(50);
+    }
+}

AutobusApi.Application/Companies/Queries/GetCompany/GetCompanyQuery.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompany;
+
+public record GetCompanyQuery : IRequest<CompanyDto>
+{
+    public int Id { get; set; }
+}

AutobusApi.Application/Companies/Queries/GetCompany/GetCompanyQueryHandler.cs

@@ -0,0 +1,38 @@
+using AutobusApi.Application.Common.Exceptions;
+using AutobusApi.Application.Common.Interfaces;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompany;
+
+public class GetCompanyQueryHandler : IRequestHandler<GetCompanyQuery, CompanyDto>
+{
+    private readonly IApplicationDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public GetCompanyQueryHandler(
+        IApplicationDbContext dbContext,
+        IMapper mapper)
+    {
+        _dbContext = dbContext;
+        _mapper = mapper;
+    }
+
+    public async Task<CompanyDto> Handle(
+        GetCompanyQuery request,
+        CancellationToken cancellationToken)
+    {
+        var company = await _dbContext.Companies
+            .ProjectTo<CompanyDto>(_mapper.ConfigurationProvider)
+            .SingleOrDefaultAsync(c => c.Id == request.Id);
+
+        if (company == null)
+        {
+            throw new NotFoundException();
+        }
+
+        return company;
+    }
+}

AutobusApi.Application/Companies/Queries/GetCompany/GetCompanyQueryValidator.cs

@@ -0,0 +1,11 @@
+using FluentValidation;
+
+namespace AutobusApi.Application.Companies.Queries.GetCompany;
+
+public class GetCompanyQueryValidator : AbstractValidator<GetCompanyQuery>
+{
+    public GetCompanyQueryValidator()
+    {
+        RuleFor(v => v.Id).GreaterThan(0);
+    }
+}

AutobusApi.Application/Countries/Commands/CreateCountry/CreateCountryCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace AutobusApi.Application.Countries.Commands.CreateCountry;
+
+public record CreateCountryCommand : IRequest<int>
+{
+    public string Name { get; set; } = null!;
+}