DavidRogersDev

del /s /ah /f *.suo
del /s /f *.user
del /s /f *.cache
del /s /f *.keep
del /s /ah StyleCop.Cache

rd /s /q bin obj .vs ClientBin _Resharper.* _Upgrade* TestResults 

del dirs.txt
dir /s /b /ad bin > dirs.txt

DavidRogersDev

public class ValidateableResponse
{
	private readonly IList<string> _errorMessages;

	public ValidateableResponse(IList<string> errors = null)
	{
		_errorMessages = errors ?? new List<string>();
	}

	public bool IsValidResponse => !_errorMessages.Any();

DavidRogersDev

public class CreateUserValidator: AbstractValidator<CreateUserDto>
{
 public CreateUserValidator()
 {
  RuleFor(m => m.Password).NotEmpty();
  RuleFor(m => m.UserName).NotEmpty();
 }
}

DavidRogersDev

public class CreateNewUserCommandHandler : IRequestHandler<CreateNewUserCommand, ValidateableResponse<ApiResponse<int>>>
{
	private readonly ILogger _logger;

	public CreateNewUserCommandHandler(ILogger logger)
	{
		_logger = logger;
	}

	public async Task<ValidateableResponse<ApiResponse<int>>> Handle(CreateNewUserCommand request,

DavidRogersDev

public class CreateNewUserCommand : IRequest<ValidateableResponse<ApiResponse<int>>>, IValidateable
{
    public CreateUserDto CreateUserDto { get; set; }
}

DavidRogersDev

[HttpPost]
[Route("[action]")]
public async Task<IActionResult> CreateUser([FromBody]CreateUserDto userDto)
{
    var result = await _mediator.Send(new CreateNewUserCommand {CreateUserDto = userDto});

	return result.IsValidResponse
		? CreatedAtRoute(routeValues: new
		{
			controller = "User",

DavidRogersDev

public class BusinessValidationPipeline<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
	where TResponse : class
	where TRequest : IValidateable
{
	private readonly IValidator<TRequest> _compositeValidator;
	private readonly ILogger<TRequest> _logger;
	private readonly ICurrentUser _currentUser;
	private readonly IActionContextAccessor _actionContextAccessor;

	public BusinessValidationPipeline(

DavidRogersDev

    public class RegisterNewUserValidator : AbstractValidator<RegisterNewUserCommand>
    {
        public RegisterNewUserValidator()
        {
            RuleFor(u => u.Dto.UserName)
                .MustAsync(NotContainUserAlready)
                .WithMessage((u,userName) => $"{userName} {Constants.Validation.PartMessages.UserAlreadyExists}");
        }

        async Task<bool> NotContainUserAlready(RegisterNewUserCommand dto, string userName, CancellationToken cancellation = new CancellationToken())

DavidRogersDev

public class ColorCollectionValidator : AbstractValidator<IEnumerable<ColorPayloadDto>>
{
        public ColorCollectionValidator()
        {
            // This is a bit of a silly validator. 
            // Normally a collection would be a property on a DTO.
            // But it interesting to see that you can do this with FluentValidation at all.
            RuleFor(c => c)
                .Must(c => c.Any())
                .WithMessage("The color collection must contain at least one colour.");

DavidRogersDev

        public class ColorsService : ApplicationService, IColorsService
    {
        private readonly IValidator<IEnumerable<ColorPayloadDto>> _colorValidator;

        public ColorsService(IValidator<IEnumerable<ColorPayloadDto>> colorValidator, IMapper mapper)
            : base(mapper)
        {
            _colorValidator = colorValidator;
        }