Update doctor page

CheckDrive.Web/CheckDrive.Web.sln

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.9.34728.123
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CheckDrive.Web", "CheckDrive.Web\CheckDrive.Web.csproj", "{7F91792F-530C-4443-AC8D-04D956B346F4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CheckDrive.Web", "CheckDrive.Web\CheckDrive.Web.csproj", "{7F91792F-530C-4443-AC8D-04D956B346F4}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

CheckDrive.Web/CheckDrive.Web/CheckDrive.Web.csproj

@@ -1,9 +1,40 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="Controllers\**" />
+    <Content Remove="Controllers\**" />
+    <EmbeddedResource Remove="Controllers\**" />
+    <None Remove="Controllers\**" />
+    <Compile Include="Controllers\AccountsController.cs" />
+    <Compile Include="Controllers\CarsController.cs" />
+    <Compile Include="Controllers\DashboardController.cs" />
+    <Compile Include="Controllers\DispatcherReviewsController.cs" />
+    <Compile Include="Controllers\DispatchersController.cs" />
+    <Compile Include="Controllers\DoctorReviewsController.cs" />
+    <Compile Include="Controllers\DoctorsController.cs" />
+    <Compile Include="Controllers\DriversController.cs" />
+    <Compile Include="Controllers\PersonalDoctorReviewsController.cs" />
+    <Compile Include="Controllers\RolesController.cs" />
+    <Compile Include="Controllers\MechanicAcceptancesController.cs" />
+    <Compile Include="Controllers\MechanicHandoversController.cs" />
+    <Compile Include="Controllers\MechanicsController.cs" />
+    <Compile Include="Controllers\OperatorReviewsController.cs" />
+    <Compile Include="Controllers\OperatorsController.cs" />
+    <Compile Include="Controllers\TechniciansController.cs" />
+
+    <PackageReference Include="CheckDrive.ApiContracts" Version="1.2.1" />
+    <PackageReference Include="CheckDrive.DTOs" Version="1.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.4" />
+    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.2" />
+    <PackageReference Include="Syncfusion.EJ2.AspNet.Core" Version="25.1.42" />
+    <PackageReference Include="Syncfusion.Licensing" Version="25.2.3" />
+
+  </ItemGroup>
+
 </Project>

CheckDrive.Web/CheckDrive.Web/Constants/Configurations.cs

@@ -0,0 +1,8 @@
+namespace CheckDrive.Web.Constants
+{
+    public static class Configurations
+    {
+        public const string JwtToken = "JwtToken";
+        public const string SynfusionLicenseKey = "Mgo+DSMBMAY9C3t2UFhhQlJBfVldWnxLflFyVWRTelx6cF1WESFaRnZdRl1mSH1TfkBgWXhXeXdV";
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/AccountsController.cs

@@ -0,0 +1,131 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Role;
+using CheckDrive.Web.Stores.Accounts;
+using CheckDrive.Web.Stores.Roles;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class AccountsController : Controller
+    {
+        private readonly IAccountDataStore _accountDataStore;
+        private readonly IRoleDataStore _roleStore;
+        public AccountsController(IAccountDataStore accountDataStore, IRoleDataStore roleDataStore)
+        {
+            _roleStore = roleDataStore;
+            _accountDataStore = accountDataStore;
+        }
+
+        public async Task<IActionResult> Index(string? searchString, int? roleId, DateTime? birthDate, int? pageNumber)
+        {
+            var accounts = await _accountDataStore.GetAccountsAsync(searchString, roleId, birthDate, pageNumber);
+
+            var roles = await GETRoles();
+
+            roles.Insert(0, new RoleDto
+            {
+                Id = 0,
+                Name = "Barcha ishchilar",
+            });
+            var selectedRole = roles[0];
+
+            if (roleId.HasValue && roleId != 0)
+            {
+                selectedRole = roles.FirstOrDefault(x => x.Id == roleId);
+            }
+
+            ViewBag.Accounts = accounts.Data;
+            ViewBag.Roles = roles;
+
+            ViewBag.PageSize = accounts.PageSize;
+            ViewBag.PageCount = accounts.TotalPages;
+            ViewBag.TotalCount = accounts.TotalCount;
+            ViewBag.CurrentPage = accounts.PageNumber;
+            ViewBag.HasPreviousPage = accounts.HasPreviousPage;
+            ViewBag.HasNextPage = accounts.HasNextPage;
+
+            ViewBag.SearchString = searchString;
+            ViewBag.CurrentRoleId = roleId;
+            ViewBag.SelectedRole = selectedRole;
+
+            return View();
+        }
+        public async Task<IActionResult> Details(int id)
+        {
+            var account = await _accountDataStore.GetAccountAsync(id);
+            if (account == null)
+            {
+                return NotFound();
+            }
+            return View(account);
+        }
+        public async Task<IActionResult> Create()
+        {
+            var roles = await GETRoles();
+            ViewBag.Roles = new SelectList(roles, "Id", "Name");
+            return View();
+        }
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("Login,Password,PhoneNumber,FirstName,LastName,Bithdate,RoleId")]
+            AccountForCreateDto account)
+        {
+            if (ModelState.IsValid)
+            {
+                await _accountDataStore.CreateAccountAsync(account);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(account);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var account = await _accountDataStore.GetAccountAsync(id);
+            if (account == null)
+            {
+                return NotFound();
+            }
+
+            return View(account);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,Login,Password,PhoneNumber,FirstName,LastName,Bithdate,RoleId")]
+            AccountForUpdateDto account)
+        {
+            if (ModelState.IsValid)
+            {
+                await _accountDataStore.UpdateAccountAsync(id, account);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(account);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var account = await _accountDataStore.GetAccountAsync(id);
+            if (account == null)
+            {
+                return NotFound();
+            }
+            return View(account);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _accountDataStore.DeleteAccountAsync(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<List<RoleDto>> GETRoles()
+        {
+            var roleResponse = await _roleStore.GetRoles();
+            var roles = roleResponse.Data.ToList();
+            return roles;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/CarsController.cs

@@ -0,0 +1,120 @@
+using CheckDrive.ApiContracts.Car;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Cars;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class CarsController : Controller
+    {
+        private readonly ICarDataStore _carDataStore;
+
+        public CarsController(ICarDataStore carDataStore)
+        {
+            _carDataStore = carDataStore;
+        }
+
+        public async Task<IActionResult> Index(string? searchString,int? pageNumber)
+        {
+            var cars = await _carDataStore.GetCars(searchString,pageNumber);
+
+            ViewBag.SearchString = searchString;
+            ViewBag.Cars = cars.Data;
+
+            ViewBag.PageSize = cars.PageSize;
+            ViewBag.PageCount = cars.TotalPages;
+            ViewBag.TotalCount = cars.TotalCount;
+            ViewBag.CurrentPage = cars.PageNumber;
+            ViewBag.HasPreviousPage = cars.HasPreviousPage;
+            ViewBag.HasNextPage = cars.HasNextPage;
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var car = await _carDataStore.GetCar(id);
+            if (car == null)
+            {
+                return NotFound();
+            }
+            return View(car);
+        }
+
+        public async Task<IActionResult> DetailsForMechanicAcceptance(int id)
+        {
+            var car = await _carDataStore.GetCar(id);
+            if (car == null)
+            {
+                return NotFound();
+            }
+            return PartialView("_CarDetailsForMechanicAcceptance", car);
+        }
+
+        public async Task<IActionResult> DetailsForMechanicHandover(int id)
+        {
+            var car = await _carDataStore.GetCar(id);
+            if (car == null)
+            {
+                return NotFound();
+            }
+            return PartialView("_CarDetailsForMechanicHandover", car);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("Model,Color,Number,RemainingFuel,MeduimFuelConsumption,FuelTankCapacity,ManufacturedYear")] CarForCreateDto car)
+        {
+            if (ModelState.IsValid)
+            {
+                await _carDataStore.CreateCar(car);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(car);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var car = await _carDataStore.GetCar(id);
+            if (car == null)
+            {
+                return NotFound();
+            }
+            return View(car);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,Model,Color,Number,RemainingFuel,MeduimFuelConsumption,FuelTankCapacity,ManufacturedYear")] CarForUpdateDto car)
+        {
+            if (ModelState.IsValid)
+            {
+                await _carDataStore.UpdateCar(id, car);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(car);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var car = await _carDataStore.GetCar(id);
+            if (car == null)
+            {
+                return NotFound();
+            }
+            return View(car);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _carDataStore.DeleteCar(id);
+            return RedirectToAction(nameof(Index));
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DashboardController.cs

@@ -0,0 +1,36 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DashboardController : Controller
+    {
+        public IActionResult Index()
+        {
+            List<SplineChartData> SplineData = new List<SplineChartData>
+            {
+                new SplineChartData { Days = "Yanvar", MaxTemp = 15, AvgTemp = 10, MinTemp = 2 },
+                new SplineChartData { Days = "Febral", MaxTemp = 22, AvgTemp = 18, MinTemp = 12 },
+                new SplineChartData { Days = "Mart", MaxTemp = 32, AvgTemp = 28, MinTemp = 22 },
+                new SplineChartData { Days = "Aprel", MaxTemp = 31, AvgTemp = 28, MinTemp = 23 },
+                new SplineChartData { Days = "May", MaxTemp = 29, AvgTemp = 26, MinTemp = 19 },
+                new SplineChartData { Days = "Iyun", MaxTemp = 24, AvgTemp = 20, MinTemp = 13 },
+                new SplineChartData { Days = "Iyul", MaxTemp = 18, AvgTemp = 15, MinTemp = 8 },
+                new SplineChartData { Days = "Avgust", MaxTemp = 18, AvgTemp = 23, MinTemp = 13 },
+                new SplineChartData { Days = "Sentabr", MaxTemp = 6, AvgTemp = 23, MinTemp = 3 },
+                new SplineChartData { Days = "Oktabr", MaxTemp = 23, AvgTemp = 15, MinTemp = 8 },
+                new SplineChartData { Days = "Noyabr", MaxTemp = 13, AvgTemp = 11, MinTemp = 17 },
+                new SplineChartData { Days = "Dekabr", MaxTemp = 12, AvgTemp = 21, MinTemp = 10 },
+            };
+            ViewBag.SplineData = SplineData;
+            return View();
+        }
+
+        public class SplineChartData
+        {
+            public string Days;
+            public double MaxTemp;
+            public double AvgTemp;
+            public double MinTemp;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DispatcherReviewsController.cs

@@ -0,0 +1,114 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.DispatcherReviews;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DispatcherReviewsController : Controller
+    {
+        private readonly IDispatcherReviewDataStore _dispatcherReviewDataStore;
+
+        public DispatcherReviewsController(IDispatcherReviewDataStore dispatcherReviewDataStore)
+        {
+            _dispatcherReviewDataStore = dispatcherReviewDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            var reviews = await _dispatcherReviewDataStore.GetDispatcherReviews();
+            return View(reviews);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var review = await _dispatcherReviewDataStore.GetDispatcherReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("FuelSpended,DistanceCovered,Date,DispatcherId,OperatorId,MechanicId,DriverId")] DispatcherReview dispatcherReview)
+        {
+            if (ModelState.IsValid)
+            {
+                await _dispatcherReviewDataStore.CreateDispatcherReview(dispatcherReview);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(dispatcherReview);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var review = await _dispatcherReviewDataStore.GetDispatcherReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,FuelSpended,DistanceCovered,Date,DispatcherId,OperatorId,MechanicId,DriverId")] DispatcherReview dispatcherReview)
+        {
+            if (id != dispatcherReview.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _dispatcherReviewDataStore.UpdateDispatcherReview(id, dispatcherReview);
+                }
+                catch (Exception)
+                {
+                    if (!await DispatcherReviewExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(dispatcherReview);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var review = await _dispatcherReviewDataStore.GetDispatcherReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _dispatcherReviewDataStore.DeleteDispatcherReview(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DispatcherReviewExists(int id)
+        {
+            var review = await _dispatcherReviewDataStore.GetDispatcherReview(id);
+            return review != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DispatchersController.cs

@@ -0,0 +1,114 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Dispatchers;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DispatchersController : Controller
+    {
+        private readonly IDispatcherDataStore _dispatcherDataStore;
+
+        public DispatchersController(IDispatcherDataStore dispatcherDataStore)
+        {
+            _dispatcherDataStore = dispatcherDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            var dispatchers = await _dispatcherDataStore.GetDispatchers();
+            return View(dispatchers);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var dispatcher = await _dispatcherDataStore.GetDispatcher(id);
+            if (dispatcher == null)
+            {
+                return NotFound();
+            }
+            return View(dispatcher);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] Dispatcher dispatcher)
+        {
+            if (ModelState.IsValid)
+            {
+                await _dispatcherDataStore.CreateDispatcher(dispatcher);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(dispatcher);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var dispatcher = await _dispatcherDataStore.GetDispatcher(id);
+            if (dispatcher == null)
+            {
+                return NotFound();
+            }
+            return View(dispatcher);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,AccountId")] Dispatcher dispatcher)
+        {
+            if (id != dispatcher.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _dispatcherDataStore.UpdateDispatcher(id, dispatcher);
+                }
+                catch (Exception)
+                {
+                    if (!await DispatcherExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(dispatcher);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var dispatcher = await _dispatcherDataStore.GetDispatcher(id);
+            if (dispatcher == null)
+            {
+                return NotFound();
+            }
+            return View(dispatcher);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _dispatcherDataStore.DeleteDispatcher(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DispatcherExists(int id)
+        {
+            var dispatcher = await _dispatcherDataStore.GetDispatcher(id);
+            return dispatcher != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DoctorReviewsController.cs

@@ -0,0 +1,134 @@
+using CheckDrive.ApiContracts.DoctorReview;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.DoctorReviews;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DoctorReviewsController : Controller
+    {
+        private readonly IDoctorReviewDataStore _doctorReviewDataStore;
+
+        public DoctorReviewsController(IDoctorReviewDataStore doctorReviewDataStore)
+        {
+            _doctorReviewDataStore = doctorReviewDataStore;
+        }
+
+        public async Task<IActionResult> Index(int? pageNumber)
+        {
+            var response = await _doctorReviewDataStore.GetDoctorReviews(pageNumber);
+
+            ViewBag.PageSize = response.PageSize;
+            ViewBag.PageCount = response.TotalPages;
+            ViewBag.TotalCount = response.TotalCount;
+            ViewBag.CurrentPage = response.PageNumber;
+            ViewBag.HasPreviousPage = response.HasPreviousPage;
+            ViewBag.HasNextPage = response.HasNextPage;
+
+            var doctorReviews = response.Data.Select(r => new
+            {
+                r.Id,
+                r.DriverName,
+                r.DoctorName,
+                IsHealthy = r.IsHealthy ? "Sog`lom" : "Kasal",
+                r.Comments
+            }).ToList();
+
+            ViewBag.DoctorsReview = doctorReviews;
+
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var review = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("IsHealthy,Comments,Date,DriverId,DoctorId")] DoctorReviewForCreateDto doctorReview)
+        {
+            if (ModelState.IsValid)
+            {
+                await _doctorReviewDataStore.CreateDoctorReview(doctorReview);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctorReview);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var review = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,IsHealthy,Comments,Date,DriverId,DoctorId")] DoctorReviewForUpdateDto doctorReview)
+        {
+            if (id != doctorReview.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _doctorReviewDataStore.UpdateDoctorReview(id, doctorReview);
+                }
+                catch (Exception)
+                {
+                    if (!await DoctorReviewExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctorReview);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var review = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (review == null)
+            {
+                return NotFound();
+            }
+            return View(review);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _doctorReviewDataStore.DeleteDoctorReview(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DoctorReviewExists(int id)
+        {
+            var review = await _doctorReviewDataStore.GetDoctorReview(id);
+            return review != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DoctorsController.cs

@@ -0,0 +1,116 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Doctor;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Doctors;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DoctorsController : Controller
+    {
+        private readonly IDoctorDataStore _doctorDataStore;
+
+        public DoctorsController(IDoctorDataStore doctorDataStore)
+        {
+            _doctorDataStore = doctorDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            var doctors = await _doctorDataStore.GetDoctors();
+            return View(doctors);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var doctor = await _doctorDataStore.GetDoctor(id);
+            if (doctor == null)
+            {
+                return NotFound();
+            }
+            return View(doctor);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] DoctorForCreateDto doctor)
+        {
+            if (ModelState.IsValid)
+            {
+                await _doctorDataStore.CreateDoctor(doctor);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctor);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var doctor = await _doctorDataStore.GetDoctor(id);
+            if (doctor == null)
+            {
+                return NotFound();
+            }
+            return View(doctor);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,AccountId")] AccountForUpdateDto doctor)
+        {
+            if (id != doctor.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _doctorDataStore.UpdateDoctor(id, doctor);
+                }
+                catch (Exception)
+                {
+                    if (!await DoctorExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctor);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var doctor = await _doctorDataStore.GetDoctor(id);
+            if (doctor == null)
+            {
+                return NotFound();
+            }
+            return View(doctor);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _doctorDataStore.DeleteDoctor(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DoctorExists(int id)
+        {
+            var doctor = await _doctorDataStore.GetDoctor(id);
+            return doctor != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/DriversController.cs

@@ -0,0 +1,113 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Driver;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Drivers;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class DriversController(IDriverDataStore driverDataStore) : Controller
+    {
+        private readonly IDriverDataStore _driverDataStore = driverDataStore;
+
+        public async Task<IActionResult> Index()
+        {
+            var drivers = await _driverDataStore.GetDriversAsync();
+
+            ViewBag.Drivers = drivers;
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var driver = await _driverDataStore.GetDriverAsync(id);
+            if (driver == null)
+            {
+                return NotFound();
+            }
+            return View(driver);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] DriverForCreateDto driver)
+        {
+            if (ModelState.IsValid)
+            {
+                await _driverDataStore.CreateDriverAsync(driver);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(driver);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var driver = await _driverDataStore.GetDriverAsync(id);
+            if (driver == null)
+            {
+                return NotFound();
+            }
+            return View(driver);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,AccountId")] AccountForUpdateDto driver)
+        {
+            if (id != driver.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _driverDataStore.UpdateDriverAsync(id, driver);
+                }
+                catch (Exception)
+                {
+                    if (!await DriverExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(driver);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var driver = await _driverDataStore.GetDriverAsync(id);
+            if (driver == null)
+            {
+                return NotFound();
+            }
+            return View(driver);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _driverDataStore.DeleteDriverAsync(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DriverExists(int id)
+        {
+            var driver = await _driverDataStore.GetDriverAsync(id);
+            return driver != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/MechanicAcceptancesController.cs

@@ -0,0 +1,140 @@
+using CheckDrive.ApiContracts;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Cars;
+using CheckDrive.Web.Stores.MechanicAcceptances;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class MechanicAcceptancesController : Controller
+    {
+        private readonly IMechanicAcceptanceDataStore _mechanicAcceptanceDataStore;
+        private readonly ICarDataStore _carDataStore;
+
+        public MechanicAcceptancesController(IMechanicAcceptanceDataStore mechanicAcceptanceDataStore, ICarDataStore carDataStore)
+        {
+            _mechanicAcceptanceDataStore = mechanicAcceptanceDataStore;
+            _carDataStore = carDataStore;
+        }
+
+        public async Task<IActionResult> Index(int? pageNumber)
+        {
+
+            var response = await _mechanicAcceptanceDataStore.GetMechanicAcceptancesAsync(pageNumber);
+
+            ViewBag.PageSize = response.PageSize;
+            ViewBag.PageCount = response.TotalPages;
+            ViewBag.TotalCount = response.TotalCount;
+            ViewBag.CurrentPage = response.PageNumber;
+            ViewBag.HasPreviousPage = response.HasPreviousPage;
+            ViewBag.HasNextPage = response.HasNextPage;
+
+            var mechanicAcceptances = response.Data.Select(r => new
+            {
+                r.Id,
+                IsAccepted = r.IsAccepted ? "Qabul qilindi" : "Rad etildi",
+                r.Comments,
+                Status = ((StatusForDto)r.Status) switch
+                {
+                    StatusForDto.Pending => "Pending",
+                    StatusForDto.Completed => "Completed",
+                    StatusForDto.Rejected => "Rejected",
+                    StatusForDto.Unassigned => "Unassigned",
+                    _ => "Unknown Status"
+                },
+                r.Date,
+                r.Distance,
+                r.DriverName,
+                r.MechanicName,
+                r.CarName,
+                r.CarId
+            }).ToList();
+
+
+            ViewBag.MechanicAcceptances = mechanicAcceptances;
+
+            return View();
+        }
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("IsAccepted,Comments,Status,Date,Distance")] MechanicAcceptance mechanicAcceptance)
+        {
+            if (ModelState.IsValid)
+            {
+                await _mechanicAcceptanceDataStore.CreateMechanicAcceptanceAsync(mechanicAcceptance);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanicAcceptance);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var mechanicAcceptance = await _mechanicAcceptanceDataStore.GetMechanicAcceptanceAsync(id);
+            if (mechanicAcceptance == null)
+            {
+                return NotFound();
+            }
+            return View(mechanicAcceptance);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,IsAccepted,Comments,Status,Date,Distance")] MechanicAcceptance mechanicAcceptance)
+        {
+            if (id != mechanicAcceptance.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _mechanicAcceptanceDataStore.UpdateMechanicAcceptanceAsync(id, mechanicAcceptance);
+                }
+                catch (Exception)
+                {
+                    if (!await MechanicAcceptanceExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanicAcceptance);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var mechanicAcceptance = await _mechanicAcceptanceDataStore.GetMechanicAcceptanceAsync(id);
+            if (mechanicAcceptance == null)
+            {
+                return NotFound();
+            }
+            return View(mechanicAcceptance);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _mechanicAcceptanceDataStore.DeleteMechanicAcceptanceAsync(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> MechanicAcceptanceExists(int id)
+        {
+            var mechanicAcceptance = await _mechanicAcceptanceDataStore.GetMechanicAcceptanceAsync(id);
+            return mechanicAcceptance != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/MechanicHandoversController.cs

@@ -0,0 +1,152 @@
+using CheckDrive.ApiContracts;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.MechanicHandovers;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class MechanicHandoversController : Controller
+    {
+        private readonly IMechanicHandoverDataStore _mechanicHandoverDataStore;
+
+        public MechanicHandoversController(IMechanicHandoverDataStore mechanicHandoverDataStore)
+        {
+            _mechanicHandoverDataStore = mechanicHandoverDataStore;
+        }
+
+        public async Task<IActionResult> Index(int? pageNumber)
+        {
+
+            var response = await _mechanicHandoverDataStore.GetMechanicHandoversAsync(pageNumber);
+
+            ViewBag.PageSize = response.PageSize;
+            ViewBag.PageCount = response.TotalPages;
+            ViewBag.TotalCount = response.TotalCount;
+            ViewBag.CurrentPage = response.PageNumber;
+            ViewBag.HasPreviousPage = response.HasPreviousPage;
+            ViewBag.HasNextPage = response.HasNextPage;
+
+            var mechanicHandovers = response.Data.Select(r => new
+            {
+                r.Id,
+                IsHanded = r.IsHanded ? "Qabul qilindi" : "Rad etildi",
+                r.Comments,
+                Status = ((StatusForDto)r.Status) switch
+                {
+                    StatusForDto.Pending => "Pending",
+                    StatusForDto.Completed => "Completed",
+                    StatusForDto.Rejected => "Rejected",
+                    StatusForDto.Unassigned => "Unassigned",
+                    _ => "Unknown Status"
+                },
+                r.Date,
+                r.Distance,
+                r.DriverName,
+                r.MechanicName,
+                r.CarName,
+                r.CarId
+            }).ToList();
+
+            if (mechanicHandovers == null)
+            {
+                return BadRequest();
+            }
+
+            ViewBag.MechanicHandovers = mechanicHandovers;
+
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var mechanicHandover = await _mechanicHandoverDataStore.GetMechanicHandoverAsync(id);
+            if (mechanicHandover == null)
+            {
+                return NotFound();
+            }
+            return View(mechanicHandover);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("IsHanded,Comments,Status,Date,MechanicId,CarId,DriverId")] MechanicHandover mechanicHandover)
+        {
+            if (ModelState.IsValid)
+            {
+                await _mechanicHandoverDataStore.CreateMechanicHandoverAsync(mechanicHandover);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanicHandover);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var mechanicHandover = await _mechanicHandoverDataStore.GetMechanicHandoverAsync(id);
+            if (mechanicHandover == null)
+            {
+                return NotFound();
+            }
+            return View(mechanicHandover);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,IsHanded,Comments,Status,Date,MechanicId,CarId,DriverId")] MechanicHandover mechanicHandover)
+        {
+            if (id != mechanicHandover.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _mechanicHandoverDataStore.UpdateMechanicHandoverAsync(id, mechanicHandover);
+                }
+                catch (Exception)
+                {
+                    if (!await MechanicHandoverExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanicHandover);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var mechanicHandover = await _mechanicHandoverDataStore.GetMechanicHandoverAsync(id);
+            if (mechanicHandover == null)
+            {
+                return NotFound();
+            }
+            return View(mechanicHandover);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _mechanicHandoverDataStore.DeleteMechanicHandoverAsync(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> MechanicHandoverExists(int id)
+        {
+            var mechanicHandover = await _mechanicHandoverDataStore.GetMechanicHandoverAsync(id);
+            return mechanicHandover != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/MechanicsController.cs

@@ -0,0 +1,114 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Mechanics;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class MechanicsController : Controller
+    {
+        private readonly IMechanicDataStore _mechanicDataStore;
+
+        public MechanicsController(IMechanicDataStore mechanicDataStore)
+        {
+            _mechanicDataStore = mechanicDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            var mechanics = await _mechanicDataStore.GetMechanicsAsync();
+            return View(mechanics);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var mechanic = await _mechanicDataStore.GetMechanicAsync(id);
+            if (mechanic == null)
+            {
+                return NotFound();
+            }
+            return View(mechanic);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] Mechanic mechanic)
+        {
+            if (ModelState.IsValid)
+            {
+                await _mechanicDataStore.CreateMechanicAsync(mechanic);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanic);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var mechanic = await _mechanicDataStore.GetMechanicAsync(id);
+            if (mechanic == null)
+            {
+                return NotFound();
+            }
+            return View(mechanic);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,AccountId")] Mechanic mechanic)
+        {
+            if (id != mechanic.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _mechanicDataStore.UpdateMechanicAsync(id, mechanic);
+                }
+                catch (Exception)
+                {
+                    if (!await MechanicExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(mechanic);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var mechanic = await _mechanicDataStore.GetMechanicAsync(id);
+            if (mechanic == null)
+            {
+                return NotFound();
+            }
+            return View(mechanic);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _mechanicDataStore.DeleteMechanicAsync(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> MechanicExists(int id)
+        {
+            var mechanic = await _mechanicDataStore.GetMechanicAsync(id);
+            return mechanic != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/OperatorReviewsController.cs

@@ -0,0 +1,118 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.OperatorReviews;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class OperatorReviewsController(IOperatorReviewDataStore operatorReviewDataStore) : Controller
+    {
+        private readonly IOperatorReviewDataStore _operatorReviewDataStore = operatorReviewDataStore;
+
+        public async Task<IActionResult> Index()
+        {
+
+            var operatorReviews = await _operatorReviewDataStore.GetOperatorsReviews();
+
+            if (operatorReviews is null)
+            {
+                return BadRequest();
+            }
+
+            ViewBag.OperatorsReview = operatorReviews.Data;
+            return View();
+
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var operatorReview = await _operatorReviewDataStore.GetOperatorReview(id);
+            if (operatorReview == null)
+            {
+                return NotFound();
+            }
+            return View(operatorReview);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("OilAmount,Comments,Status,Date,OperatorId,DriverId")] OperatorReview operatorReview)
+        {
+            if (ModelState.IsValid)
+            {
+                await _operatorReviewDataStore.CreateOperatorReview(operatorReview);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(operatorReview);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var operatorReview = await _operatorReviewDataStore.GetOperatorReview(id);
+            if (operatorReview == null)
+            {
+                return NotFound();
+            }
+            return View(operatorReview);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,OilAmount,Comments,Status,Date,OperatorId,DriverId")] OperatorReview operatorReview)
+        {
+            if (id != operatorReview.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _operatorReviewDataStore.UpdateOperatorReview(id, operatorReview);
+                }
+                catch (Exception)
+                {
+                    if (!await OperatorReviewExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(operatorReview);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var operatorReview = await _operatorReviewDataStore.GetOperatorReview(id);
+            if (operatorReview == null)
+            {
+                return NotFound();
+            }
+            return View(operatorReview);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _operatorReviewDataStore.DeleteOperatorReview(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> OperatorReviewExists(int id)
+        {
+            var operatorReview = await _operatorReviewDataStore.GetOperatorReview(id);
+            return operatorReview != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/OperatorsController.cs

@@ -0,0 +1,120 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Accounts;
+using CheckDrive.Web.Stores.Operators;
+using CheckDrive.Web.Stores.Roles;
+using Microsoft.AspNetCore.Mvc;
+using Syncfusion.EJ2.PivotView;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class OperatorsController : Controller
+    {
+        private readonly IOperatorDataStore _operatorDataStore;
+        private readonly IAccountDataStore _accountDataStore;
+        private readonly IRoleDataStore _roleDataStore;
+
+        public OperatorsController(IOperatorDataStore operatorDataStore, IAccountDataStore accountDataStore, IRoleDataStore roleDataStore)
+        {
+            _operatorDataStore = operatorDataStore;
+            _accountDataStore = accountDataStore;
+            _roleDataStore = roleDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var @operator = await _operatorDataStore.GetOperator(id);
+            if (@operator == null)
+            {
+                return NotFound();
+            }
+            return View(@operator);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] Operator @operator)
+        {
+            if (ModelState.IsValid)
+            {
+                await _operatorDataStore.CreateOperator(@operator);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(@operator);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var @operator = await _operatorDataStore.GetOperator(id);
+            if (@operator == null)
+            {
+                return NotFound();
+            }
+            return View(@operator);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,AccountId")] Operator @operator)
+        {
+            if (id != @operator.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _operatorDataStore.UpdateOperator(id, @operator);
+                }
+                catch (Exception)
+                {
+                    if (!await OperatorExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(@operator);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var @operator = await _operatorDataStore.GetOperator(id);
+            if (@operator == null)
+            {
+                return NotFound();
+            }
+            return View(@operator);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _operatorDataStore.DeleteOperator(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> OperatorExists(int id)
+        {
+            var @operator = await _operatorDataStore.GetOperator(id);
+            return @operator != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/PersonalDoctorReviewsController.cs

@@ -0,0 +1,169 @@
+using CheckDrive.ApiContracts.DoctorReview;
+using CheckDrive.Web.Stores.DoctorReviews;
+using CheckDrive.Web.Stores.Doctors;
+using CheckDrive.Web.Stores.Drivers;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class PersonalDoctorReviewsController : Controller
+    {
+        private readonly IDoctorReviewDataStore _doctorReviewDataStore;
+        private readonly IDoctorDataStore _doctorDataStore;
+        private readonly IDriverDataStore _driverDataStore;
+
+        public PersonalDoctorReviewsController(IDoctorReviewDataStore doctorReviewDataStore, IDoctorDataStore doctorDataStore, IDriverDataStore driverDataStore)
+        {
+            _doctorReviewDataStore = doctorReviewDataStore;
+            _doctorDataStore = doctorDataStore;
+            _driverDataStore = driverDataStore;
+        }
+
+        public IActionResult HelloPage()
+        {
+            return View();
+        }
+
+        public async Task<IActionResult> Index(int? pageNumber)
+        {
+            var response = await _doctorReviewDataStore.GetDoctorReviews( pageNumber);
+            var doctorReviews = response.Data.Select(r => new
+            {
+                r.Id,
+                r.DriverName,
+                r.DoctorName,
+                IsHealthy = r.IsHealthy ? "Sog`lom" : "Kasal",
+                r.Comments
+            }).ToList();
+
+            ViewBag.DoctorsReview = doctorReviews;
+
+            return View();
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var doctorReview = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (doctorReview == null)
+            {
+                return NotFound();
+            }
+            return View(doctorReview);
+        }
+
+        public async Task<IActionResult> Create()
+        {
+            var doctors = await GETDoctors();
+            var drivers = await GETDrivers();
+
+            ViewBag.Drivers = new SelectList(drivers, "Value", "Text");
+            ViewBag.Doctors = new SelectList(doctors, "Value", "Text");
+
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("IsHealthy,Comments,Date,DriverId,DoctorId")] DoctorReviewForCreateDto doctorReview)
+        {
+            if (ModelState.IsValid)
+            {
+                await _doctorReviewDataStore.CreateDoctorReview(doctorReview);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctorReview);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var doctorReview = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (doctorReview == null)
+            {
+                return NotFound();
+            }
+            return View(doctorReview);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,IsHealthy,Comments,Date,DriverId,DoctorId")] DoctorReviewForUpdateDto doctorReview)
+        {
+            if (id != doctorReview.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _doctorReviewDataStore.UpdateDoctorReview(id, doctorReview);
+                }
+                catch (Exception)
+                {
+                    if (!await DoctorReviewExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(doctorReview);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var doctorReview = await _doctorReviewDataStore.GetDoctorReview(id);
+            if (doctorReview == null)
+            {
+                return NotFound();
+            }
+            return View(doctorReview);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _doctorReviewDataStore.DeleteDoctorReview(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> DoctorReviewExists(int id)
+        {
+            var doctorReview = await _doctorReviewDataStore.GetDoctorReview(id);
+            return doctorReview != null;
+        }
+
+        private async Task<List<SelectListItem>> GETDrivers()
+        {
+            var driverResponse = await _driverDataStore.GetDriversAsync();
+            var drivers = driverResponse.Data
+                .Select(d => new SelectListItem
+                {
+                    Value = d.Id.ToString(),
+                    Text = $"{d.FirstName} {d.LastName}"
+                })
+                .ToList();
+            return drivers;
+        }
+
+        private async Task<List<SelectListItem>> GETDoctors()
+        {
+            var doctorResponse = await _doctorDataStore.GetDoctors();
+            var doctors = doctorResponse.Data
+                .Select(d => new SelectListItem
+                {
+                    Value = d.Id.ToString(),
+                    Text = $"{d.FirstName} {d.LastName}"
+                })
+                .ToList();
+            return doctors;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/RolesController.cs

@@ -0,0 +1,112 @@
+using CheckDrive.ApiContracts.Role;
+using CheckDrive.DTOs.Role;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Roles;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class RolesController : Controller
+    {
+        private readonly IRoleDataStore _roleDataStore;
+
+        public RolesController(IRoleDataStore roleDataStore)
+        {
+            _roleDataStore = roleDataStore;
+        }
+
+        public async Task<IActionResult> Index()
+        {
+            var roles = await _roleDataStore.GetRoles();
+            return View(roles);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var role = await _roleDataStore.GetRole(id);
+            if (role == null)
+            {
+                return NotFound();
+            }
+            return View(role);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("Name")] ApiContracts.Role.RoleForCreateDto role)
+        {
+            if (ModelState.IsValid)
+            {
+                await _roleDataStore.CreateRole(role);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(role);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var role = await _roleDataStore.GetRole(id);
+            if (role == null)
+            {
+                return NotFound();
+            }
+            return View(role);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id,Name")] ApiContracts.Role.RoleForCreateDto role)
+        {
+
+            if (ModelState.IsValid)
+            {
+                try
+                {
+                    await _roleDataStore.UpdateRole(id, role);
+                }
+                catch (Exception)
+                {
+                    if (!await RoleExists(id))
+                    {
+                        return NotFound();
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                return RedirectToAction(nameof(Index));
+            }
+            return View(role);
+        }
+
+        public async Task<IActionResult> Delete(int id)
+        {
+            var role = await _roleDataStore.GetRole(id);
+            if (role == null)
+            {
+                return NotFound();
+            }
+            return View(role);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _roleDataStore.DeleteRole(id);
+            return RedirectToAction(nameof(Index));
+        }
+
+        private async Task<bool> RoleExists(int id)
+        {
+            var role = await _roleDataStore.GetRole(id);
+            return role != null;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Controllers/TechniciansController.cs

@@ -0,0 +1,92 @@
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Stores.Technicians;
+using Microsoft.AspNetCore.Mvc;
+
+namespace CheckDrive.Web.Controllers
+{
+    public class TechniciansController : Controller
+    {
+        private readonly ITechnicianDataStore _technicianDataStore;
+
+        public TechniciansController(ITechnicianDataStore technicianDataStore)
+        {
+            _technicianDataStore = technicianDataStore;
+        }
+        public async Task<IActionResult> Index()
+        {
+            var technicians = await _technicianDataStore.GetTechnicians();
+            return View(technicians);
+        }
+
+        public async Task<IActionResult> Details(int id)
+        {
+            var technician = await _technicianDataStore.GetTechnician(id);
+            if (technician == null)
+            {
+                return NotFound();
+            }
+            return View(technician);
+        }
+
+        public IActionResult Create()
+        {
+            return View();
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Create([Bind("AccountId")] Technician technician)
+        {
+            if (ModelState.IsValid)
+            {
+                await _technicianDataStore.CreateTechnician(technician);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(technician);
+        }
+
+        public async Task<IActionResult> Edit(int id)
+        {
+            var technician = await _technicianDataStore.GetTechnician(id);
+            if (technician == null)
+            {
+                return NotFound();
+            }
+            return View(technician);
+        }
+
+        [HttpPost]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Edit(int id, [Bind("Id, AccountId")] Technician technician)
+        {
+            if (id != technician.Id)
+            {
+                return NotFound();
+            }
+
+            if (ModelState.IsValid)
+            {
+                await _technicianDataStore.UpdateTechnician(id, technician);
+                return RedirectToAction(nameof(Index));
+            }
+            return View(technician);
+        }
+        public async Task<IActionResult> Delete(int id)
+        {
+            var technician = await _technicianDataStore.GetTechnician(id);
+            if (technician == null)
+            {
+                return NotFound();
+            }
+            return View(technician);
+        }
+
+        [HttpPost, ActionName("Delete")]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> DeleteConfirmed(int id)
+        {
+            await _technicianDataStore.DeleteTechnician(id);
+            return RedirectToAction(nameof(Index));
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Exceptions/ApiException.cs

@@ -0,0 +1,20 @@
+using System.Net;
+
+namespace CheckDrive.Web.Exceptions
+{
+    public class ApiException : Exception
+    {
+        public HttpStatusCode StatusCode { get; private set; }
+
+        public ApiException(HttpStatusCode statusCode) : base()
+        {
+            StatusCode = statusCode;
+        }
+
+        public ApiException(HttpStatusCode statusCode, string message) :
+            base(message)
+        {
+            StatusCode = statusCode;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Extensions/ConfigureServiceExtensions.cs

@@ -0,0 +1,48 @@
+using CheckDrive.Web.Service;
+using CheckDrive.Web.Stores.Accounts;
+using CheckDrive.Web.Stores.Cars;
+using CheckDrive.Web.Stores.DispatcherReviews;
+using CheckDrive.Web.Stores.Dispatchers;
+using CheckDrive.Web.Stores.DoctorReviews;
+using CheckDrive.Web.Stores.Doctors;
+using CheckDrive.Web.Stores.Drivers;
+using CheckDrive.Web.Stores.MechanicAcceptances;
+using CheckDrive.Web.Stores.MechanicHandovers;
+using CheckDrive.Web.Stores.Mechanics;
+using CheckDrive.Web.Stores.OperatorReviews;
+using CheckDrive.Web.Stores.Operators;
+using CheckDrive.Web.Stores.Roles;
+using CheckDrive.Web.Stores.Technicians;
+
+namespace CheckDrive.Web.Extensions
+{
+    public static class ConfigureServiceExtensions
+    {
+        public static IServiceCollection ConfigureDataStores(this IServiceCollection services)
+        {
+            services.AddScoped<IAccountDataStore, AccountDataStore>();
+            services.AddScoped<ICarDataStore, CarDataStore>();
+            services.AddScoped<IDispatcherReviewDataStore, MockDispatcherReviewDataStore>();
+            services.AddScoped<IDispatcherDataStore, MockDispatcherDataStore>();
+            services.AddScoped<IDoctorDataStore, DoctorDataStore>();
+            services.AddScoped<IDoctorReviewDataStore, DoctorReviewDataStore>();
+            services.AddScoped<IDriverDataStore, DriverDataStore>();
+            services.AddScoped<IMechanicAcceptanceDataStore, MechanicAcceptanceDataStore>();
+            services.AddScoped<IMechanicHandoverDataStore, MechanicHandoverDataStore>();
+            services.AddScoped<IMechanicDataStore, MechanicDataStore>();
+            services.AddScoped<IOperatorReviewDataStore, OperatorReviewDataStore>();
+            services.AddScoped<IOperatorDataStore, OperatorDataStore>();
+            services.AddScoped<IRoleDataStore, RoleDataStore>();
+            services.AddScoped<ITechnicianDataStore, MockTechnicianDataStore>();
+
+            return services;
+        }
+
+        public static IServiceCollection ConfigureServices(this IServiceCollection services)
+        {
+            services.AddSingleton<ApiClient>();
+
+            return services;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Filters/ApiExceptionFilter.cs

@@ -0,0 +1,24 @@
+using CheckDrive.Web.Exceptions;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace CheckDrive.Web.Filters
+{
+    public class ApiExceptionFilter : IExceptionFilter
+    {
+        public void OnException(ExceptionContext context)
+        {
+            if (context.Exception is ApiException exception)
+            {
+                int statusCode = (int)exception.StatusCode;
+                context.Result = new RedirectToActionResult("Error", "Home", new { statusCode });
+                context.ExceptionHandled = true;
+            }
+            else
+            {
+                context.Result = new RedirectToActionResult("Error", "Home", new { statusCode = 500 });
+                context.ExceptionHandled = true;
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Helpers/PaginatedList.cs

@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace CheckDrive.Web.Helpers
+{
+    public class PaginatedList<T> : List<T>
+    {
+        public int PageIndex { get; private set; }
+        public int TotalPages { get; private set; }
+
+        public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)
+        {
+            PageIndex = pageIndex;
+            TotalPages = (int)Math.Ceiling(count / (double)pageSize);
+
+            AddRange(items);
+        }
+
+        public bool HasPreviousPage => PageIndex > 1;
+
+        public bool HasNextPage => PageIndex < TotalPages;
+
+        public static async Task<PaginatedList<T>> CreateAsync(IQueryable<T> source, int pageIndex, int pageSize)
+        {
+            var count = await source.CountAsync();
+            var items = await source.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
+            return new PaginatedList<T>(items, count, pageIndex, pageSize);
+        }
+
+        public static PaginatedList<T> Create(IQueryable<T> source, int pageIndex, int pageSize)
+        {
+            var count = source.Count();
+            var items = source.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
+            return new PaginatedList<T>(items, count, pageIndex, pageSize);
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Account.cs

@@ -0,0 +1,24 @@
+namespace CheckDrive.Web.Models
+{
+    public class Account
+    {
+        public int Id { get; set; }
+        public string Login { get; set; }
+        public string Password { get; set; }
+        public string PhoneNumber { get; set; }
+        public string FirstName { get; set; }
+        public string LastName { get; set; }
+        public DateTime Bithdate { get; set; }
+
+        public string RoleName { get; set; }
+        public Role Role { get; set; }
+
+        public virtual ICollection<Dispatcher> Dispatchers { get; set; }
+        public virtual ICollection<Operator> Operators { get; set; }
+        public virtual ICollection<Mechanic> Mechanics { get; set; }
+        public virtual ICollection<Driver> Drivers { get; set; }
+        public virtual ICollection<Doctor> Doctors { get; set; }
+        public virtual ICollection<Technician> Technicians { get; set; }
+    }
+}
+

CheckDrive.Web/CheckDrive.Web/Models/Car.cs

@@ -0,0 +1,16 @@
+namespace CheckDrive.Web.Models
+{
+    public class Car
+    {
+        public int Id { get; set; }
+        public string Model { get; set; }
+        public string Color { get; set; }
+        public string Number { get; set; }
+        public double MeduimFuelConsumption { get; set; }
+        public double RemainingFuel { get; set; }
+        public double FuelTankCapacity { get; set; }
+        public int ManufacturedYear { get; set; }
+
+        public virtual ICollection<MechanicHandover> MechanicHandovers { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Dispatcher.cs

@@ -0,0 +1,11 @@
+namespace CheckDrive.Web.Models
+{
+    public class Dispatcher
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+
+        public virtual ICollection<DispatcherReview> DispetcherReviews { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/DispatcherReview.cs

@@ -0,0 +1,19 @@
+namespace CheckDrive.Web.Models
+{
+    public class DispatcherReview
+    {
+        public int Id { get; set; }
+        public double FuelSpended { get; set; }
+        public double DistanceCovered { get; set; }
+        public DateTime Date { get; set; }
+
+        public int DispatcherId { get; set; }
+        public Dispatcher Dispatcher { get; set; }
+        public int OperatorId { get; set; }
+        public Operator Operator { get; set; }
+        public int MechanicId { get; set; }
+        public Mechanic Mechanic { get; set; }
+        public int DriverId { get; set; }
+        public Driver Driver { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Doctor.cs

@@ -0,0 +1,11 @@
+namespace CheckDrive.Web.Models
+{
+    public class Doctor
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+
+        public virtual ICollection<DoctorReview> DoctorReviews { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/DoctorReview.cs

@@ -0,0 +1,15 @@
+namespace CheckDrive.Web.Models
+{
+    public class DoctorReview
+    {
+        public int Id { get; set; }
+        public bool IsHealthy { get; set; }
+        public string? Comments { get; set; }
+        public DateTime Date { get; set; }
+
+        public int DriverId { get; set; }
+        public Driver Driver { get; set; }
+        public int DoctorId { get; set; }
+        public Doctor Doctor { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Driver.cs

@@ -0,0 +1,14 @@
+namespace CheckDrive.Web.Models
+{
+    public class Driver
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+
+        public virtual ICollection<DispatcherReview> DispetcherReviews { get; set; }
+        public virtual ICollection<DoctorReview> DoctorReviews { get; set; }
+        public virtual ICollection<MechanicHandover> MechanicHandovers { get; set; }
+        public virtual ICollection<OperatorReview> OperatorReviews { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Mechanic.cs

@@ -0,0 +1,12 @@
+namespace CheckDrive.Web.Models
+{
+    public class Mechanic
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+
+        public virtual ICollection<DispatcherReview> DispetcherReviews { get; set; }
+        public virtual ICollection<MechanicHandover> MechanicHandovers { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/MechanicAcceptance.cs

@@ -0,0 +1,16 @@
+namespace CheckDrive.Web.Models
+{
+    public class MechanicAcceptance
+    {
+        public int Id { get; set; }
+
+        public bool IsAccepted { get; set; }
+        public string? Comments { get; set; }
+        public Status Status { get; set; }
+        public DateTime Date { get; set; }
+        public double Distance { get; set; }
+
+        public int MechanicHandoverId { get; set; }
+        public MechanicHandover MechanicHandover { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/MechanicHandover.cs

@@ -0,0 +1,20 @@
+namespace CheckDrive.Web.Models
+{
+    public class MechanicHandover
+    {
+        public int Id { get; set; }
+        public bool IsHanded { get; set; }
+        public string? Comments { get; set; }
+        public Status Status { get; set; }
+        public DateTime Date { get; set; }
+
+        public int MechanicId { get; set; }
+        public Mechanic Mechanic { get; set; }
+        public int CarId { get; set; }
+        public Car Car { get; set; }
+        public int DriverId { get; set; }
+        public Driver Driver { get; set; }
+
+        public virtual ICollection<MechanicAcceptance> MechanicAcceptances { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Operator.cs

@@ -0,0 +1,12 @@
+namespace CheckDrive.Web.Models
+{
+    public class Operator
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+
+        public virtual ICollection<DispatcherReview> DispetcherReviews { get; set; }
+        public virtual ICollection<OperatorReview> OperatorReviews { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/OperatorReview.cs

@@ -0,0 +1,16 @@
+namespace CheckDrive.Web.Models
+{
+    public class OperatorReview
+    {
+        public int Id { get; set; }
+        public double OilAmount { get; set; }
+        public string? Comments { get; set; }
+        public Status Status { get; set; }
+        public DateTime Date { get; set; }
+
+        public int OperatorId { get; set; }
+        public Operator Operator { get; set; }
+        public int DriverId { get; set; }
+        public Driver Driver { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Role.cs

@@ -0,0 +1,10 @@
+namespace CheckDrive.Web.Models
+{
+    public class Role
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+
+        public virtual ICollection<Account> Accounts { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Status.cs

@@ -0,0 +1,10 @@
+namespace CheckDrive.Web.Models
+{
+    public enum Status
+    {
+        Pending,
+        Completed,
+        Rejected,
+        Unassigned
+    }
+}

CheckDrive.Web/CheckDrive.Web/Models/Technician.cs

@@ -0,0 +1,9 @@
+namespace CheckDrive.Web.Models
+{
+    public class Technician
+    {
+        public int Id { get; set; }
+        public int AccountId { get; set; }
+        public Account Account { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Program.cs

@@ -1,7 +1,18 @@
+using CheckDrive.Web.Constants;
+using CheckDrive.Web.Extensions;
+using CheckDrive.Web.Filters;
+
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
-builder.Services.AddControllersWithViews();
+builder.Services.AddControllersWithViews(options =>
+    options.Filters.Add(new ApiExceptionFilter()));
+builder.Services.ConfigureDataStores();
+builder.Services.ConfigureServices();
+builder.Services.AddHttpContextAccessor();
+
+Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense(Configurations.SynfusionLicenseKey);
 
 var app = builder.Build();
 
@@ -22,6 +33,6 @@
 
 app.MapControllerRoute(
     name: "default",
-    pattern: "{controller=Home}/{action=Index}/{id?}");
+    pattern: "{controller=Dashboard}/{action=index}/{id?}");
 
 app.Run();

CheckDrive.Web/CheckDrive.Web/Responses/GetAccountResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.ApiContracts.Account;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetAccountResponse : GetBaseResponse<AccountDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetBaseResponse.cs

@@ -0,0 +1,13 @@
+namespace CheckDrive.Web.Responses
+{
+    public abstract class GetBaseResponse<T>
+    {
+        public IEnumerable<T>? Data { get; set; }
+        public int PageNumber { get; set; }
+        public int PageSize { get; set; }
+        public bool HasNextPage { get; set; }
+        public bool HasPreviousPage { get; set; }
+        public int TotalPages { get; set; }
+        public int TotalCount { get; set; }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetCarResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetCarResponse : GetBaseResponse<Car>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetDispatcherResponse.cs

@@ -0,0 +1,8 @@
+using Microsoft.AspNetCore.Components;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetDispatcherResponse : GetBaseResponse<Dispatcher>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetDispatcherReviewResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetDispatcherReviewResponse : GetBaseResponse<DispatcherReview>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetDoctorResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.ApiContracts.Doctor;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetDoctorResponse : GetBaseResponse<DoctorDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetDoctorReviewResponse.cs

@@ -0,0 +1,9 @@
+using CheckDrive.ApiContracts.DoctorReview;
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetDoctorReviewResponse : GetBaseResponse<DoctorReviewDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetDriverResponse.cs

@@ -0,0 +1,9 @@
+using CheckDrive.ApiContracts.Driver;
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetDriverResponse : GetBaseResponse<DriverDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetMechanicAcceptanceResponse.cs

@@ -0,0 +1,6 @@
+namespace CheckDrive.Web.Responses
+{
+    public class GetMechanicAcceptanceResponse : GetBaseResponse<ApiContracts.MechanicAcceptance.MechanicAcceptanceDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetMechanicHandoverResponse.cs

@@ -0,0 +1,6 @@
+namespace CheckDrive.Web.Responses
+{
+    public class GetMechanicHandoverResponse : GetBaseResponse<ApiContracts.MechanicHandover.MechanicHandoverDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetMechanicResponse.cs

@@ -0,0 +1,6 @@
+namespace CheckDrive.Web.Responses
+{
+    public class GetMechanicResponse : GetBaseResponse<ApiContracts.Mechanic.MechanicDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetOperatorResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetOperatorResponse : GetBaseResponse<Operator>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetOperatorReviewResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetOperatorReviewResponse : GetBaseResponse<ApiContracts.OperatorReview.OperatorReviewDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetRoleResponse.cs

@@ -0,0 +1,9 @@
+using CheckDrive.ApiContracts.Role;
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetRoleResponse : GetBaseResponse<RoleDto>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Responses/GetTechnicianResponse.cs

@@ -0,0 +1,8 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Responses
+{
+    public class GetTechnicianResponse : GetBaseResponse<Technician>
+    {
+    }
+}

CheckDrive.Web/CheckDrive.Web/Service/ApiClient.cs

@@ -0,0 +1,94 @@
+using CheckDrive.Web.Constants;
+using CheckDrive.Web.Exceptions;
+
+namespace CheckDrive.Web.Service
+{
+    public class ApiClient
+    {
+        private const string baseUrl = "https://v1n3bj45-7111.euw.devtunnels.ms/api";
+
+        private readonly HttpClient _client = new();
+        private readonly IHttpContextAccessor _contextAccessor;
+
+        public ApiClient(IHttpContextAccessor contextAccessor)
+        {
+            _client.BaseAddress = new Uri(baseUrl);
+            _client.DefaultRequestHeaders.Add("Accept", "application/json");
+            _contextAccessor = contextAccessor ?? throw new ArgumentNullException(nameof(contextAccessor));
+        }
+
+        public async Task<HttpResponseMessage> GetAsync(string url)
+        {
+            string token = string.Empty;
+            var request = new HttpRequestMessage(HttpMethod.Get, _client.BaseAddress?.AbsolutePath + "/" + url);
+            _contextAccessor.HttpContext?.Request.Cookies.TryGetValue(Configurations.JwtToken, out token);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
+
+            var response = await _client.SendAsync(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new ApiException(response.StatusCode, $"Error fetching url: {url}");
+            }
+
+            return response;
+        }
+
+        public async Task<HttpResponseMessage> PostAsync(string url, string data)
+        {
+            string token = string.Empty;
+            var request = new HttpRequestMessage(HttpMethod.Post, _client.BaseAddress?.AbsolutePath + "/" + url)
+            {
+                Content = new StringContent(data, System.Text.Encoding.UTF8, "application/json")
+            };
+            _contextAccessor.HttpContext?.Request.Cookies.TryGetValue(Configurations.JwtToken, out token);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
+
+            var response = await _client.SendAsync(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new ApiException(response.StatusCode, $"Error fetching url: {url}");
+            }
+
+            return response;
+        }
+
+        public async Task<HttpResponseMessage> PutAsync(string url, string data)
+        {
+            string token = string.Empty;
+            var request = new HttpRequestMessage(HttpMethod.Put, _client.BaseAddress?.AbsolutePath + "/" + url)
+            {
+                Content = new StringContent(data, System.Text.Encoding.UTF8, "application/json")
+            };
+            _contextAccessor.HttpContext?.Request.Cookies.TryGetValue(Configurations.JwtToken, out token);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
+
+            var response = await _client.SendAsync(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new ApiException(response.StatusCode, $"Error fetching url: {url}");
+            }
+
+            return response;
+        }
+
+        public async Task<HttpResponseMessage> DeleteAsync(string url)
+        {
+            string token = string.Empty;
+            var request = new HttpRequestMessage(HttpMethod.Delete, _client.BaseAddress?.AbsolutePath + "/" + url);
+            _contextAccessor.HttpContext?.Request.Cookies.TryGetValue(Configurations.JwtToken, out token);
+            request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
+
+            var response = await _client.SendAsync(request);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new ApiException(response.StatusCode, $"Error fetching url: {url}");
+            }
+
+            return response;
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Accounts/AccountDataStore.cs

@@ -0,0 +1,111 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.Web.Responses;
+using CheckDrive.Web.Service;
+using Newtonsoft.Json;
+using System.Text;
+
+namespace CheckDrive.Web.Stores.Accounts
+{
+    public class AccountDataStore : IAccountDataStore
+    {
+        private readonly ApiClient _api;
+
+        public AccountDataStore(ApiClient apiClient)
+        {
+            _api = apiClient;
+        }
+
+
+        public async Task<GetAccountResponse> GetAccountsAsync(string? searchString, int? roleId, DateTime? birthDate, int? pageNumber)
+        {
+            StringBuilder query = new("");
+
+            if (birthDate is not null)
+            {
+                query.Append($"birthDate={birthDate.Value.ToString("MM/dd/yyyy")}&");
+            }
+            if (!string.IsNullOrWhiteSpace(searchString))
+            {
+                query.Append($"searchString={searchString}&");
+            }
+            if (roleId is not null)
+            {
+                query.Append($"roleId={roleId}&");
+            }
+            if (pageNumber != null)
+            {
+                query.Append($"pageNumber={pageNumber}");
+            }
+
+            var response = await _api.GetAsync("accounts?" + query.ToString());
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Could not fetch accounts.");
+            }
+
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<GetAccountResponse>(json);
+
+            return result;
+        }
+
+        public async Task<AccountDto> GetAccountAsync(int id)
+
+        {
+            var response = await _api.GetAsync($"accounts/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not fetch account with id: {id}.");
+            }
+
+            var json = await response.Content.ReadAsStringAsync();
+            var result = JsonConvert.DeserializeObject<AccountDto>(json);
+
+            return result;
+        }
+
+        public async Task<AccountDto> CreateAccountAsync(AccountForCreateDto account)
+        {
+            var json = JsonConvert.SerializeObject(account);
+            var response = await _api.PostAsync("accounts", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error creating account.");
+            }
+
+            var jsonResponse = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<AccountDto>(jsonResponse);
+        }
+
+
+
+        public async Task<AccountDto> UpdateAccountAsync(int id, AccountForUpdateDto account)
+        {
+            var json = JsonConvert.SerializeObject(account);
+            var response = await _api.PutAsync($"accounts/{account.Id}", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error updating account.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<AccountDto>(jsonResponse);
+        }
+
+        public async Task DeleteAccountAsync(int id)
+        {
+            var response = await _api.DeleteAsync($"accounts/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not delete account with id: {id}.");
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Accounts/IAccountDataStore.cs

@@ -0,0 +1,14 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.Web.Responses;
+
+namespace CheckDrive.Web.Stores.Accounts
+{
+    public interface IAccountDataStore
+    {
+        Task<GetAccountResponse> GetAccountsAsync(string? searchString, int? roleId, DateTime? birthDate, int? pageNumber);
+        Task<AccountDto> GetAccountAsync(int id);
+        Task<AccountDto> CreateAccountAsync(AccountForCreateDto account);
+        Task<AccountDto> UpdateAccountAsync(int id, AccountForUpdateDto account);
+        Task DeleteAccountAsync(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Cars/CarDataStore.cs

@@ -0,0 +1,100 @@
+using CheckDrive.ApiContracts.Car;
+using CheckDrive.Web.Responses;
+using CheckDrive.Web.Service;
+using Newtonsoft.Json;
+using System.Text;
+using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
+
+namespace CheckDrive.Web.Stores.Cars
+{
+    public class CarDataStore : ICarDataStore
+    {
+        private readonly ApiClient _api;
+
+        public CarDataStore(ApiClient apiClient)
+        {
+            _api = apiClient;
+        }
+
+        public async Task<GetCarResponse> GetCars(string? searchString,int? pageNumber)
+        {
+            StringBuilder query = new("");
+
+            if (!string.IsNullOrWhiteSpace(searchString))
+            {
+                query.Append($"searchString={searchString}&");
+            }
+            if (pageNumber != null)
+            {
+                query.Append($"pageNumber={pageNumber}");
+            }
+
+            var response = await _api.GetAsync("cars?" + query.ToString());
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Could not fetch cars.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<GetCarResponse>(json);
+
+            return result;
+        }
+
+        public async Task<CarDto> GetCar(int id)
+        {
+            var response = await _api.GetAsync($"cars/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not fetch car with id: {id}.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<CarDto>(json);
+
+            return result;
+        }
+
+        public async Task<CarDto> CreateCar(CarForCreateDto carForCreate)
+        {
+            var json = JsonConvert.SerializeObject(carForCreate);
+            var response = await _api.PostAsync("cars", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error creating cars.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<CarDto>(jsonResponse);
+        }
+
+        public async Task<CarDto> UpdateCar(int id, CarForUpdateDto car)
+        {
+            var json = JsonConvert.SerializeObject(car);
+            var response =  await _api.PutAsync($"cars/{car.Id}", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error updating cars.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<CarDto>(jsonResponse);
+        }
+
+        public async Task DeleteCar(int id)
+        {
+            var response = await _api.DeleteAsync($"cars/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not delete car with id: {id}.");
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Cars/ICarDataStore.cs

@@ -0,0 +1,14 @@
+using CheckDrive.ApiContracts.Car;
+using CheckDrive.Web.Responses;
+
+namespace CheckDrive.Web.Stores.Cars
+{
+    public interface ICarDataStore
+    {
+        Task<GetCarResponse> GetCars(string? searchString, int? pageNumber);
+        Task<CarDto> GetCar(int id);
+        Task<CarDto> CreateCar(CarForCreateDto carForCreate);
+        Task<CarDto> UpdateCar(int id, CarForUpdateDto car);
+        Task DeleteCar(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/DispatcherReviews/IDispatcherReviewDataStore.cs

@@ -0,0 +1,13 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Stores.DispatcherReviews
+{
+    public interface IDispatcherReviewDataStore
+    {
+        Task<List<DispatcherReview>> GetDispatcherReviews();
+        Task<DispatcherReview> GetDispatcherReview(int id);
+        Task<DispatcherReview> CreateDispatcherReview(DispatcherReview review);
+        Task<DispatcherReview> UpdateDispatcherReview(int id, DispatcherReview review);
+        Task DeleteDispatcherReview(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/DispatcherReviews/MockDispatcherReviewDataStore.cs

@@ -0,0 +1,61 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Stores.DispatcherReviews
+{
+    public class MockDispatcherReviewDataStore : IDispatcherReviewDataStore
+    {
+        private readonly List<DispatcherReview> _reviews;
+
+        public MockDispatcherReviewDataStore()
+        {
+            _reviews = new List<DispatcherReview>
+            {
+                new DispatcherReview { Id = 1, FuelSpended = 50, DistanceCovered = 100, Date = DateTime.Now },
+                new DispatcherReview { Id = 2, FuelSpended = 60, DistanceCovered = 120, Date = DateTime.Now.AddDays(-1) },
+            };
+        }
+
+        public async Task<List<DispatcherReview>> GetDispatcherReviews()
+        {
+            await Task.Delay(100);
+            return _reviews.ToList();
+        }
+
+        public async Task<DispatcherReview> GetDispatcherReview(int id)
+        {
+            await Task.Delay(100);
+            return _reviews.FirstOrDefault(r => r.Id == id);
+        }
+
+        public async Task<DispatcherReview> CreateDispatcherReview(DispatcherReview review)
+        {
+            await Task.Delay(100);
+            review.Id = _reviews.Max(r => r.Id) + 1;
+            _reviews.Add(review);
+            return review;
+        }
+
+        public async Task<DispatcherReview> UpdateDispatcherReview(int id, DispatcherReview review)
+        {
+            await Task.Delay(100); 
+            var existingReview = _reviews.FirstOrDefault(r => r.Id == id);
+            if (existingReview != null)
+            {
+                existingReview.FuelSpended = review.FuelSpended;
+                existingReview.DistanceCovered = review.DistanceCovered;
+                existingReview.Date = review.Date;
+            }
+            return existingReview;
+        }
+
+        public async Task DeleteDispatcherReview(int id)
+        {
+            await Task.Delay(100); 
+            var reviewToRemove = _reviews.FirstOrDefault(r => r.Id == id);
+            if (reviewToRemove != null)
+            {
+                _reviews.Remove(reviewToRemove);
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Dispatchers/IDispatcherDataStore.cs

@@ -0,0 +1,13 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Stores.Dispatchers
+{
+    public interface IDispatcherDataStore
+    {
+        Task<List<Dispatcher>> GetDispatchers();
+        Task<Dispatcher> GetDispatcher(int id);
+        Task<Dispatcher> CreateDispatcher(Dispatcher dispatcher);
+        Task<Dispatcher> UpdateDispatcher(int id, Dispatcher dispatcher);
+        Task DeleteDispatcher(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Dispatchers/MockDispatcherDataStore.cs

@@ -0,0 +1,59 @@
+using CheckDrive.Web.Models;
+
+namespace CheckDrive.Web.Stores.Dispatchers
+{
+    public class MockDispatcherDataStore : IDispatcherDataStore
+    {
+        private readonly List<Dispatcher> _dispatchers;
+
+        public MockDispatcherDataStore()
+        {
+            _dispatchers = new List<Dispatcher>
+            {
+                new Dispatcher { Id = 1, AccountId = 1 },
+                new Dispatcher { Id = 2, AccountId = 2 },
+            };
+        }
+
+        public async Task<List<Dispatcher>> GetDispatchers()
+        {
+            await Task.Delay(100); 
+            return _dispatchers.ToList();
+        }
+
+        public async Task<Dispatcher> GetDispatcher(int id)
+        {
+            await Task.Delay(100); 
+            return _dispatchers.FirstOrDefault(d => d.Id == id);
+        }
+
+        public async Task<Dispatcher> CreateDispatcher(Dispatcher dispatcher)
+        {
+            await Task.Delay(100); 
+            dispatcher.Id = _dispatchers.Max(d => d.Id) + 1; 
+            _dispatchers.Add(dispatcher);
+            return dispatcher;
+        }
+
+        public async Task<Dispatcher> UpdateDispatcher(int id, Dispatcher dispatcher)
+        {
+            await Task.Delay(100); 
+            var existingDispatcher = _dispatchers.FirstOrDefault(d => d.Id == id);
+            if (existingDispatcher != null)
+            {
+                existingDispatcher.AccountId = dispatcher.AccountId;
+            }
+            return existingDispatcher;
+        }
+
+        public async Task DeleteDispatcher(int id)
+        {
+            await Task.Delay(100); 
+            var dispatcherToRemove = _dispatchers.FirstOrDefault(d => d.Id == id);
+            if (dispatcherToRemove != null)
+            {
+                _dispatchers.Remove(dispatcherToRemove);
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/DoctorReviews/DoctorReviewDataStore.cs

@@ -0,0 +1,85 @@
+using System.Text;
+using CheckDrive.ApiContracts.DoctorReview;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Responses;
+using CheckDrive.Web.Service;
+using Newtonsoft.Json;
+
+namespace CheckDrive.Web.Stores.DoctorReviews
+{
+    public class DoctorReviewDataStore(ApiClient api) : IDoctorReviewDataStore
+    {
+        private readonly ApiClient _api = api;
+
+        public async Task<GetDoctorReviewResponse> GetDoctorReviews(int? pageNumber)
+        {
+            StringBuilder query = new("");
+
+            if (pageNumber != null)
+            {
+                query.Append($"pageNumber={pageNumber}");
+            }
+            var response = await _api.GetAsync("doctors/reviews?" + query.ToString());
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Could not fetch doctorReviews.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<GetDoctorReviewResponse>(json);
+
+            return result;
+        }
+
+        public async Task<DoctorReviewDto> GetDoctorReview(int id)
+        {
+            var response = await _api.GetAsync($"doctors/review/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not fetch doctorReview with id: {id}.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<DoctorReviewDto>(json);
+
+            return result;
+        }
+
+        public async Task<DoctorReviewDto> CreateDoctorReview(DoctorReviewForCreateDto review)
+        {
+            var json = JsonConvert.SerializeObject(review);
+            var response = await _api.PostAsync("doctors/review", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error creating doctorReviews.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<DoctorReviewDto>(jsonResponse);
+        }
+
+        public async Task<DoctorReview> UpdateDoctorReview(int id, DoctorReviewForUpdateDto review)
+        {
+            var json = JsonConvert.SerializeObject(review);
+            var response = await _api.PutAsync($"doctors/review/{review.Id}", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error updating doctorReview.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<DoctorReview>(jsonResponse);
+        }
+
+        public async Task DeleteDoctorReview(int id)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/DoctorReviews/IDoctorReviewDataStore.cs

@@ -0,0 +1,15 @@
+using CheckDrive.ApiContracts.DoctorReview;
+using CheckDrive.Web.Models;
+using CheckDrive.Web.Responses;
+
+namespace CheckDrive.Web.Stores.DoctorReviews
+{
+    public interface IDoctorReviewDataStore
+    {
+        Task<GetDoctorReviewResponse> GetDoctorReviews(int? pageNumber);
+        Task<DoctorReviewDto> GetDoctorReview(int id);
+        Task<DoctorReviewDto> CreateDoctorReview(DoctorReviewForCreateDto review);
+        Task<DoctorReview> UpdateDoctorReview(int id, DoctorReviewForUpdateDto review);
+        Task DeleteDoctorReview(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Doctors/DoctorDataStore.cs

@@ -0,0 +1,88 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Doctor;
+using CheckDrive.Web.Responses;
+using CheckDrive.Web.Service;
+using Newtonsoft.Json;
+
+namespace CheckDrive.Web.Stores.Doctors
+{
+    public class DoctorDataStore : IDoctorDataStore
+    {
+        private readonly ApiClient _api;
+
+        public DoctorDataStore(ApiClient apiClient)
+        {
+            _api = apiClient;
+        }
+
+        public async Task<GetDoctorResponse> GetDoctors()
+        {
+            var response = await _api.GetAsync("doctors");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Could not fetch doctors.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<GetDoctorResponse>(json);
+
+            return result;
+        }
+
+        public async Task<DoctorDto> GetDoctor(int id)
+        {
+            var response = await _api.GetAsync($"doctors/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not fetch doctor with id: {id}.");
+            }
+
+            var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+            var result = JsonConvert.DeserializeObject<DoctorDto>(json);
+
+            return result;
+        }
+
+        public async Task<DoctorDto> CreateDoctor(DoctorForCreateDto doctorForCreate)
+        {
+            var json = JsonConvert.SerializeObject(doctorForCreate);
+            var response = await _api.PostAsync("doctors", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error creating doctors.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<DoctorDto>(jsonResponse);
+        }
+
+        public async Task<DoctorDto> UpdateDoctor(int id, AccountForUpdateDto doctorForUpdate)
+        {
+            var json = JsonConvert.SerializeObject(doctorForUpdate);
+            var response = await _api.PutAsync($"doctors/{doctorForUpdate.Id}", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error updating doctors.");
+            }
+
+            var jsonResponse = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
+
+            return JsonConvert.DeserializeObject<DoctorDto>(jsonResponse);
+        }
+
+        public async Task DeleteDoctor(int id)
+        {
+            var response = await _api.DeleteAsync($"doctors/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not delete doctor with id: {id}.");
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Doctors/IDoctorsDataStore.cs

@@ -0,0 +1,15 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Doctor;
+using CheckDrive.Web.Responses;
+
+namespace CheckDrive.Web.Stores.Doctors
+{
+    public interface IDoctorDataStore
+    {
+        Task<GetDoctorResponse> GetDoctors();
+        Task<DoctorDto> GetDoctor(int id);
+        Task<DoctorDto> CreateDoctor(DoctorForCreateDto doctorForCreate);
+        Task<DoctorDto> UpdateDoctor(int id, AccountForUpdateDto doctorForUpdate);
+        Task DeleteDoctor(int id);
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Drivers/DriverDataStore.cs

@@ -0,0 +1,86 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Driver;
+using CheckDrive.Web.Responses;
+using CheckDrive.Web.Service;
+using Newtonsoft.Json;
+
+namespace CheckDrive.Web.Stores.Drivers
+{
+    public class DriverDataStore : IDriverDataStore
+    {
+        private readonly ApiClient _api;
+
+        public DriverDataStore(ApiClient apiClient)
+        {
+            _api = apiClient;
+        }
+
+        public async Task<GetDriverResponse> GetDriversAsync()
+        {
+            var response = await _api.GetAsync("drivers");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Could not fetch drivers.");
+            }
+
+            var json = await response.Content.ReadAsStringAsync();
+            var result = JsonConvert.DeserializeObject<GetDriverResponse>(json);
+
+            return result;
+        }
+
+        public async Task<DriverDto> GetDriverAsync(int id)
+        {
+            var response = await _api.GetAsync($"drivers/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not fetch driver with id: {id}.");
+            }
+
+            var json = await response.Content.ReadAsStringAsync();
+            var result = JsonConvert.DeserializeObject<DriverDto>(json);
+
+            return result;
+        }
+
+        public async Task<DriverDto> CreateDriverAsync(DriverForCreateDto driverForCreate)
+        {
+            var json = JsonConvert.SerializeObject(driverForCreate);
+            var response = await _api.PostAsync("drivers", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error creating driver.");
+            }
+
+            var jsonResponse = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<DriverDto>(jsonResponse);
+        }
+
+        public async Task<DriverDto> UpdateDriverAsync(int id, AccountForUpdateDto driverForUpdate)
+        {
+            var json = JsonConvert.SerializeObject(driverForUpdate);
+            var response = await _api.PutAsync($"drivers/{driverForUpdate.Id}", json);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception("Error updating driver.");
+            }
+
+            var jsonResponse = await response.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<DriverDto>(jsonResponse);
+        }
+
+        public async Task DeleteDriverAsync(int id)
+        {
+            var response = await _api.DeleteAsync($"drivers/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new Exception($"Could not delete driver with id: {id}.");
+            }
+        }
+    }
+}

CheckDrive.Web/CheckDrive.Web/Stores/Drivers/IDriverDataStore.cs

@@ -0,0 +1,15 @@
+using CheckDrive.ApiContracts.Account;
+using CheckDrive.ApiContracts.Driver;
+using CheckDrive.Web.Responses;
+
+namespace CheckDrive.Web.Stores.Drivers
+{
+    public interface IDriverDataStore
+    {
+        Task<GetDriverResponse> GetDriversAsync();
+        Task<DriverDto> GetDriverAsync(int id);
+        Task<DriverDto> CreateDriverAsync(DriverForCreateDto driverForCreate);
+        Task<DriverDto> UpdateDriverAsync(int id, AccountForUpdateDto driverForUpdate);
+        Task DeleteDriverAsync(int id);
+    }
+}