public BulkInventoryLockCreatedEventHandler(
IInventoryLockRepository inventoryLockRepository,
ISalesAreaRepository salesAreaRepository,
IMapper mapper)
{
_inventoryLockRepository = inventoryLockRepository;
_salesAreaRepository = salesAreaRepository;
_mapper = mapper;
}
public BulkUniverseCreatedEventHandler(IMapper mapper,
IUniverseRepository universeRepository,
ISalesAreaRepository salesAreaRepository,
IDemographicRepository demographicRepository)
{
_mapper = mapper;
_universeRepository = universeRepository;
_salesAreaRepository = salesAreaRepository;
_demographicRepository = demographicRepository;
}
public UniversesController(IUniverseRepository universeRepository, IDemographicRepository demographicRepository,
ISalesAreaRepository salesAreaRepository,
IDataChangeValidator dataChangeValidator, IMapper mapper)
{
_universeRepository = universeRepository;
_demographicRepository = demographicRepository;
_salesAreaRepository = salesAreaRepository;
_dataChangeValidator = dataChangeValidator;
_mapper = mapper;
}
public CreateSponsorshipItemModelValidation(ISalesAreaRepository salesAreaRepository,
IProgrammeRepository programmeRepository,
IValidator <SponsoredDayPartModelBase> sponsoredDayPartModelValidation,
SponsorshipModelBase sponsorshipModelBase = null)
: base(salesAreaRepository,
programmeRepository,
sponsoredDayPartModelValidation,
sponsorshipModelBase)
{
}
public SalesAreaUpdatedEventHandler(
ISalesAreaRepository salesAreaRepository,
IDemographicRepository demographicRepository,
ISalesAreaDemographicRepository salesAreaDemographicRepository,
IMapper mapper)
{
_salesAreaRepository = salesAreaRepository;
_demographicRepository = demographicRepository;
_salesAreaDemographicRepository = salesAreaDemographicRepository;
_mapper = mapper;
}
public BulkTotalRatingCreatedEventHandler(
ITotalRatingRepository totalRatingRepository,
IDemographicRepository demographicRepository,
ISalesAreaRepository salesAreaRepository,
IMapper mapper)
{
_totalRatingRepository = totalRatingRepository;
_demographicRepository = demographicRepository;
_salesAreaRepository = salesAreaRepository;
_mapper = mapper;
}
public BulkSpotCreatedOrUpdatedEventHandler(
ISpotRepository spotRepository,
IBookingPositionRepository bookingPositionRepository,
ISalesAreaRepository salesAreaRepository,
IMapper mapper)
{
_spotRepository = spotRepository;
_bookingPositionRepository = bookingPositionRepository;
_salesAreaRepository = salesAreaRepository;
_mapper = mapper;
}
public BulkSpotBookingRuleCreatedEventHandler(
ISpotBookingRuleRepository spotBookingRuleRepository,
ISalesAreaRepository salesAreaRepository,
IMetadataRepository metadataRepository,
IMapper mapper)
{
_spotBookingRuleRepository = spotBookingRuleRepository;
_salesAreaRepository = salesAreaRepository;
_metadataRepository = metadataRepository;
_mapper = mapper;
}
public BulkSalesAreaCreatedOrUpdatedHandler(
ISalesAreaRepository salesAreaRepository,
IDemographicRepository demographicRepository,
ISalesAreaDemographicRepository salesAreaDemographicRepository,
IMapper mapper)
{
_salesAreaRepository = salesAreaRepository;
_demographicRepository = demographicRepository;
_salesAreaDemographicRepository = salesAreaDemographicRepository;
_mapper = mapper;
}
public SalesAreasController(
IDemographicRepository demographicRepository,
ISalesAreaRepository salesAreaRepository,
ISalesAreaCleanupDeleteCommand salesAreaCleanupDeleteCommand,
IMapper mapper)
{
_demographicRepository = demographicRepository;
_salesAreaRepository = salesAreaRepository;
_cleanupDeleteCommand = salesAreaCleanupDeleteCommand;
_mapper = mapper;
}
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 BulkBreakCreatedEventHandler(
IBreakRepository breakRepository,
IScheduleRepository scheduleRepository,
ISalesAreaRepository salesAreaRepository,
IMetadataRepository metadataRepository,
IMapper mapper)
{
_breakRepository = breakRepository;
_scheduleRepository = scheduleRepository;
_salesAreaRepository = salesAreaRepository;
_metadataRepository = metadataRepository;
_mapper = mapper;
}
public BulkStandardDayPartGroupCreatedEventHandler(
IStandardDayPartGroupRepository standardDayPartGroupRepository,
IStandardDayPartRepository standardDayPartRepository,
ISalesAreaRepository salesAreaRepository,
IDemographicRepository demographicRepository,
IMapper mapper)
{
_standardDayPartGroupRepository = standardDayPartGroupRepository;
_standardDayPartRepository = standardDayPartRepository;
_salesAreaRepository = salesAreaRepository;
_demographicRepository = demographicRepository;
_mapper = mapper;
}
public BulkRestrictionCreatedOrUpdatedEventHandler(
IRestrictionRepository restrictionRepository,
ISalesAreaRepository salesAreaRepository,
IClearanceRepository clearanceRepository,
IProgrammeCategoryHierarchyRepository programmeCategoryRepository,
IMapper mapper)
{
_restrictionRepository = restrictionRepository;
_salesAreaRepository = salesAreaRepository;
_clearanceRepository = clearanceRepository;
_programmeCategoryRepository = programmeCategoryRepository;
_mapper = mapper;
}
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 BreaksController(IBreakRepository breakRepository, IMapper mapper,
IScheduleRepository scheduleRepository, ISpotRepository spotRepository,
IDataChangeValidator dataChangeValidator, IAuditEventRepository auditEventRepository,
ISalesAreaRepository salesAreaRepository,
IRecalculateBreakAvailabilityService recalculateBreakAvailabilityService)
{
_breakRepository = breakRepository;
_spotRepository = spotRepository;
_mapper = mapper;
_scheduleRepository = scheduleRepository;
_dataChangeValidator = dataChangeValidator;
_auditEventRepository = auditEventRepository;
_salesAreaRepository = salesAreaRepository;
_recalculateBreakAvailabilityService = recalculateBreakAvailabilityService;
}
public PassesController(
IScenarioRepository scenarioRepository,
IPassRepository passRepository,
IMapper mapper,
IDataManipulator dataManipulator,
ISalesAreaRepository salesAreaRepository,
IIdentityGeneratorResolver identityGeneratorResolver,
IPassInspectorService passInspectorService)
{
_scenarioRepository = scenarioRepository;
_passRepository = passRepository;
_identityGeneratorResolver = identityGeneratorResolver;
_mapper = mapper;
_dataManipulator = dataManipulator;
_salesAreaRepository = salesAreaRepository;
_passInspectorService = passInspectorService;
}
public OutputImmutableDataSnapshot(RunWithScenarioReference runWithScenarioRef, IRunRepository runRepository,
IScenarioRepository scenarioRepository, IPassRepository passRepository,
ICampaignRepository campaignRepository, IScheduleRepository scheduleRepository,
ISalesAreaRepository salesAreaRepository, IDemographicRepository demographicRepository,
IProgrammeDictionaryRepository programmeDictionaryRepository, ISpotRepository spotRepository,
IMetadataRepository metadataRepository)
{
var runStartDate = new Lazy <DateTime>(() => Run.Value.StartDate.Add(Run.Value.StartTime));
var runEndDate = new Lazy <DateTime>(() => DateHelper.ConvertBroadcastToStandard(Run.Value.EndDate, Run.Value.EndTime));
Run = new Lazy <Run>(() => runRepository.Find(runWithScenarioRef.RunId));
Scenario = new Lazy <Scenario>(() => scenarioRepository.Get(runWithScenarioRef.ScenarioId), true);
ScenarioPasses = new Lazy <IEnumerable <Pass> >(() => passRepository.FindByScenarioId(runWithScenarioRef.ScenarioId), true);
AllCampaigns = new Lazy <IEnumerable <Campaign> >(campaignRepository.GetAll, true);
AllSalesAreas = new Lazy <IEnumerable <SalesArea> >(salesAreaRepository.GetAll, true);
AllDemographics = new Lazy <IEnumerable <Demographic> >(demographicRepository.GetAll, true);
AllProgrammeDictionaries = new Lazy <IEnumerable <ProgrammeDictionary> >(programmeDictionaryRepository.GetAll, true);
BreakTypes = new Lazy <IEnumerable <string> >(() => metadataRepository.GetByKey(MetaDataKeys.BreakTypes).Select(e => (string)e.Value));
SpotsForRun = new Lazy <IEnumerable <Spot> >(() =>
{
var salesAreaPriorities = Run.Value.SalesAreaPriorities.Count == 0
? AllSalesAreas.Value
: AllSalesAreas.Value.Where(sa => Run.Value.SalesAreaPriorities.Find(rsa => rsa.SalesArea == sa.Name) != null);
return(spotRepository.Search(
runStartDate.Value,
runEndDate.Value,
salesAreaPriorities.Select(sa => sa.Name).ToList()
));
},
true
);
BreaksForRun = new Lazy <IEnumerable <BreakSimple> >(() =>
scheduleRepository.GetScheduleSimpleBreaks(
AllSalesAreas.Value.Select(c => c.Name).ToList(),
runStartDate.Value,
runEndDate.Value
),
true
);
}
public static void ValidateSalesArea(this ISalesAreaRepository repository, IReadOnlyCollection <string> salesAreaNames)
{
if (repository is null)
{
throw new ArgumentNullException(nameof(repository));
}
if (!salesAreaNames.Any())
{
throw new DataSyncException(DataSyncErrorCode.SalesAreaNotFound, "Empty Sales area names list");
}
var sanitizedNames = salesAreaNames.Distinct().Trim();
IReadOnlyCollection <string> existingSalesAreas =
repository.FindByNames(sanitizedNames)
.Select(r => r.Name)
.ToArray();
ValidateSalesArea(existingSalesAreas, salesAreaNames);
}
public ScenariosController(
IRunRepository runRepository,
IScenarioRepository scenarioRepository,
IPassRepository passRepository,
ITenantSettingsRepository tenantSettingsRepository,
IIdentityGeneratorResolver identityGeneratorResolver,
IMapper mapper,
ICampaignRepository campaignRepository,
ISalesAreaRepository salesAreaRepository,
IPassInspectorService passInspectorService)
{
_runRepository = runRepository;
_scenarioRepository = scenarioRepository;
_passRepository = passRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_identityGeneratorResolver = identityGeneratorResolver;
_mapper = mapper;
_campaignRepository = campaignRepository;
_salesAreaRepository = salesAreaRepository;
_passInspectorService = passInspectorService;
}
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));
});
});
}
/// <summary>
/// Get sales ares id by names
/// </summary>
/// <param name="salesAreaNames"></param>
/// <returns></returns>
public static void ValidateSaleArea(
this ISalesAreaRepository repository,
List <string> salesAreaNames)
{
if (repository is null)
{
throw new ArgumentNullException(nameof(repository));
}
if (salesAreaNames?.Count == 0)
{
throw new InvalidDataException("No sales area names to validate");
}
var names = salesAreaNames.Distinct().Trim();
List <SalesArea> salesAreas = repository.FindByNames(names);
if (salesAreas is null)
{
throw new InvalidDataException(
"Invalid Sales Area Names: " + string.Join(",", names)
);
}
var invalidNames = names
.Except(salesAreas.Select(s => s.Name))
.ToList();
if (invalidNames.Count == 0)
{
return;
}
throw new InvalidDataException(
"Invalid Sales Area Names: " + string.Join(",", invalidNames)
);
}
public UpdateLibrarySalesAreaPassPriorityModelValidation(ILibrarySalesAreaPassPrioritiesRepository repository,
ISalesAreaRepository salesAreaRepository) : base(repository, salesAreaRepository)
{
RuleFor(a => a).MustAsync(ContainUniqueName).When(ContainsValidName).WithName("Name").WithMessage(NameAlreadyExistsMessage);
}
public HolidayResultChecker(ITestDataImporter dataImporter, ISalesAreaRepository clashRepository) : base(dataImporter) =>
public BulkHolidayCreatedEventHandler(ISalesAreaRepository salesAreaRepository)
{
_salesAreaRepository = salesAreaRepository;
}
public RecommendationsFakeData(ISpotRepository spotRepository, ISalesAreaRepository salesAreaRepository, IProgrammeRepository programmeRepository)
{
_spotRepository = spotRepository;
_salesAreaRepository = salesAreaRepository;
_programmeRepository = programmeRepository;
}
public BulkStandardDayPartCreatedEventHandler(IStandardDayPartRepository standardDayPartRepository, ISalesAreaRepository salesAreaRepository, IMapper mapper)
{
_standardDayPartRepository = standardDayPartRepository;
_salesAreaRepository = salesAreaRepository;
_mapper = mapper;
}
public HolidayController(ISalesAreaRepository salesAreaRepository)
{
_salesAreaRepository = salesAreaRepository;
}
public BulkLengthFactorCreatedEventHandler(ILengthFactorRepository repository, ISalesAreaRepository salesAreaRepository, IMapper mapper)
{
_repository = repository;
_salesAreaRepository = salesAreaRepository;
_mapper = mapper;
}
public SalesAreaResultChecker(ITestDataImporter dataImporter, ISalesAreaRepository salesAreaRepository) : base(dataImporter) =>
