OnionArch

public interface IBaseRepository<TEntity> where TEntity : BaseEntity
{
Task<TEntity> Add(TEntity entity);
Task AddRange(params TEntity[] entities);

Task<TEntity> Update(TEntity entity);
Task<int> UpdateRange(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> setPropertyCalls);
Task<int> UpdateByPK(Guid Id, Expression<Func<SetPropertyCalls<TEntity>, SetPropertyCalls<TEntity>>> setPropertyCalls);


Task<TEntity> Delete(TEntity entity);
Task<int> DeleteRange(Expression<Func<TEntity, bool>> whereLambda);
Task<int> DeleteByPK(Guid Id);
Task<TEntity> DeleteByPK2(Guid Id);


Task<TEntity> SelectByPK(Guid Id);
IQueryable<TEntity> SelectRange<TOrder>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TOrder>> orderbyLambda, bool isAsc = true);
Task<PagedResult<TEntity>> SelectPaged<TOrder>(Expression<Func<TEntity, bool>> whereLambda, PagedOption pageOption, Expression<Func<TEntity, TOrder>> orderbyLambda, bool isAsc = true);

Task<bool> IsExist(Expression<Func<TEntity, bool>> whereLambda);
}

public class CUDCommandHandler<TModel, TEntity> : IRequestHandler<CUDCommand<TModel>> where TEntity : BaseEntity
{
private readonly CURDDomainService<TEntity> _curdDomainService;

public CUDCommandHandler(CURDDomainService<TEntity> curdDomainService)
{
_curdDomainService = curdDomainService;
}

public async Task<Unit> Handle(CUDCommand<TModel> request, CancellationToken cancellationToken)
{
TEntity entity = null;
if (request.Operation == "C" || request.Operation == "U")
{
if (request.Model == null)
{
throw new BadRequestException($"the model of this request is null");
}
entity = request.Model.Adapt<TEntity>();
if (entity == null)
{
throw new ArgumentNullException($"the entity of {nameof(TEntity)} is null");
}
}
if (request.Operation == "U" || request.Operation == "D")
{
if (request.Id == Guid.Empty)
{
throw new BadRequestException($"the Id of this request is null");
}
}

switch (request.Operation)
{
case "C":
await _curdDomainService.Create(entity);
break;
case "U":
await _curdDomainService.Update(entity);
break;
case "D":
await _curdDomainService.Delete(request.Id);
break;
}

return Unit.Value;
}
}

public class RequestValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
private readonly IEnumerable<IValidator<TRequest>> _validators;

public RequestValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
{
_validators = validators;
}

public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
{
var errors = _validators
.Select(v => v.Validate(request))
.SelectMany(result => result.Errors)
.Where(error => error != null)
.ToList();

if (errors.Any())
{
var errorBuilder = new StringBuilder();

errorBuilder.AppendLine("Invalid Request, reason: ");

foreach (var error in errors)
{
errorBuilder.AppendLine(error.ErrorMessage);
}

throw new InvalidRequestException(errorBuilder.ToString(), null);
}
return await next();
}
}

public class RequestPerformanceBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
{
private readonly Stopwatch _timer;
private readonly ILogger<TRequest> _logger;
private readonly ICurrentUserService _currentUserService;
private readonly ICurrentTenantService _currentTenantService;

public RequestPerformanceBehaviour(ILogger<TRequest> logger, ICurrentUserService currentUserService, ICurrentTenantService currentTenantService)
{
_timer = new Stopwatch();

_logger = logger;
_currentUserService = currentUserService;
_currentTenantService = currentTenantService;
}

public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
{
_timer.Start();

var response = await next();

_timer.Stop();

if (_timer.ElapsedMilliseconds > 500)
{
var name = typeof(TRequest).Name;

_logger.LogWarning("Request End: {Name} ({ElapsedMilliseconds} milliseconds) {@UserId} {@Request}",
name, _timer.ElapsedMilliseconds, _currentUserService.UserId, request);
}

return response;
}
}

public class CommonExceptionHandler<TRequest, TResponse, TException> : IRequestExceptionHandler<TRequest, TResponse, TException>
where TException : Exception where TRequest: IRequest<TResponse>
{
private readonly ILogger<CommonExceptionHandler<TRequest, TResponse,TException>> _logger;
private readonly ICurrentUserService _currentUserService;
private readonly ICurrentTenantService _currentTenantService;

public CommonExceptionHandler(ILogger<CommonExceptionHandler<TRequest, TResponse, TException>> logger, ICurrentUserService currentUserService, ICurrentTenantService currentTenantService)
{
this._logger = logger;
_currentUserService = currentUserService;
_currentTenantService = currentTenantService;
}

public Task Handle(TRequest request, TException exception, RequestExceptionHandlerState<TResponse> state, CancellationToken cancellationToken)
{
var name = typeof(TRequest).Name;

_logger.LogError(exception, $"Request Error: {name} {state} Tenant:{_currentTenantService.TenantId} User:{_currentUserService.UserId}", request);

//state.SetHandled();
return Task.CompletedTask;
}

}