alex/CleanArchitecture
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'Sec_16_UnitOfWork/UnitOfWorkCustomRepositories' into dev

Browse Source
This commit is contained in:
Alejandro Sarmiento
2024-02-20 17:05:14 +01:00
parent a2be9b5604 f5f0379b7a
commit b55f2be085
6 changed files with 46 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CleanArchitecture/CleanArchitecture.Application/Contracts/Persistence/IUnitOfWork.cs
View File

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

21
CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/CreateStreamer/CreateStreamerCommandHandler.cs
View File

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

11
CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/DeleteStreamer/DeleteStreamerCommandHandler.cs
View File

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

11
CleanArchitecture/CleanArchitecture.Application/Features/Streamers/Commands/UpdateStreamer/UpdateStreamerCommandHandler.cs
View File

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

6
CleanArchitecture/CleanArchitecture.Application/Features/Videos/Queries/GetVideosList/GetVideosListQueryHandler.cs
View File

@@ -4,16 +4,16 @@ using MediatR;
namespace CleanArchitecture.Application.Features.Videos.Queries.GetVideosList 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>> IRequestHandler<GetVideosListQuery, List<VideosVm>>
{ {
private readonly IVideoRepository videoRepository = _videoRepository; private readonly IUnitOfWork unitOfWork = _unitOfWork;
private readonly IMapper mapper = _mapper; private readonly IMapper mapper = _mapper;
public async Task<List<VideosVm>> Handle(GetVideosListQuery request, CancellationToken cancellationToken) 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); return mapper.Map<List<VideosVm>>(videoList);
} }
} }

19
CleanArchitecture/CleanArchitecture.Data/Persistence/UnitOfWork.cs → CleanArchitecture/CleanArchitecture.Data/Repositories/UnitOfWork.cs
View File

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