public ExclusivityModelBaseValidation(SponsoredItemModelBase sponsoredItemModelBase = null)
{
_sponsoredItemModelBase = sponsoredItemModelBase;
When(model => model != null, () =>
{
When(RestrictionTypeIsRequired, () =>
{
RuleFor(model => model.RestrictionType)
.Must(ContainRestrictionType)
.WithMessage($"A valid {nameof(SponsoredItemModelBase.RestrictionType)} is required");
});
When(RestrictionTypeIsNotRequired, () =>
{
RuleFor(model => model.RestrictionType)
.Must(NotContainAnyRestrictionType)
.WithMessage($"{nameof(SponsoredItemModelBase.RestrictionType)} is not required");
});
When(RestrictionValueIsRequired, () =>
{
RuleFor(model => model.RestrictionValue)
.Must(ContainRestrictionValue)
.WithMessage($"A valid {nameof(SponsoredItemModelBase.RestrictionValue)} is required");
});
When(RestrictionValueIsRequired, () =>
{
RuleFor(model => model.RestrictionValue)
.Must(IfHasValueContainPositiveIntegerRestrictionValue)
.When(CalculationTypeIsFlat)
.WithMessage($"{nameof(SponsoredItemModelBase.RestrictionValue)} is not positive integer. Acceptable values are any whole number greater than 0");
});
When(RestrictionValueIsRequired, () =>
{
RuleFor(model => model.RestrictionValue)
.Must(IfHasValueContainPercentageRestrictionValue)
.When(CalculationTypeIsPercentage)
.WithMessage($"{nameof(SponsoredItemModelBase.RestrictionValue)} is not percentage. Acceptable values are 1 to 100");
});
When(RestrictionValueIsNotRequired, () =>
{
RuleFor(model => model.RestrictionValue)
.Must(NotContainAnyRestrictionValue)
.WithMessage($"{nameof(SponsoredItemModelBase.RestrictionValue)} is not required");
});
});
}
public ClashExclusivityModelBaseValidation(IClashRepository clashRepository,
SponsoredItemModelBase sponsoredItemModelBase = null)
: base(sponsoredItemModelBase)
{
_clashRepository = clashRepository;
RuleFor(model => model).NotNull()
.WithMessage("A valid ClashExclusivity is required");
When(model => model != null, () =>
{
RuleFor(model => model.ClashExternalRef)
.Must(ContainClashExternalRef)
.WithMessage("ClashExternalRef is required");
});
}
public AdvertiserExclusivityModelBaseValidation(IProductRepository productRepository,
SponsoredItemModelBase sponsoredItemModelBase = null)
: base(sponsoredItemModelBase)
{
_productRepository = productRepository;
RuleFor(model => model).NotNull()
.WithMessage("A valid AdvertiserExclusivity is required");
When(model => model != null, () =>
{
RuleFor(model => model.AdvertiserIdentifier)
.Must(ContainAdvertiserIdentifier)
.WithMessage("AdvertiserIdentifier is required");
When(ContainsAdvertiserIdentifier, () =>
{
RuleFor(model => model.AdvertiserIdentifier)
.Must(ContainOnlyExistingAdvertiserIdentifier)
.WithMessage(model => $"AdvertiserIdentifier: {model.AdvertiserIdentifier} do not exists");
});
});
}
private bool ApplicabilityIsEachCompetitor(SponsoredItemModelBase model)
{
return(model?.Applicability == SponsorshipApplicability.EachCompetitor);
}
private bool ApplicabilityIsAllCompetitors(SponsoredItemModelBase model)
{
return(model?.Applicability == SponsorshipApplicability.AllCompetitors);
}
public CreateClashExclusivityModelValidation(IClashRepository clashRepository,
SponsoredItemModelBase sponsoredItemModelBase = null)
: base(clashRepository, sponsoredItemModelBase)
{
}
public CreateAdvertiserExclusivityModelValidation(IProductRepository productRepository,
SponsoredItemModelBase sponsoredItemModelBase = null)
: base(productRepository, sponsoredItemModelBase)
{
}
