public static Result <SubjectId> Create(long subjectId, ISubjectExistenceValidator subjectExistenceValidator)
{
return(Result.Create(() => subjectId > 0, DomainErrors.BuildInvalidIdentifier(subjectId))
.AndEnsure(() => subjectExistenceValidator.Exist(subjectId),
DomainErrors.BuildNotFound("Subject", subjectId))
.OnSuccess(() => new SubjectId(subjectId)));
}
public static Response <string> ValidateName <TEntity>(this DbSet <TEntity> dbSet, string name, int?min = null, int?max = null)
where TEntity : class, IHasName
{
if (string.IsNullOrWhiteSpace(name))
{
return(Response.Failure <string>(Error.InvalidValue <IHasName>(x => x.Name, "Name is required")));
}
name = name.TrimStart().TrimEnd();
if (min != null && name.Length < min)
{
return(Response.Failure <string>(Error.InvalidValue <IHasName>(x => x.Name, $"Name must be at least {min} characters")));
}
if (max != null && name.Length > max)
{
return(Response.Failure <string>(Error.InvalidValue <IHasName>(x => x.Name, $"Name can be no more than {max} characters")));
}
var matchedByName = dbSet.AsNoTracking().FirstOrDefault(x => EF.Functions.Like(x.Name, name));
if (matchedByName != null)
{
return(Response.Failure <string>(DomainErrors.Duplicate <IHasName>(x => x.Name, name)));
}
return(Response.Success(name));
}
public static Result <LocationId> Create(long locationId, ILocationExistenceValidator locationExistenceValidator)
{
return(Result.Create(locationId > 0, DomainErrors.BuildInvalidIdentifier(locationId))
.AndEnsure(() => locationExistenceValidator.Exist(locationId),
DomainErrors.BuildNotFound("Location", locationId))
.OnSuccess(() => new LocationId(locationId)));
}
public void ShouldReturnExpectedErrorForInvalidIdentifier()
{
var identifier = 7;
var notFoundError = DomainErrors.BuildInvalidIdentifier(identifier);
notFoundError.Message.Should().Be($"Provided identifier {identifier} is invalid");
}
public Task <TDto> GetOneAsync(TId id)
{
if (CachedDtos.TryGetValue(id, out var dto))
{
return(Task.FromResult(dto));
}
throw new ErrorException(DomainErrors.NotFound <TDto>());
}
public void ShouldReturnExpectedErrorForNotFound()
{
var entity = "Location";
var identifier = 7;
var notFoundError = DomainErrors.BuildNotFound(entity, identifier);
notFoundError.Message.Should().Be($"{entity} for provided identifier {identifier} does not exist");
}
public async Task <TDto> GetOneAsync(TId id)
{
var dtos = await LoadDtosAsync(x => x.Id.Equals(id));
return(dtos.Count == 1
? dtos[0]
: throw new ErrorException(DomainErrors.NotFound <TDto>()));
}
public static TEntity ThrowIfNotExists <TEntity>(this TEntity?entity)
{
if (entity == null)
{
throw new ErrorException(DomainErrors.NotFound <TEntity>());
}
return(entity);
}
public async Task <Result <RegistrationDto> > Handle(GetRegistrationQuery request, CancellationToken cancellationToken)
{
var registration =
await _dbConnection.QuerySingleAsync <RegistrationDto>(BuildQuery(), new { id = request.Id });
return(registration != null
? Result.Ok(registration)
: Result.Fail <RegistrationDto>(DomainErrors.BuildNotFound("Registration", request.Id)));
}
public async Task <Result <ExamDto> > Handle(GetExamQuery request, CancellationToken cancellationToken)
{
//TODO: Dapper is not mapping dates as UTC, but as Unspecified
var exam = await _dbConnection.QuerySingleAsync <ExamDto>(_queryBuilder.SingleExamQuery(),
new { id = request.Id });
return(exam == null
? Result.Fail <ExamDto>(DomainErrors.BuildNotFound("Exam", request.Id))
: Result.Ok(exam));
}
public async Task IF_not_Active_SHOULD_fail(EntityState invalidState)
{
//Arrange
ExistingEntityBuilder.With(x => x.EntityState, invalidState);
//Act
var result = await Sut.HandleAsync(Command, AdminUser);
//Assert
result.VerifyResponseError(DomainErrors.InvalidEntityState(invalidState), MockAnalyticsService);
}
public async Task IF_not_Draft_or_Archived_SHOULD_fail(EntityState invalidState)
{
//Arrange
ExistingEntityBuilder.With(x => x.EntityState, invalidState);
//Act
var result = await Sut.HandleAsync(Command, AdminUser);
//Assert
result.VerifyResponseError(DomainErrors.InvalidEntityState(invalidState), MockAnalyticsService);
Assert.That(DbContextAfter.Set <TEntity>().First(x => x.Id == GrainId).EntityState, Is.Not.EqualTo(EntityState.Draft));
}
public async Task <Result <OrderDto> > Handle(GetOrderQuery request, CancellationToken cancellationToken)
{
var orders = new Dictionary <long, OrderDto>();
await _dbConnection.QueryAsync <OrderDto, OrderItemDto, OrderDto>(BuildQuery(), (order, item) =>
{
if (!orders.ContainsKey(order.Id))
{
order.Items ??= new List <OrderItemDto>();
orders.Add(order.Id, order);
}
orders[order.Id].Items.Add(item);
return(order);
}, new { id = request.Id });
return(orders.Count() == 1
? Result.Ok(orders.Values.Single())
: Result.Fail <OrderDto>(DomainErrors.BuildNotFound("Order", request.Id)));
}
public static Response TryActivate(this BaseServerEntity entity, DateTime now)
{
switch (entity.EntityState)
{
case EntityState.Active:
return(Response.Success());
case EntityState.Deleted:
return(Response.Failure(DomainErrors.InvalidEntityState(entity.EntityState)));
case EntityState.Draft:
case EntityState.Archived:
entity.Activate(now);
return(Response.Success());
default:
throw new ArgumentOutOfRangeException();
}
}
public static Response <string> ValidateNamedEntityCreateCommand <TEntity>(this DbSet <TEntity> dbSet, IHasName command, int minimumLength = 4)
where TEntity : class, IHasName, IServerEntity
{
if (string.IsNullOrWhiteSpace(command.Name))
{
return(Response.Failure <string>(Error.RequiredValue <IHasName>(x => x.Name)));
}
var requestedName = command.Name.TrimStart().TrimEnd();
if (requestedName.Length < minimumLength)
{
return(Response.Failure <string>(Error.InvalidValue <IHasName>(x => x.Name, $"Name must be at least {minimumLength} characters")));
}
var matchedByName = dbSet.AsNoTracking().FirstOrDefault(x =>
EF.Functions.Like(x.Name, command.Name.TrimStart().TrimEnd()) &&
x.EntityState != EntityState.Deleted);
return(matchedByName != null
? Response.Failure <string>(DomainErrors.Duplicate <IHasName>(x => x.Name, command.Name))
: Response.Success(requestedName));
}
public static Result <OrderId> Create(long orderId)
{
return(Result.Create(() => orderId > 0, DomainErrors.BuildInvalidIdentifier(orderId))
.OnSuccess(() => new OrderId(orderId)));
}
public static Result <ExamId> Create(long examId, IExamExistenceValidator examExistenceValidator)
{
return(Result.Create(() => examId > 0, DomainErrors.BuildInvalidIdentifier(examId))
.AndEnsure(() => examExistenceValidator.Exist(examId), DomainErrors.BuildAggregateNotFound("Exam", examId))
.OnSuccess(() => new ExamId(examId)));
}
public bool FillMessages()
{
//DomainErrors.ToList().ForEach(error => _showMessages.Show(new Message("Validação", error.Value, MessagesType.Warning)));
return(!DomainErrors.Any());
}
public async Task <Result <Exam> > GetAsync(ExamId identifier)
{
return(Maybe <Exam> .From(await _examsDbContext.Exams.SingleOrDefaultAsync(exam => exam.Id == identifier))
.ToResult(DomainErrors.BuildAggregateNotFound(nameof(Exam), identifier.Value)));
}
protected DomainError(DomainErrors error, string key, string message)
{
Error = error;
Key = key;
Message = message;
}
public DomainException(DomainErrors error, string message) : base(message)
{
Error = error;
}
