public CreateSponsorshipsModelValidation(ISponsorshipRepository sponsorshipRepository,
ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IProductRepository productRepository,
IClashRepository clashRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation)
{
RuleFor(model => model).NotNull()
.WithMessage("A valid createSponsorshipModels is required");
When(model => model != null, () =>
{
RuleFor(model => model).Must(ContainValidCreateSponsorshipModelItems)
.WithMessage("createSponsorshipModels is required and should contain a valid CreateSponsorshipModel for each item");
When(ContainsValidCreateSponsorshipModelItems, () =>
{
RuleFor(model => model)
.Must(ContainUniqueExternalReferenceIds)
.WithMessage("createSponsorshipModels should contain unique ExternalReferenceId for each item")
.DependentRules((model) =>
{
model.RuleFor(createSponsorshipModels => createSponsorshipModels)
.SetCollectionValidator(
new CreateSponsorshipModelValidation(sponsorshipRepository, salesAreaRepository,
programmeRepository, productRepository,
clashRepository, sponsoredDayPartModelValidation));
});
});
});
}
public UpdateSponsorshipModelValidation(ISponsorshipRepository sponsorshipRepository,
ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IProductRepository productRepository,
IClashRepository clashRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation)
{
_sponsorshipRepository = sponsorshipRepository;
RuleFor(model => model).NotNull()
.WithMessage("A valid SponsorshipModel is required");
When(model => model != null, () =>
{
RuleFor(model => model.ExternalReferenceId)
.Must(ContainAnExistingExternalReferenceId)
.When(model => !String.IsNullOrWhiteSpace(model.ExternalReferenceId))
.WithMessage(model => $"ExternalReferenceId: {model.ExternalReferenceId} doesn't exists, An existing ExternalReferenceId is required to update the Sponsorship");
RuleFor(model => model.SponsoredItems)
.Must(ContainSponsoredItems)
.WithMessage("SponsoredItems is required and should contain a valid SponsoredItem for each item");
When(ContainsSponsoredItems, () =>
{
RuleFor(model => model.SponsoredItems)
.SetCollectionValidator(model =>
new CreateSponsoredItemModelValidation(salesAreaRepository, programmeRepository,
productRepository, clashRepository,
sponsoredDayPartModelValidation,
model));
});
});
}
public SponsorshipDomainModelHandler(ISponsorshipRepository sponsorshipRepository,
ISqlServerDbContext dbContext)
{
_sponsorshipRepository =
sponsorshipRepository ?? throw new ArgumentNullException(nameof(sponsorshipRepository));
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
public SponsorshipsController(
ISponsorshipRepository sponsorshipRepository,
IDataChangeValidator dataChangeValidator,
IMapper mapper,
IModelDataValidator <IEnumerable <CreateSponsorshipModel> > createSponsorshipsValidator,
IModelDataValidator <UpdateSponsorshipModel> updateSponsorshipValidator
)
{
_sponsorshipRepository = sponsorshipRepository;
_dataChangeValidator = dataChangeValidator;
_mapper = mapper;
_createSponsorshipsValidator = createSponsorshipsValidator;
_updateSponsorshipValidator = updateSponsorshipValidator;
}
public CreateSponsorshipModelValidation(ISponsorshipRepository sponsorshipRepository,
ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IProductRepository productRepository,
IClashRepository clashRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation)
{
_sponsorshipRepository = sponsorshipRepository;
RuleFor(model => model).NotNull()
.WithMessage("A valid SponsorshipModel is required");
When(model => model != null, () =>
{
RuleFor(model => model.ExternalReferenceId)
.Must(ContainUniqueExternalReferenceId)
.When(model => !String.IsNullOrWhiteSpace(model.ExternalReferenceId))
.WithMessage(model => $"ExternalReferenceId: {model.ExternalReferenceId} already exists, A unique ExternalReferenceId is required");
//RuleFor(model => model.RestrictionLevel)
// .Must(ContainValidRestrictionLevel)
// .WithMessage(model => CreateInvalidRestrictionLevelErrorMessage(model.RestrictionLevel));
RuleFor(model => model.SponsoredItems)
.Must(ContainSponsoredItems)
.WithMessage("SponsoredItems is required and should contain a valid SponsoredItem for each item");
When(ContainsSponsoredItems, () =>
{
RuleFor(model => model.SponsoredItems)
.SetCollectionValidator(model =>
new CreateSponsoredItemModelValidation(salesAreaRepository, programmeRepository,
productRepository, clashRepository,
sponsoredDayPartModelValidation,
model));
});
});
}
