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