Merge branch 'Sec_16_UnitOfWork/UnitOfWorkCustomRepositories' into dev

CleanArchitecture/CleanArchitecture.Application/Contracts/Persistence/IUnitOfWork.cs

@@ -4,6 +4,9 @@ namespace CleanArchitecture.Application.Contracts.Persistence
 {
     public interface IUnitOfWork: IDisposable
     {
+
+        IStreamerRepository StreamerRepository { get; }
+        IVideoRepository VideoRepository { get; }
         IAsyncRepository<T> Repository<T>() where T : BaseDomainModel;
 
         Task<int> Complete();

CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/CreateStreamer/CreateStreamerCommandHandler.cs

@@ -8,11 +8,11 @@ using Microsoft.Extensions.Logging;
 
 namespace CleanArchitecture.Application.Features.Streamers.Commands.CreateStreamer
 {
-    public class CreateStreamerCommandHandler(IStreamerRepository _streamerRepository, IMapper _mapper,
+    public class CreateStreamerCommandHandler(IUnitOfWork _unitOfWork, IMapper _mapper,
                                                                      IEmailService _emailService, ILogger<CreateStreamerCommandHandler> _logger) :
                                                                             IRequestHandler<CreateStreamerCommand, int>
     {
-        private readonly IStreamerRepository streamerRepository = _streamerRepository;
+        private readonly IUnitOfWork unitOfWork = _unitOfWork;
         private readonly IMapper mapper = _mapper;
         private readonly IEmailService emailService = _emailService;
         private readonly ILogger<CreateStreamerCommandHandler> logger = _logger;
@@ -20,10 +20,19 @@ namespace CleanArchitecture.Application.Features.Streamers.Commands.CreateStream
         public async Task<int> Handle(CreateStreamerCommand request, CancellationToken cancellationToken)
         {
             var streamerEntity = mapper.Map<Streamer>(request);
-            var newStreamer = await streamerRepository.AddAsync(streamerEntity);
-            logger.LogInformation($"Streamer {newStreamer.Id} is successfully created.");
-            await SendEmail(newStreamer);
-            return newStreamer.Id;
+            unitOfWork.StreamerRepository.AddEntity(streamerEntity);
+            var response = await unitOfWork.Complete();
+            if(response > 0)
+            {
+                logger.LogInformation($"Streamer {streamerEntity.Id} is successfully created.");
+                await SendEmail(streamerEntity);
+                return streamerEntity.Id;
+            }
+            else
+            {
+                throw new Exception("Failed to create the streamer.");
+            }
+            
         }
 
         private async Task SendEmail(Streamer streamer)

CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/DeleteStreamer/DeleteStreamerCommandHandler.cs

@@ -9,27 +9,28 @@ namespace CleanArchitecture.Application.Features.Streamers.Commands.DeleteStream
 {
     public class DeleteStreamerCommandHandler : IRequestHandler<DeleteStreamerCommand, Unit>
     {
-        private readonly IStreamerRepository streamerRepository;
+        private readonly IUnitOfWork unitOfWork;
         private readonly IMapper mapper;
         private readonly ILogger<DeleteStreamerCommandHandler> logger;
 
-        public DeleteStreamerCommandHandler(IStreamerRepository streamerRepository, IMapper mapper, ILogger<DeleteStreamerCommandHandler> logger)
+        public DeleteStreamerCommandHandler(IUnitOfWork unitOfWork, IMapper mapper, ILogger<DeleteStreamerCommandHandler> logger)
         {
-            this.streamerRepository = streamerRepository;
+            this.unitOfWork = unitOfWork;
             this.mapper = mapper;
             this.logger = logger;
         }
 
         public async Task<Unit> Handle(DeleteStreamerCommand request, CancellationToken cancellationToken)
         {
-            var streamerToDelete = await streamerRepository.GetByIdAsync(request.Id);
+            var streamerToDelete = await unitOfWork.StreamerRepository.GetByIdAsync(request.Id);
             if (streamerToDelete == null)
             {
                 logger.LogError($"Streamer with id {request.Id} not found.");
                 throw new NotFoundException(nameof(Streamer), request.Id);
             }
 
-            await streamerRepository.DeleteAsync(streamerToDelete);
+            unitOfWork.StreamerRepository.DeleteEntity(streamerToDelete);
+            await unitOfWork.Complete();
             logger.LogInformation($"Streamer {streamerToDelete.Id} is successfully deleted.");
 
             return Unit.Value;

CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/UpdateStreamer/UpdateStreamerCommandHandler.cs

@@ -9,21 +9,21 @@ namespace CleanArchitecture.Application.Features.Streamers.Commands.UpdateStream
 {
     public class UpdateStreamerCommandHandler : IRequestHandler<UpdateStreamerCommand, Unit>
     {
-        private readonly IStreamerRepository streamerRepository;
+        private readonly IUnitOfWork unitOfWork;
         private readonly IMapper mapper;
         private readonly ILogger<UpdateStreamerCommandHandler> logger;
 
-        public UpdateStreamerCommandHandler(IStreamerRepository streamerRepository, 
+        public UpdateStreamerCommandHandler(IUnitOfWork unitOfWork, 
                                                                         IMapper mapper, ILogger<UpdateStreamerCommandHandler> logger)
         {
-            this.streamerRepository = streamerRepository;
+            this.unitOfWork = unitOfWork;
             this.mapper = mapper;
             this.logger = logger;
         }
 
         public async Task<Unit> Handle(UpdateStreamerCommand request, CancellationToken cancellationToken)
         {
-            var streamerToUpdate = await streamerRepository.GetByIdAsync(request.Id);
+            var streamerToUpdate = await unitOfWork.StreamerRepository.GetByIdAsync(request.Id);
             if(streamerToUpdate == null)
             {
                 logger.LogError($"Streamer with id {request.Id} not found.");
@@ -32,7 +32,8 @@ namespace CleanArchitecture.Application.Features.Streamers.Commands.UpdateStream
 
             mapper.Map(request, streamerToUpdate, typeof(UpdateStreamerCommand), typeof(Streamer));
 
-            await streamerRepository.UpdateAsync(streamerToUpdate);
+            unitOfWork.StreamerRepository.UpdateEntity(streamerToUpdate);
+            await unitOfWork.Complete();
 
             logger.LogInformation($"Streamer {streamerToUpdate.Id} is successfully updated.");
 

CleanArchitecture/CleanArchitecture.Application/Features/Videos/Queries/GetVideosList/GetVideosListQueryHandler.cs

@@ -4,16 +4,16 @@ using MediatR;
 
 namespace CleanArchitecture.Application.Features.Videos.Queries.GetVideosList
 {
-    public class GetVideosListQueryHandler(IVideoRepository _videoRepository, IMapper _mapper) :
+    public class GetVideosListQueryHandler(IUnitOfWork _unitOfWork, IMapper _mapper) :
                                                                         IRequestHandler<GetVideosListQuery, List<VideosVm>>
     {
-        private readonly IVideoRepository videoRepository = _videoRepository;
+        private readonly IUnitOfWork unitOfWork = _unitOfWork;
         private readonly IMapper mapper = _mapper;
 
         public async Task<List<VideosVm>> Handle(GetVideosListQuery request, CancellationToken cancellationToken)
         {
 
-            var videoList = await videoRepository.GetVideoByUserName(request.UserName);
+            var videoList = await unitOfWork.VideoRepository.GetVideoByUserName(request.UserName);
             return mapper.Map<List<VideosVm>>(videoList);
         }
     }

CleanArchitecture/CleanArchitecture.Data/Repositories/UnitOfWork.cs

@@ -1,15 +1,22 @@
 using CleanArchitecture.Application.Contracts.Persistence;
 using CleanArchitecture.Domain.Common;
-using CleanArchitecture.Infrastructure.Repositories;
+using CleanArchitecture.Infrastructure.Persistence;
 using System.Collections;
 
-namespace CleanArchitecture.Infrastructure.Persistence
+namespace CleanArchitecture.Infrastructure.Repositories
 {
     public class UnitOfWork : IUnitOfWork
     {
         private Hashtable repositories;
-        private readonly StreamerDbContext context;
-        
+        private readonly StreamerDbContext context;
+
+        private IVideoRepository videoRepository;
+        private IStreamerRepository streamerRepository;
+
+
+        public IVideoRepository VideoRepository => videoRepository ?? new VideoRepository(context);
+        public IStreamerRepository StreamerRepository => streamerRepository ?? new StreamerRepository(context);
+
         public UnitOfWork(StreamerDbContext _context)
         {
             context = _context;
@@ -29,12 +36,12 @@ namespace CleanArchitecture.Infrastructure.Persistence
 
         public IAsyncRepository<T> Repository<T>() where T : BaseDomainModel
         {
-            if(repositories == null)
+            if (repositories == null)
             {
                 repositories = new Hashtable();
             }
             var type = typeof(T).Name;
-            if(!repositories.ContainsKey(type))
+            if (!repositories.ContainsKey(type))
             {
                 var repositoryType = typeof(RepositoryBase<>);
                 var repositoryInstance = Activator.CreateInstance(repositoryType.MakeGenericType(typeof(T)), context);