public UnitRepository(IUnitOfWork unitOfWork, IDocRepository docRepository, IDomainValidator validator) { this.unitOfWork = unitOfWork; this.docRepository = docRepository; this.validator = validator; unitsInContext = unitOfWork.DbContext.Set<Unit>(); }
public static void Validate(this IDomainValidator validator) { if (!validator.IsValid) { throw new ValidationFailedException(); } }
public DomainProviderIpDateRangeRequestValidator(IDomainValidator domainValidator) { RuleFor(_ => _.Domain) .NotNull() .WithMessage("A domain is required.") .NotEmpty() .WithMessage("A domain cannot be empty.") .Must(domainValidator.IsValidDomain) .WithMessage("A domain must be a valid domain."); RuleFor(_ => _.Provider) .NotNull() .WithMessage("A provider is required.") .NotEmpty() .WithMessage("A provider cannot be empty."); RuleFor(_ => _.Ip) .NotNull() .WithMessage("An IP is required.") .NotEmpty() .WithMessage("An IP cannot be empty."); RuleFor(_ => _.EndDate) .GreaterThanOrEqualTo(_ => _.StartDate) .WithMessage("An end date must be greater than the start date."); }
public DkimInfoRequestValidator(IDomainValidator domainValidator) { CascadeMode = CascadeMode.StopOnFirstFailure; RuleFor(_ => _.Domain) .NotNull() .WithMessage("A \"domain\" field is required.") .NotEmpty() .WithMessage("The \"domain\" field should not be empty.") .Must(domainValidator.IsValidDomain) .WithMessage("The domains must be be a valid domain"); }
public DataExportRequestValidator(IDomainValidator domainValidator) { RuleFor(_ => _.Domain) .NotNull() .WithMessage("A domain is required.") .NotEmpty() .WithMessage("A domain cannot be empty.") .Must(domainValidator.IsValidDomain) .WithMessage("A domain must be a valid domain."); RuleFor(_ => _.EndDate) .GreaterThanOrEqualTo(_ => _.StartDate) .WithMessage("An end date must be greater than the start date."); }
public PublicDomainValidator(IDomainValidator domainValidator, IPublicDomainListValidator publicDomainValidator) { CascadeMode = CascadeMode.StopOnFirstFailure; RuleFor(d => d.Name) .NotNull() .WithMessage("A name is required.") .NotEmpty() .WithMessage("A name cannot be empty.") .Must(domainValidator.IsValidDomain) .WithMessage("A name must be a valid domain.") .Must(publicDomainValidator.IsValidPublicDomain) .WithMessage("A name must be a public domain name and cannot be a top level domain (TLD)."); }
public DomainStatusListController(IDomainStatusListDao domainStatusListDao, IOrganisationalDomainProvider organisationalDomainProvider, ICertificateEvaluatorApi certificateEvaluatorApi, IDomainValidator domainValidator, IPublicDomainListValidator publicDomainValidator, IValidator <DomainsRequest> domainsRequestValidator, ILogger <DomainStatusListController> log) { _domainStatusListDao = domainStatusListDao; _organisationalDomainProvider = organisationalDomainProvider; _certificateEvaluatorApi = certificateEvaluatorApi; _domainValidator = domainValidator; _publicDomainValidator = publicDomainValidator; _domainsRequestValidator = domainsRequestValidator; _log = log; }
public void SetUp() { _domainStatusListDao = A.Fake <IDomainStatusListDao>(); _organisationDomainProvider = A.Fake <IOrganisationalDomainProvider>(); _domainRequestValidator = A.Fake <IValidator <DomainsRequest> >(); _certificateEvaluatorApi = A.Fake <ICertificateEvaluatorApi>(); _domainValidator = A.Fake <IDomainValidator>(); _publicDomainValidator = A.Fake <IPublicDomainListValidator>(); _domainStatusListController = new DomainStatusListController(_domainStatusListDao, _organisationDomainProvider, _certificateEvaluatorApi, _domainValidator, _publicDomainValidator, _domainRequestValidator, A.Fake <ILogger <DomainStatusListController> >()); _domainStatusListController.ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext { User = new ClaimsPrincipal(new ClaimsIdentity()) } }; }
public PolicyPublishedDeserialiser(IDomainValidator domainValidator) { _domainValidator = domainValidator; }
public DomainForCreationValidator(IDomainValidator domainValidator) { RuleFor(d => d.Name) .Must(domainValidator.IsValidDomain) .WithMessage("A name must be a valid domain name."); }
public void SetUp() { _domainValidator = A.Fake <IDomainValidator>(); _policyPublishedDeserialiser = new PolicyPublishedDeserialiser(_domainValidator); }
public UnitBusinessLogic(IUnitRepository unitRepository, IDomainValidator validator) { this.unitRepository = unitRepository; this.validator = validator; }
/// <summary> /// Constructor sets dependent components. /// </summary> /// <param name="domainValidator">Validates domain URL entered during website creation.</param> /// <param name="modelValidator">Model validator.</param> /// <param name="webRepository">Web repository.</param> public WebValidator(IDomainValidator domainValidator, IModelValidator modelValidator, IWebRepository webRepository) { _domainValidator = domainValidator; _modelValidator = modelValidator; _webRepository = webRepository; }
/// <summary> /// Constructor sets dependent components. /// </summary> /// <param name="domainRepository">Domain repository.</param> /// <param name="domainValidator">Domain validator.</param> public DomainService(IDomainRepository domainRepository, IDomainValidator domainValidator) { _domainRepository = domainRepository; _domainValidator = domainValidator; }