Editing UnitOfWork pattern for scoped lifetime

Author: Mardson581

Program.cs

@@ -2,6 +2,7 @@
 using TechInventory.Services.DeviceModel;
 using TechInventory.Services.Brand;
 using TechInventory.Services.Maintenance;
+using TechInventory.Data.Repository;
 using TechInventory.Data.UnitOfWork;
 using TechInventory.Data.Context;
 using Microsoft.EntityFrameworkCore;
@@ -15,6 +16,8 @@
     options.UseMySQL(builder.Configuration.GetConnectionString("AZURE_MYSQL_CONNECTIONSTRING"))
 );
 
+builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
+builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
 builder.Services.AddScoped<IDeviceService, DeviceService>();
 builder.Services.AddScoped<IDeviceModelService, DeviceModelService>();
 builder.Services.AddScoped<IBrandService, BrandService>();

Services/Brand/BrandService.cs

@@ -1,6 +1,5 @@
 using TechInventory.Models;
 using TechInventory.Data.UnitOfWork;
-using TechInventory.Data.Context;
 using TechInventory.Data.Repository;
 
 namespace TechInventory.Services.Brand;
@@ -10,9 +9,9 @@ public class BrandService : IBrandService
     private readonly UnitOfWork _unitOfWork;
     private readonly IRepository<Models.Brand> _repository;
 
-    public BrandService(InventoryDbContext context)
+    public BrandService(IUnitOfWork unitOfWork)
     {
-        _unitOfWork = new UnitOfWork(context);
+        _unitOfWork = (UnitOfWork)unitOfWork;
         _repository = _unitOfWork.BrandRepository;
     }
 

Services/Device/DeviceService.cs

@@ -1,21 +1,20 @@
 using TechInventory.Models;
 using TechInventory.Data.Repository;
 using TechInventory.Data.UnitOfWork;
-using TechInventory.Data.Context;
 
 namespace TechInventory.Services.Device;
 
 public class DeviceService : IDeviceService
 {
     private readonly UnitOfWork _unitOfWork;
     private readonly IRepository<Models.Device> _repository;
-    private readonly IRepository<Models.DeviceModel> _modelRepository;
+    private readonly IRepository<Models.DeviceModel> _deviceModelRepository;
 
-    public DeviceService(InventoryDbContext context)
+    public DeviceService(IUnitOfWork unitOfWork)
     {
-        _unitOfWork = new UnitOfWork(context);
+        _unitOfWork = (UnitOfWork)unitOfWork;
         _repository = _unitOfWork.DeviceRepository;
-        _modelRepository = _unitOfWork.DeviceModelRepository;
+        _deviceModelRepository = _unitOfWork.DeviceModelRepository;
     }
 
     public async Task<Result<bool>> AddDevice(Models.Device device)
@@ -85,7 +84,7 @@ public async Task<Result<bool>> UpdateDevice(Models.Device device)
     public async Task<Result<bool>> CheckIncludes(Models.Device device)
     {
         // Check if the device's model exists
-        var result = await _modelRepository.GetAsync(device.DeviceModelId);
+        var result = await _deviceModelRepository.GetAsync(device.DeviceModelId);
 
         if (result == null)
             return Result<bool>.Failure($"Modelo com Id {device.DeviceModelId} não foi encontrado", false);

Services/DeviceModel/DeviceModelService.cs

@@ -1,20 +1,19 @@
 using TechInventory.Data.UnitOfWork;
 using TechInventory.Data.Repository;
-using TechInventory.Data.Context;
 using TechInventory.Models;
 
 namespace TechInventory.Services.DeviceModel;
 
 public class DeviceModelService : IDeviceModelService
 {
     private readonly UnitOfWork _unitOfWork;
-    private readonly IRepository<Models.DeviceModel> _repository;
+    private readonly IRepository<Models.DeviceModel> _deviceModelRepository;
     private readonly IRepository<Models.Brand> _brandRepository;
 
-    public DeviceModelService(InventoryDbContext context)
+    public DeviceModelService(IUnitOfWork unitOfWork)
     {
-        _unitOfWork = new UnitOfWork(context);
-        _repository = _unitOfWork.DeviceModelRepository;
+        _unitOfWork = (UnitOfWork)unitOfWork;
+        _deviceModelRepository = _unitOfWork.DeviceModelRepository;
         _brandRepository = _unitOfWork.BrandRepository;
     }
 
@@ -24,18 +23,18 @@ public async Task<Result<bool>> CreateDeviceModel(Models.DeviceModel deviceModel
         if (!checkResult.IsSuccessful)
             return checkResult;
 
-        await _repository.CreateAsync(deviceModel);
+        await _deviceModelRepository.CreateAsync(deviceModel);
         return await _unitOfWork.CommitAsync();
     }
 
     public async Task<Models.DeviceModel> GetDeviceModelById(int id)
     {
-        return await _repository.GetAsync(id);
+        return await _deviceModelRepository.GetAsync(id);
     }
 
     public async Task<List<Models.DeviceModel>> GetAllDeviceModels()
     {
-        return await _repository.GetWhere(null, "Brand");
+        return await _deviceModelRepository.GetWhere(null, "Brand");
     }
 
     public async Task<Result<bool>> UpdateDeviceModel(Models.DeviceModel deviceModel)
@@ -44,19 +43,19 @@ public async Task<Result<bool>> UpdateDeviceModel(Models.DeviceModel deviceModel
         if (!checkResult.IsSuccessful)
             return checkResult;
 
-        _repository.Update(deviceModel);
+        _deviceModelRepository.Update(deviceModel);
         return await _unitOfWork.CommitAsync();
     }
 
     public Task<Result<bool>> DeleteDeviceModel(int id)
     {
-        _repository.DeleteAsync(id);
+        _deviceModelRepository.DeleteAsync(id);
         return _unitOfWork.CommitAsync();
     }
 
     public async Task<List<Models.DeviceModel>> GetDeviceModelsByBrandId(int brandId)
     {
-        return await _repository.GetWhere(m => m.BrandId == brandId);
+        return await _deviceModelRepository.GetWhere(m => m.BrandId == brandId);
     }
 
     public async Task<Result<bool>> CheckIncludes(Models.DeviceModel deviceModel)

Services/Maintenance/MaintenanceRecordService.cs

@@ -1,6 +1,5 @@
 using TechInventory.Models;
 using TechInventory.Data.UnitOfWork;
-using TechInventory.Data.Context;
 using TechInventory.Data.Repository;
 
 namespace TechInventory.Services.Maintenance;
@@ -9,13 +8,13 @@ public class MaintenanceRecordService : IMaintenanceRecordService
 {
     private readonly UnitOfWork _unitOfWork;
     private readonly IRepository<MaintenanceRecord> _repository;
-    private readonly IRepository<Models.Device> _deviceRepository;
+    private readonly IRepository<Models.Device> _deviceRepository; // This is correct
 
-    public MaintenanceRecordService(InventoryDbContext context)
+    public MaintenanceRecordService(IUnitOfWork unitOfWork)
     {
-        _unitOfWork = new UnitOfWork(context);
+        _unitOfWork = (UnitOfWork)unitOfWork;
         _repository = _unitOfWork.MaintenanceRecordRepository;
-        _deviceRepository = _unitOfWork.DeviceRepository;
+        _deviceRepository = _unitOfWork.DeviceRepository; // This is correct
     }
 
     public async Task<Result<bool>> CreateRecord(MaintenanceRecord record)