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; }