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 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 CampaignsController(
ICampaignRepository campaignRepository,
IRecommendationRepository recommendationRepository,
IDataChangeValidator dataChangeValidator,
IMapper mapper,
IDemographicRepository demographicRepository,
ISalesAreaRepository salesAreaRepository,
IProductRepository productRepository,
ICampaignExcelReportGenerator campaignsReportGenerator,
IReportColumnFormatter reportColumnFormatter,
IProgrammeRepository programmeRepository,
IClashRepository clashRepository,
IProgrammeCategoryHierarchyRepository programmeCategoryRepository,
IFeatureManager featureManager,
ICampaignFlattener campaignFlattener,
ICampaignCleaner campaignCleaner,
ICampaignPassPrioritiesService campaignPassPrioritiesService)
{
_campaignRepository = campaignRepository;
_dataChangeValidator = dataChangeValidator;
_recommendationRepository = recommendationRepository;
_mapper = mapper;
_demographicRepository = demographicRepository;
_clashRepository = clashRepository;
_salesAreaRepository = salesAreaRepository;
_productRepository = productRepository;
_campaignsReportGenerator = campaignsReportGenerator;
_reportColumnFormatter = reportColumnFormatter;
_programmeCategoryRepository = programmeCategoryRepository;
_featureManager = featureManager;
_campaignFlattener = campaignFlattener;
_campaignCleaner = campaignCleaner;
_programmeRepository = programmeRepository;
_campaignPassPrioritiesService = campaignPassPrioritiesService;
}
public ProgrammesController(IProgrammeRepository programmeRepository,
ILogger <ProgrammesController> logger,
IMapper mapper)
{
this._programmeRepository = programmeRepository ?? throw new ArgumentNullException(nameof(_programmeRepository));
this._logger = logger ?? throw new ArgumentNullException(nameof(_logger));
this._mapper = mapper ?? throw new ArgumentNullException(nameof(_mapper));
}
public TeacherController(ITeacherRepository teacherRepository,
IProgrammeRepository programmeRepository,
UserManager <AppUser> userManager)
{
this.teacherRepository = teacherRepository;
this.programmeRepository = programmeRepository;
this.userManager = userManager;
}
public CompareController(IBreakRepository breakRepository, ISpotRepository spotRepository, IProgrammeRepository programmeRepository, ICampaignRepository campaignRepository, IProductRepository productRepository, IClashRepository clashRepository)
{
_breakrepo = breakRepository;
_spotrepo = spotRepository;
_programmerepo = programmeRepository;
_campaignrepo = campaignRepository;
_productRepository = productRepository;
_clashRepository = clashRepository;
}
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 ProgrammesController(IProgrammeRepository programmeRepository, IMapper mapper,
IRepositoryFactory repositoryFactory,
IProgrammeCategoryHierarchyRepository programmeCategoryRepository,
ISalesAreaRepository salesAreaRepository, IDataChangeValidator dataChangeValidator)
{
_programmeRepository = programmeRepository;
_mapper = mapper;
_repositoryFactory = repositoryFactory;
_programmeCategoryRepository = programmeCategoryRepository;
_salesAreaRepository = salesAreaRepository;
_dataChangeValidator = dataChangeValidator;
}
public AssessmentResultsController(IStudentRepository studentRepository,
IAssessmentResultRepository assessmentResultRepository,
IProgrammeRepository programmeRepository,
IModuleRepository moduleRepository,
IAssessmentRepository assessmentRepository)
{
this.studentRepository = studentRepository;
this.assessmentResultRepository = assessmentResultRepository;
this.programmeRepository = programmeRepository;
this.moduleRepository = moduleRepository;
this.assessmentRepository = assessmentRepository;
}
public StudentController(UserManager <AppUser> userManager,
IStudentRepository studentRepository,
IProgrammeRepository programmeRepository,
IAssessmentResultRepository assessmentResultRepository,
ILogger <StudentController> logger)
{
this.userManager = userManager;
this.studentRepository = studentRepository;
this.programmeRepository = programmeRepository;
this.assessmentResultRepository = assessmentResultRepository;
this.logger = logger;
}
public UserController(
UserManager <Student> userManager,
IProgrammeRepository <Programme> programmeRepository,
IProgrammeRepository <MyRole> myRoleIprogrammeRepository
,
RoleManager <MongoRole> roleManager,
IMongoCollection <Student> userCollection)
{
_roleManager = roleManager;
_userManager = userManager;
_userUserCollection = userCollection;
_programmeRepository = programmeRepository;
_myRoleIprogrammeRepository = myRoleIprogrammeRepository;
}
public DashboardService(ISchoolRepository schoolRepository, IDepartmentRepository departmentRepository, IProgrammeRepository programmeRepository,
ICourseRepository courseRepository, ILecturerRepository lecturerRepository, IStudentRepository studentRepository, ISessionSemesterRepository sessionSemesterRepository,
ILecturerCourseRepository lecturerCourseRepository, IRegisteredCourseRepository registeredCourseRepository)
{
_schoolRepository = schoolRepository;
_departmentRepository = departmentRepository;
_programmeRepository = programmeRepository;
_courseRepository = courseRepository;
_lecturerRepository = lecturerRepository;
_studentRepository = studentRepository;
_sessionSemesterRepository = sessionSemesterRepository;
_lecturerCourseRepository = lecturerCourseRepository;
_registeredCourseRepository = registeredCourseRepository;
}
public ExamController(ILogger <HomeController> logger,
IProgrammeRepository <Programme> programmeRepository,
IExamRepository examRepository,
UserManager <Student> userManager,
RoleManager <MongoRole> roleManager,
IMongoCollection <Student> userCollection)
{
_logger = logger;
_programmeRepository = programmeRepository;
_examRepository = examRepository;
_roleManager = roleManager;
_userManager = userManager;
_userUserCollection = userCollection;
}
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");
});
});
}
public static void ValidateProgrammes(this IProgrammeRepository repository, IReadOnlyCollection <string> externalRefs)
{
if (repository is null)
{
throw new ArgumentNullException(nameof(repository));
}
var sanitizedExternalRefs = externalRefs.ToList().Distinct(StringComparer.CurrentCultureIgnoreCase).Trim().ToList();
var existingProgrammes = repository.FindByExternal(sanitizedExternalRefs);
var invalidExternalRefs = sanitizedExternalRefs.Except(existingProgrammes.Select(s => s.ExternalReference), StringComparer.CurrentCultureIgnoreCase).ToList();
if (invalidExternalRefs.Any())
{
throw new DataSyncException(DataSyncErrorCode.ExternalReferenceNotFound, "Invalid Programme: " + string.Join(",", invalidExternalRefs.ToList()));
}
}
public TimeController(
ITimeRepository repository,
IPeriodeRepository periodeRepository,
IJourRepository jourRepository,
ISalleRepository salleRepository,
IProgrammeRepository programmeRepository,
IEnseignantRepository enseignantRepository,
ITimeService service
)
{
this.repository = repository;
this.periodeRepository = periodeRepository;
this.jourRepository = jourRepository;
this.salleRepository = salleRepository;
this.programmeRepository = programmeRepository;
this.enseignantRepository = enseignantRepository;
this.service = service;
}
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));
});
});
}
public ProgrammeResultChecker(ITestDataImporter dataImporter, IProgrammeRepository programmeRepository) : base(dataImporter)
{
_programmeRepository = programmeRepository;
}
public ProgrammeService(IProgrammeRepository eventRepository, IUnitOfWork unitOfWork)
{
this._programmeRepository = eventRepository;
this._unitOfWork = unitOfWork;
}
public ProgrammeDomainModelHandler(IProgrammeRepository repository, ISqlServerTestDbContext dbContext,
IMapper mapper) : base(dbContext, mapper)
{
_repository = repository;
}
public ProgrammeService(IProgrammeRepository programmeRepository) => _programmeRepository = programmeRepository;
public ProgrammeDomainModelHandler(IProgrammeRepository programmeRepository) =>
public ProgrammeController(IProgrammeRepository programmeRepository)
{
this.programmeRepository = programmeRepository;
}
public RecommendationsFakeData(ISpotRepository spotRepository, ISalesAreaRepository salesAreaRepository, IProgrammeRepository programmeRepository)
{
_spotRepository = spotRepository;
_salesAreaRepository = salesAreaRepository;
_programmeRepository = programmeRepository;
}
public ProgrammesController(IProgrammeRepository programmeRepository, IFacultyRepository facultyRepository, IReviewRepository reviewRepository)
{
_programmeRepository = programmeRepository;
_facultyRepository = facultyRepository;
_reviewRepository = reviewRepository;
}
public ProgrammeService()
{
_programmeRepository = new ProgrammeRepository(new ConnectionStringProvider());
}
public ProgrammeService(IProgrammeRepository programmeRepository)
{
_programmeRepository = programmeRepository;
}
public StudentService(IStudentRepository studentRepository, IMailService mailService, IProgrammeRepository programmeRepository)
{
_studentRepository = studentRepository;
_mailService = mailService;
_programmeRepository = programmeRepository;
}
public ModuleController(IModuleRepository moduleRepository, IProgrammeRepository programmeRepository)
{
this.moduleRepository = moduleRepository;
this.programmeRepository = programmeRepository;
}
public ProgrammeService(IProgrammeRepository eventRepository, IUnitOfWork unitOfWork)
{
this._programmeRepository = eventRepository;
this._unitOfWork = unitOfWork;
}
