public SponsorshipItemModelBaseValidation(ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation,
SponsorshipModelBase sponsorshipModelBase = null)
{
_sponsorshipModelBase = sponsorshipModelBase;
_salesAreaRepository = salesAreaRepository;
_programmeRepository = programmeRepository;
RuleFor(model => model).NotNull()
.WithMessage("A valid SponsorshipItemModelBase is required");
When(model => model != null, () =>
{
RuleFor(model => model.SalesAreas)
.Must(ContainSomeSalesAreas)
.WithMessage("SalesAreas should contain a valid SalesArea for each item");
When(ContainsSomeSalesAreas, () =>
{
RuleFor(model => model.SalesAreas)
.Must(ContainOnlyExistingSalesAreas)
.WithMessage(model => CreateNonExistingSalesAreasErrorMessage(model.SalesAreas));
});
RuleFor(model => model.StartDate)
.Must(BeGreaterThanOrEqualToToday)
.WithMessage("StartDate must be greater than or equal to today");
RuleFor(model => model.EndDate)
.Must(BeGreaterThanOrEqualToToday)
.WithMessage("EndDate must be greater than or equal to today");
When(StartAndEndDatesAreValid, () =>
{
RuleFor(model => model).Must(ContainAnEndDateGreaterThanOrEqualToStartDate)
.WithName(model => nameof(model.EndDate))
.WithMessage("EndDate must be greater than or equal to StartDate");
});
RuleFor(model => model.DayParts)
.Must(ContainDayParts)
.WithMessage("DayParts is required and should contain valid DayPart for each item");
When(ContainsDayParts, () =>
{
RuleFor(model => model.DayParts).SetCollectionValidator(sponsoredDayPartModelValidation);
});
When(ProgrammeNameIsRequired, () =>
{
RuleFor(model => model.ProgrammeName)
.NotEmpty()
.WithMessage("ProgrammeName is required when RestrictionLevel Is 'Programme'");
});
});
}
public CreateSponsorshipItemModelValidation(ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation,
SponsorshipModelBase sponsorshipModelBase = null)
: base(salesAreaRepository,
programmeRepository,
sponsoredDayPartModelValidation,
sponsorshipModelBase)
{
}
public CreateSponsoredItemModelValidation(ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IProductRepository productRepository,
IClashRepository clashRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation,
SponsorshipModelBase sponsorshipModelBase = null)
: base(productRepository)
{
RuleFor(model => model).NotNull()
.WithMessage("A valid SponsoredItem is required");
When(model => model != null, () =>
{
RuleFor(model => model.SponsorshipItems)
.Must(ContainSponsorshipItems)
.WithMessage("SponsorshipItems is required and should contain a valid SponsorshipItem for each item");
When(ContainsSponsorshipItems, () =>
{
RuleFor(model => model.SponsorshipItems)
.SetCollectionValidator(model =>
new CreateSponsorshipItemModelValidation(salesAreaRepository, programmeRepository,
sponsoredDayPartModelValidation, sponsorshipModelBase));
});
RuleFor(model => model).Must(ContainAdvertiserOrClashExclusivities)
.WithName(model => nameof(model.AdvertiserExclusivities))
.WithMessage("SponsoredItem must contain AdvertiserExclusivities And/Or ClashExclusivities");
When(ContainsAdvertiserExclusivities, () =>
{
RuleFor(model => model.AdvertiserExclusivities)
.SetCollectionValidator(model => new CreateAdvertiserExclusivityModelValidation(productRepository, model));
});
When(ContainsClashExclusivities, () =>
{
RuleFor(model => model.ClashExclusivities)
.SetCollectionValidator(model => new CreateClashExclusivityModelValidation(clashRepository, model));
});
When(ContainsBothClashAndAdvertiserExclusivities, () =>
{
RuleFor(model => model).Must(ContainSameRestrictionTypeForBothClashAndAdvertiserExclusivities)
.WithName(model => nameof(model.AdvertiserExclusivities))
.WithMessage("RestrictionType must be same for both AdvertiserExclusivities And ClashExclusivities");
});
});
}
private void AssumeTargetIsInitialised(SponsorshipModelBase sponsorshipModelBase = null)
{
AssumeTargetIsInitialised(SalesAreaRepository.Object, ProgrammeRepository.Object,
ProductRepository.Object, ClashRepository.Object,
SponsoredDayPartModelValidation, sponsorshipModelBase);
}
//======================================
protected override void AssumeDependenciesAreSupplied()
{
base.AssumeDependenciesAreSupplied();
SponsoredDayPartModelValidation = new SponsoredDayPartModelValidation();
SponsorshipModelBase = CreateValidModel <SponsorshipModelBase>();
}
