Integration

CheckDrive.Api/CheckDrive.Api/CheckDrive.Api.csproj

@@ -24,6 +24,7 @@
     <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
     <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.8.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" Version="6.9.0" />
     <PackageReference Include="Syncfusion.XlsIO.Net.Core" Version="27.1.50" />
   </ItemGroup>
 
@@ -33,4 +34,8 @@
     <ProjectReference Include="..\CheckDrive.TestDataCreator\CheckDrive.TestDataCreator.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="logs\" />
+  </ItemGroup>
+
 </Project>

CheckDrive.Api/CheckDrive.Api/Controllers/AccountsController.cs

@@ -1,6 +1,7 @@
 using CheckDrive.Application.Constants;
 using CheckDrive.Application.DTOs.Account;
 using CheckDrive.Application.Interfaces;
+using CheckDrive.Domain.Enums;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
@@ -18,9 +19,9 @@ public AccountsController(IAccountService service)
     }
 
     [HttpGet]
-    public async Task<ActionResult<List<AccountDto>>> GetAsync()
+    public async Task<ActionResult<List<AccountDto>>> GetAsync(EmployeePosition? position)
     {
-        var accounts = await _service.GetAsync();
+        var accounts = await _service.GetAsync(position);
 
         return Ok(accounts);
     }

CheckDrive.Api/CheckDrive.Api/Controllers/Auth/AuthController.cs → CheckDrive.Api/CheckDrive.Api/Controllers/AuthController.cs

@@ -2,7 +2,7 @@
 using CheckDrive.Application.Interfaces.Auth;
 using Microsoft.AspNetCore.Mvc;
 
-namespace CheckDrive.Api.Controllers.Auth;
+namespace CheckDrive.Api.Controllers;
 
 [Route("api/auth")]
 [ApiController]

CheckDrive.Api/CheckDrive.Api/Controllers/CarsController.cs

@@ -0,0 +1,63 @@
+using CheckDrive.Application.DTOs.Car;
+using CheckDrive.Application.Interfaces;
+using CheckDrive.Application.QueryParameters;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Api.Controllers;
+
+[Route("api/cars")]
+[ApiController]
+public class CarsController : ControllerBase
+{
+    private readonly ICarService _carService;
+
+    public CarsController(ICarService carService)
+    {
+        _carService = carService;
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<List<CarDto>>> GetAllAsync(CarQueryParameters queryParameters)
+    {
+        var cars = await _carService.GetAllAsync(queryParameters);
+
+        return Ok(cars);
+    }
+
+    [HttpGet("{id:int}", Name = "GetCarByIdAsync")]
+    public async Task<ActionResult<CarDto>> GetByIdAsync(int id)
+    {
+        var car = await _carService.GetByIdAsync(id);
+
+        return Ok(car);
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<CarDto>> CreateAsync(CreateCarDto car)
+    {
+        var createdCar = await _carService.CreateAsync(car);
+
+        return CreatedAtAction("GetCarByIdAsync", createdCar, new { id = createdCar.Id });
+    }
+
+    [HttpPut("{id:int}")]
+    public async Task<ActionResult<CarDto>> UpdateAsync(int id, UpdateCarDto car)
+    {
+        if (id != car.Id)
+        {
+            return BadRequest($"Route parameter id: {id} does not match with body parameter id: {car.Id}.");
+        }
+
+        var updatedCar = await _carService.UpdateAsync(car);
+
+        return Ok(updatedCar);
+    }
+
+    [HttpDelete("{id:int}")]
+    public async Task<ActionResult> DeleteAsync(int id)
+    {
+        await _carService.DeleteAsync(id);
+
+        return NoContent();
+    }
+}

CheckDrive.Api/CheckDrive.Api/Controllers/CheckPointsController.cs

@@ -23,4 +23,20 @@ public async Task<ActionResult<List<CheckPointDto>>> GetCheckPointsAsync([FromQu
 
         return Ok(checkPoints);
     }
+
+    [HttpGet("drivers/{driverId:int}/current")]
+    public async Task<ActionResult<CheckPointDto>> GetCurrentCheckPointByDriverIdAsync(int driverId)
+    {
+        var checkPoint = await _service.GetCurrentCheckPointByDriverIdAsync(driverId);
+
+        return Ok(checkPoint);
+    }
+
+    [HttpPut("{id:int}/cancel")]
+    public async Task<ActionResult<CheckPointDto>> CancelCheckPoint(int id)
+    {
+        await _service.CancelCheckPointAsync(id);
+
+        return NoContent();
+    }
 }

CheckDrive.Api/CheckDrive.Api/Controllers/DriversController.cs

@@ -0,0 +1,33 @@
+using CheckDrive.Application.DTOs.Driver;
+using CheckDrive.Application.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Api.Controllers;
+
+[Route("api/drivers")]
+[ApiController]
+public class DriversController : ControllerBase
+{
+    private readonly IDriverService _driverService;
+
+    public DriversController(IDriverService driverService)
+    {
+        _driverService = driverService ?? throw new ArgumentNullException(nameof(driverService));
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<List<DriverDto>>> GetAvailableDriversAsync()
+    {
+        var drivers = await _driverService.GetAvailableDriversAsync();
+
+        return Ok(drivers);
+    }
+
+    [HttpPost("reviews")]
+    public async Task<IActionResult> CreateReviewConfirmation(DriverReviewConfirmationDto confirmationDto)
+    {
+        await _driverService.CreateReviewConfirmation(confirmationDto);
+
+        return NoContent();
+    }
+}

CheckDrive.Api/CheckDrive.Api/Controllers/OilMarksController.cs

@@ -0,0 +1,63 @@
+using CheckDrive.Application.DTOs.OilMark;
+using CheckDrive.Application.Interfaces;
+using CheckDrive.Application.QueryParameters;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Api.Controllers;
+
+[Route("api/oilMarks")]
+[ApiController]
+public class OilMarksController : ControllerBase
+{
+    private readonly IOilMarkService _oilMarkService;
+
+    public OilMarksController(IOilMarkService oilMarkService)
+    {
+        _oilMarkService = oilMarkService ?? throw new ArgumentNullException(nameof(oilMarkService));
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<List<OilMarkDto>>> GetAsync(OilMarkQueryParameters queryParameters)
+    {
+        var oilMarks = await _oilMarkService.GetAllAsync(queryParameters);
+
+        return Ok(oilMarks);
+    }
+
+    [HttpGet("{id:int}", Name = "GetOilMarkById")]
+    public async Task<ActionResult<OilMarkDto>> GetByIdAsync(int id)
+    {
+        var oilMark = await _oilMarkService.GetByIdAsync(id);
+
+        return oilMark;
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<OilMarkDto>> CreateAsync(CreateOilMarkDto oilMark)
+    {
+        var createdOilMark = await _oilMarkService.CreateAsync(oilMark);
+
+        return CreatedAtAction("GetOilMarkById", oilMark, new { id = createdOilMark.Id });
+    }
+
+    [HttpPut("{id:int}")]
+    public async Task<ActionResult<OilMarkDto>> UpdateAsync(int id, UpdateOilMarkDto oilMark)
+    {
+        if (id != oilMark.Id)
+        {
+            return BadRequest($"Route parameter id: {id} does not match with body parameter id: {oilMark.Id}.");
+        }
+
+        var updatedOilMark = await _oilMarkService.UpdateAsync(oilMark);
+
+        return Ok(updatedOilMark);
+    }
+
+    [HttpDelete("{id:int}")]
+    public async Task<ActionResult> DeleteAsync(int id)
+    {
+        await _oilMarkService.DeleteAsync(id);
+
+        return NoContent();
+    }
+}

CheckDrive.Api/CheckDrive.Api/Controllers/Reviews/DispatcherReviewsController.cs

@@ -4,7 +4,7 @@
 
 namespace CheckDrive.Api.Controllers.Reviews;
 
-[Route("api/reviews/dispatcher/{dispatcherId:int}")]
+[Route("api/reviews/dispatchers/{dispatcherId:int}")]
 [ApiController]
 public class DispatcherReviewsController : ControllerBase
 {

CheckDrive.Api/CheckDrive.Api/Controllers/Reviews/ReviewHistoriesController.cs

@@ -0,0 +1,52 @@
+using Microsoft.AspNetCore.Mvc;
+using CheckDrive.Application.DTOs.CheckPoint;
+using CheckDrive.Application.DTOs.DoctorReview;
+using CheckDrive.Application.DTOs.OperatorReview;
+using CheckDrive.Application.DTOs.Review;
+using CheckDrive.Application.Interfaces.Review;
+
+namespace CheckDrive.Api.Controllers.Reviews;
+
+[Route("api/reviews/histories")]
+[ApiController]
+public class ReviewHistoriesController : ControllerBase
+{
+    private readonly IReviewHistoryService _historyService;
+
+    public ReviewHistoriesController(IReviewHistoryService historyService)
+    {
+        _historyService = historyService ?? throw new ArgumentNullException(nameof(historyService));
+    }
+
+    [HttpGet("drivers/{driverId:int}")]
+    public async Task<ActionResult<List<CheckPointDto>>> GetDriverHistoriesAsync(int driverId)
+    {
+        var reviews = await _historyService.GetDriverHistoriesAsync(driverId);
+
+        return Ok(reviews);
+    }
+
+    [HttpGet("doctors/{doctorId:int}")]
+    public async Task<ActionResult<List<DoctorReviewDto>>> GetDoctorHistoriesAsync(int doctorId)
+    {
+        var reviews = await _historyService.GetDoctorHistoriesAsync(doctorId);
+
+        return Ok(reviews);
+    }
+
+    [HttpGet("mechanics/{mechanicId:int}")]
+    public async Task<ActionResult<List<MechanicReviewHistoryDto>>> GetMechanicHistoriesAsync(int mechanicId)
+    {
+        var reviews = await _historyService.GetMechanicHistoriesAsync(mechanicId);
+
+        return Ok(reviews);
+    }
+
+    [HttpGet("operators/{operatorId:int}")]
+    public async Task<ActionResult<List<OperatorReviewDto>>> GetOperatorHistoriesAsync(int operatorId)
+    {
+        var reviews = await _historyService.GetOperatorHistoriesAsync(operatorId);
+
+        return Ok(reviews);
+    }
+}

CheckDrive.Api/CheckDrive.Api/Extensions/DependencyInjection.cs

@@ -9,7 +9,6 @@
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 using System.Text;
-using CheckDrive.Api.Filters;
 
 namespace CheckDrive.Api.Extensions;
 
@@ -21,6 +20,10 @@ public static IServiceCollection ConfigureServices(this IServiceCollection servi
         services.RegisterInfrastructure(configuration);
 
         services.AddSingleton<FileExtensionContentTypeProvider>();
+        services.AddSignalR(options =>
+        {
+            options.EnableDetailedErrors = true;
+        });
 
         AddControllers(services);
         AddSwagger(services);
@@ -56,15 +59,19 @@ private static void AddSwagger(IServiceCollection services)
             .AddSwaggerGen(setup =>
             {
                 setup.SwaggerDoc("v1", new OpenApiInfo { Title = "Check-Drive API", Version = "v1" });
-
-                setup.SchemaFilter<EnumSchemaFilter>();
-            });
+            })
+            .AddSwaggerGenNewtonsoftSupport();
     }
 
     private static void AddAuthentication(IServiceCollection services, IConfiguration configuration)
     {
         var jwtOptions = configuration.GetSection(nameof(JwtOptions)).Get<JwtOptions>();
 
+        if (jwtOptions is null)
+        {
+            throw new InvalidOperationException("Could not load JWT configurations.");
+        }
+
         services
             .AddAuthentication(options =>
         {
@@ -84,7 +91,7 @@ private static void AddAuthentication(IServiceCollection services, IConfiguratio
                     ValidateLifetime = true,
                     ValidateIssuerSigningKey = true,
                     IssuerSigningKey = new SymmetricSecurityKey(
-                        Encoding.UTF8.GetBytes(jwtOptions!.SecretKey))
+                        Encoding.UTF8.GetBytes(jwtOptions.SecretKey))
                 };
 
                 options.Events = new JwtBearerEvents

CheckDrive.Api/CheckDrive.Api/Extensions/StartupExtensions.cs

@@ -1,6 +1,5 @@
 using CheckDrive.Api.Helpers;
 using CheckDrive.Api.Middlewares;
-using CheckDrive.Application.Constants;
 using CheckDrive.Domain.Interfaces;
 using CheckDrive.TestDataCreator.Configurations;
 using Microsoft.AspNetCore.Identity;
@@ -28,4 +27,7 @@ public static IApplicationBuilder UseDatabaseSeeder(this WebApplication app)
 
         return app;
     }
+
+    public static bool IsTesting(this IHostEnvironment environment)
+        => environment.IsEnvironment("Testing");
 }