public ValidateForRun(IRepositoryFactory repositoryFactory,
IISRSettingsRepository isrSettingsRepository, IRSSettingsRepository rsSettingsRepository,
IOutputFileRepository outputFileRepository, IUniverseRepository universeRepository,
ISpotRepository spotRepository, IScheduleRepository scheduleRepository,
IRatingsScheduleRepository ratingsScheduleRepository, IProductRepository productRepository,
IClashRepository clashRepository,
ISystemMessageRepository systemMessageRepository,
IAutoBooks autoBooks, ITenantSettingsRepository tenantSettingsRepository, IClearanceRepository clearanceRepository,
IFeatureManager featureManager, ISystemLogicalDateService systemLogicalDateService)
{
_repositoryFactory = repositoryFactory;
_isrSettingsRepository = isrSettingsRepository;
_rsSettingsRepository = rsSettingsRepository;
_outputFileRepository = outputFileRepository;
_universeRepository = universeRepository;
_spotRepository = spotRepository;
_scheduleRepository = scheduleRepository;
_ratingsScheduleRepository = ratingsScheduleRepository;
_productRepository = productRepository;
_clashRepository = clashRepository;
_systemMessageRepository = systemMessageRepository;
_autoBooks = autoBooks;
_tenantSettingsRepository = tenantSettingsRepository;
_clearanceRepository = clearanceRepository;
_featureManager = featureManager;
_systemLogicalDateService = systemLogicalDateService;
}
/// <summary>
/// Returns RunModels for runs
/// </summary>
/// <param name="runs"></param>
/// <param name="scenarioRepository"></param>
/// <param name="passRepository"></param>
/// <param name="analysisGroupRepository"></param>
/// <param name="tenantSettingsRepository"></param>
/// <returns></returns>
public static List <RunModel> MapToRunModels(IEnumerable <Run> runs, IScenarioRepository scenarioRepository,
IPassRepository passRepository, IAnalysisGroupRepository analysisGroupRepository,
ITenantSettingsRepository tenantSettingsRepository, IMapper mapper)
{
// Get scenarios for all runs
var scenarios = scenarioRepository.FindByIds(runs.SelectMany(r => r.Scenarios).Select(s => s.Id).Distinct()).ToList();
// Get passes for all runs
var passes = passRepository.FindByIds(scenarios.SelectMany(s => s.Passes).Select(p => p.Id).Distinct()).ToList();
var analysisGroupIds = runs.SelectMany(x => x.AnalysisGroupTargets.Select(t => t.AnalysisGroupId)).ToArray();
var analysisGroups = analysisGroupIds.Any()
? analysisGroupRepository.GetByIds(analysisGroupIds).ToDictionary(x => x.Id)
: new Dictionary <int, AnalysisGroupNameModel>();
// Get default ScenarioId
var defaultScenarioId = tenantSettingsRepository.Get().DefaultScenarioId;
List <RunModel> runModels = new List <RunModel>();
foreach (var run in runs)
{
var runModel = mapper.Map <RunModel>(Tuple.Create(run, scenarios, passes, analysisGroups, defaultScenarioId));
runModels.Add(runModel);
}
return(runModels);
}
public RunsValidator(
IBRSConfigurationTemplateRepository brsConfigurationTemplateRepository,
ITenantSettingsRepository tenantSettingsRepository,
IRunRepository runRepository,
IScenarioRepository scenarioRepository,
ISalesAreaRepository salesAreaRepository,
ICampaignRepository campaignRepository,
IDemographicRepository demographicRepository,
IDeliveryCappingGroupRepository deliveryCappingGroupRepository,
IFeatureManager featureManager,
IRunTypeRepository runTypeRepository,
IAnalysisGroupRepository analysisGroupRepository,
IMapper mapper
)
{
_brsConfigurationTemplateRepository = brsConfigurationTemplateRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_runRepository = runRepository;
_scenarioRepository = scenarioRepository;
_salesAreaRepository = salesAreaRepository;
_campaignRepository = campaignRepository;
_demographicRepository = demographicRepository;
_deliveryCappingGroupRepository = deliveryCappingGroupRepository;
_featureManager = featureManager;
_runTypeRepository = runTypeRepository;
_analysisGroupRepository = analysisGroupRepository;
_mapper = mapper;
}
public ScenarioResultsController(ISalesAreaRepository salesAreaRepository, IRunRepository runRepository, IFailuresRepository failuresRepository,
IScenarioResultRepository scenarioResultRepository, IResultsFileRepository resultsFileRepository, IOutputFileRepository outputFileRepository,
IRecommendationRepository recommendationRepository, ICampaignRepository campaignRepository, IProductRepository productRepository, IMapper mapper,
IClashRepository clashRepository, IScenarioRepository scenarioRepository, IScenarioCampaignResultRepository scenarioCampaignResultRepository,
IScenarioCampaignFailureRepository scenarioCampaignFailureRepository, IFunctionalAreaRepository functionalAreaRepository,
ITenantSettingsRepository tenantSettingsRepository, IFactory storageClientFactory, AWSSettings awsSettings,
IRecommendationAggregator recommendationAggregator, IScenarioCampaignResultReportCreator scenarioCampaignResultReportCreator,
IKPICalculationScopeFactory kpiCalculationScopeFactory)
{
_salesAreaRepository = salesAreaRepository;
_runRepository = runRepository;
_scenarioResultRepository = scenarioResultRepository;
_resultsFileRepository = resultsFileRepository;
_outputFileRepository = outputFileRepository;
_failuresRepository = failuresRepository;
_recommendationRepository = recommendationRepository;
_campaignRepository = campaignRepository;
_productRepository = productRepository;
_clashRepository = clashRepository;
_scenarioRepository = scenarioRepository;
_scenarioCampaignResultRepository = scenarioCampaignResultRepository;
_mapper = mapper;
_tenantSettingsRepository = tenantSettingsRepository;
_scenarioCampaignFailureRepository = scenarioCampaignFailureRepository;
_functionalAreaRepository = functionalAreaRepository;
_storageClientFactory = storageClientFactory;
_awsSettings = awsSettings;
_recommendationAggregator = recommendationAggregator;
_scenarioCampaignResultReportCreator = scenarioCampaignResultReportCreator;
_kpiCalculationScopeFactory = kpiCalculationScopeFactory;
}
public TenantSettingsDomainModelHandler(
ITenantSettingsRepository tenantSettingsRepository,
ISqlServerDbContext dbContext)
{
_tenantSettingsRepository = tenantSettingsRepository ??
throw new ArgumentNullException(
nameof(tenantSettingsRepository));
_dbContext = dbContext;
}
public UpdateTenantSettingsCommandHandler(
IMapper mapper,
ITenantsRepository tenantsRepository,
ITenantSettingsRepository tenantSettingsRepository,
ITenantAllowedOriginsRepository allowedOriginsRepository)
{
_tenantsRepository = tenantsRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_allowedOriginsRepository = allowedOriginsRepository;
_mapper = mapper;
}
public RunCompletionNotifier(
ITenantSettingsRepository tenantSettingsRepository,
IAuditEventRepository auditEventRepository,
INotificationCollection notifications,
IPipelineAuditEventRepository pipelineAuditEventRepository)
{
_tenantSettingsRepository = tenantSettingsRepository;
_auditEventRepository = auditEventRepository;
_notifications = notifications;
_pipelineAuditEventRepository = pipelineAuditEventRepository;
}
public CreateTenantCommandHandler(
ITenantsRepository tenantsRepository,
ITenantSettingsRepository tenantSettingsRepository,
ITenantAllowedOriginsRepository tenantAllowedOriginsRepository,
IMapper mapper)
{
_tenantsRepository = tenantsRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_tenantAllowedOriginsRepository = tenantAllowedOriginsRepository;
_mapper = mapper;
}
/// <summary>
/// Create an instance of <see cref="LibrarySalesAreaPassPrioritiesController"/>
/// </summary>
/// <param name="librarySalesAreaPassPrioritiesRepository">The repository to use for LibrarySalesAreaPassPriority</param>
/// <param name="tenantSettingsRepository">The repository to use for TenantSettings</param>
/// <param name="mapper">The mapper to use for Model Mappings</param>
/// <param name="validatorForCreate">The Validator For Create</param>
/// <param name="validatorForUpdate">The Validator For Update</param>
public LibrarySalesAreaPassPrioritiesController(ILibrarySalesAreaPassPrioritiesRepository librarySalesAreaPassPrioritiesRepository,
ITenantSettingsRepository tenantSettingsRepository,
IMapper mapper,
IModelDataValidator <CreateLibrarySalesAreaPassPriorityModel> validatorForCreate,
IModelDataValidator <UpdateLibrarySalesAreaPassPriorityModel> validatorForUpdate)
{
_mapper = mapper;
_librarySalesAreaPassPrioritiesRepository = librarySalesAreaPassPrioritiesRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_validatorForCreate = validatorForCreate;
_validatorForUpdate = validatorForUpdate;
}
/// <summary>
/// Returns ScenarioModel from Scenario
/// </summary>
/// <param name="scenario"></param>
/// <param name="scenarioRepository"></param>
/// <param name="passRepository"></param>
/// <param name="tenantSettingsRepository"></param>
/// <returns></returns>
public static ScenarioModel MapToScenarioModel(Scenario scenario, IScenarioRepository scenarioRepository, IPassRepository passRepository,
ITenantSettingsRepository tenantSettingsRepository, IMapper mapper)
{
// Get passes
List <Pass> passes = passRepository.FindByIds(scenario.Passes.Select(p => p.Id)).ToList();
// Get default ScenarioId
var defaultScenarioId = tenantSettingsRepository.Get().DefaultScenarioId;
var scenarioModel = mapper.Map <ScenarioModel>(Tuple.Create(scenario, passes, defaultScenarioId));
return(scenarioModel);
}
/// <summary>
/// Returns RunModel for run
/// </summary>
/// <param name="run"></param>
/// <param name="scenarioRepository"></param>
/// <param name="passRepository"></param>
/// <param name="tenantSettingsRepository"></param>
/// <param name="allCampaigns"></param>
/// <param name="functionalAreaRepository"></param>
/// <returns></returns>
public static RunModel MapToRunModel(Run run, IScenarioRepository scenarioRepository, IPassRepository passRepository,
ITenantSettingsRepository tenantSettingsRepository, IMapper mapper,
IAnalysisGroupRepository analysisGroupRepository,
IFunctionalAreaRepository functionalAreaRepository = null,
IScenarioCampaignMetricRepository scenarioCampaignMetricRepository = null,
List <CampaignWithProductFlatModel> allCampaigns = null,
List <Pass> passesFromDb = null, List <Scenario> scenariosFromDb = null)
{
// Get scenarios for run
var scenarios = scenariosFromDb ?? scenarioRepository.FindByIds(run.Scenarios.Select(s => s.Id)).ToList();
// Get passes for run
var passes = passesFromDb ?? passRepository.FindByIds(scenarios.SelectMany(s => s.Passes).Select(p => p.Id).Distinct()).ToList();
var analysisGroups = run.AnalysisGroupTargets.Any()
? analysisGroupRepository.GetByIds(run.AnalysisGroupTargets.Select(x => x.AnalysisGroupId).ToArray()).ToDictionary(x => x.Id)
: new Dictionary <int, AnalysisGroupNameModel>();
// Get default ScenarioId
var defaultScenarioId = tenantSettingsRepository.GetDefaultScenarioId();
if (run.RunStatus == RunStatus.NotStarted && allCampaigns != null && allCampaigns.Any())
{
// Since the run has not already started amend Run Scenarios
// with CampaignPassPriorities for new Campaigns and remove
// CampaignPassPriorities of deleted Campaigns
CampaignPassPrioritiesServiceMapper.AmendCampaignPassPriorities(
scenarios,
passes,
allCampaigns,
passRepository,
mapper);
}
var runModel = mapper.Map <RunModel>(Tuple.Create(run, scenarios, passes, analysisGroups, defaultScenarioId));
if (run.RunStatus == RunStatus.Complete)
{
ApplyFunctionalAreaFaultTypesToRunModel(runModel, run, functionalAreaRepository);
}
if (scenarioCampaignMetricRepository != null)
{
runModel.Scenarios.ForEach(s => ApplyKPIsToScenarioCampaigns(s, scenarioCampaignMetricRepository));
}
return(runModel);
}
///// <summary>
///// Constructor.
///// </summary>
public TenantDatabaseController(ITenantsRepository tenantsRepository,
ITenantSettingsRepository tenantSettingsRepository,
ITenantSettingsFeatureManager featureManager,
IFeatureManager productFeatureManager,
IFeatureSettingsProvider featureSettingsProvider,
ITestEnvironment testEnvironment,
IConfiguration configuration,
IMapper mapper)
{
_tenantsRepository = tenantsRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_featureManager = featureManager;
_productFeatureManager = productFeatureManager;
_featureSettingsProvider = featureSettingsProvider;
_testEnvironment = testEnvironment;
_configuration = configuration;
_mapper = mapper;
}
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;
}
/// <summary>
/// Returns ScenarioModel list from Scenario list
/// </summary>
/// <param name="scenarios"></param>
/// <param name="scenarioRepository"></param>
/// <param name="passRepository"></param>
/// <param name="tenantSettingsRepository"></param>
/// <returns></returns>
public static List <ScenarioModel> MapToScenarioModels(
List <Scenario> scenarios,
IScenarioRepository scenarioRepository,
IPassRepository passRepository,
ITenantSettingsRepository tenantSettingsRepository,
IMapper mapper)
{
var scenarioModels = new List <ScenarioModel>();
var passIdsInScenarios = scenarios
.SelectMany(s => s.Passes)
.Select(p => p.Id);
var passes = passRepository.GetAll().Where(p => passIdsInScenarios.Contains(p.Id)).ToList();
var defaultScenarioId = tenantSettingsRepository.Get().DefaultScenarioId;
scenarios.ForEach(scenario => scenarioModels.Add(mapper.Map <ScenarioModel>(
Tuple.Create(scenario, passes, defaultScenarioId))));
return(scenarioModels);
}
public SystemLogicalDateService(ITenantSettingsRepository tenantSettingsRepository, IFeatureManager featureManager, IClock clock, IAuditEventRepository auditEventRepository)
{
_clock = clock;
var tenantSettings = tenantSettingsRepository.Get();
var useSystemLogicalDate = featureManager.IsEnabled(nameof(ProductFeature.UseSystemLogicalDate));
if (useSystemLogicalDate)
{
var isDateValid = DateTime.TryParseExact(tenantSettings.SystemLogicalDate, SystemLogicalDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var systemLogicalDate);
if (isDateValid)
{
_isSystemLogicalDateUsed = true;
_systemLogicalDate = systemLogicalDate.Add(_clock.GetCurrentInstant().ToDateTimeUtc().TimeOfDay);
}
else
{
auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0, $"System Logical Date is not it valid format. " +
$"Date set: '{tenantSettings.SystemLogicalDate}', but valid format is: '{SystemLogicalDateFormat}'. Using current Date instead."));
}
}
}
public TenantSettingsFeatureManager(ITenantSettingsRepository tenantSettingsRepository)
{
_tenantSettingsRepository = tenantSettingsRepository;
}
