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 ScenarioWebService(IScenarioRepository scenarioRepository, IScenarioSummaryRepository scenarioSummaryRepository, IScenarioProductFilterRepository scenarioProductFilterRepository, IScenarioHierarchyFilterRepository scenarioHierarchyFilterRepository)
{
_scenarioRepository = scenarioRepository;
_scenarioSummaryRepository = scenarioSummaryRepository;
_scenarioHierarchyFilterRepository = scenarioHierarchyFilterRepository;
_scenarioProductFilterRepository = scenarioProductFilterRepository;
}
/// <summary>
/// Filter a list of campaigns based on shared excluded campaign ids in run scenarios
/// </summary>
/// <param name="scenarioRepository">Instance of the Scenario Repository</param>
/// <param name="run">Run for generating optimiser input files</param>
/// <param name="campaigns">List of all campaign records in the database</param>
/// <returns></returns>
public static List <Campaign> FilterOutExcludedCampaigns(
IScenarioRepository scenarioRepository,
Run run,
IEnumerable <Campaign> campaigns)
{
List <int> filteredCampaignIds = new List <int>();
foreach (var runScenario in run.Scenarios)
{
var scenario = scenarioRepository.Get(runScenario.Id);
if (scenario is null)
{
continue;
}
var campaignsFilteredByPriority = scenario.ToAgScenarioCampaignPass();
if (campaignsFilteredByPriority != null && campaignsFilteredByPriority.AgScenarioCampaignPasses.Any())
{
filteredCampaignIds.AddRange(
campaignsFilteredByPriority
.AgScenarioCampaignPasses
.Select(o => o.CampaignCustomNo)
.ToList()
);
}
ReturnCampaignsThatShouldNotBeFiltered(run, scenario, filteredCampaignIds);
}
filteredCampaignIds = filteredCampaignIds.Distinct().ToList();
return(campaigns.Where(c => filteredCampaignIds.Any(o => o == c.CustomId)).ToList());
}
/// <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 CampaignCleaner(
ICampaignRepository campaignRepository,
IScenarioRepository scenarioRepository)
{
_campaignRepository = campaignRepository;
_scenarioRepository = scenarioRepository;
}
public MonitorManager(IChannelRepository channelRepository, IMonitorRepository monitorRepository, IRecordRepository recordRepository, IScenarioRepository scenarioRepository)
{
this.channelRepository = channelRepository;
this.monitorRepository = monitorRepository;
this.recordRepository = recordRepository;
this.scenarioRepository = scenarioRepository;
}
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 ScenarioListService(IScenarioRepository scenarioRepository,
IFolderRepository folderRepository,
IScenarioExecutorService scenarioExecutorService)
{
_scenarioRepository = scenarioRepository;
_folderRepository = folderRepository;
_scenarioExecutorService = scenarioExecutorService;
}
public LoanService(ILoanRepository loanRepository,
IScenarioRepository scenarioRepository,
IMapper mapper)
{
_mapper = mapper;
_loanRepository = loanRepository;
_scenarioRepository = scenarioRepository;
}
public ScenarioDomainModelHandler(
IScenarioRepository repository,
ISqlServerTenantDbContext dbContext
)
{
_repository = repository;
_dbContext = dbContext;
}
public ScenarioService(IScenarioRepository scenarioRepository)
{
if (scenarioRepository == null)
{
throw new ArgumentNullException("scenarioRepository");
}
this.scenarioRepository = scenarioRepository;
}
public ScenarioService(IScenarioRepository scenarioRepository)
{
if (scenarioRepository == null)
{
throw new ArgumentNullException("scenarioRepository");
}
this.scenarioRepository = scenarioRepository;
}
/// <summary>
/// Returns RunModel with BasicData for run
/// </summary>
/// <param name="run"></param>
/// <param name="scenarioRepository"></param>
/// <returns></returns>
public static RunModel MapToRunModel(Run run, IScenarioRepository scenarioRepository, IMapper mapper)
{
// Get scenarios for run
var scenarios = scenarioRepository.FindByIds(run.Scenarios.Select(s => s.Id)).ToList();
var runModel = mapper.Map <RunModel>(Tuple.Create(run, scenarios));
return(runModel);
}
public CurriculumServices(ICurriculumRepository curriculumRepository, ISessionRepository curriculumSessionRepository, IClubRepository clubRepository, ICurriculumStatementRepository curriculumStatementRepository, IStatementRolesRepository statementRolesRepository, IScenarioRepository scenarioRepository)
{
_curriculumRepository = curriculumRepository;
_sessionRepository = curriculumSessionRepository;
_clubRepository = clubRepository;
_curriculumStatementRepository = curriculumStatementRepository;
_statementRolesRepository = statementRolesRepository;
_scenarioRepository = scenarioRepository;
}
public CampaignPassPrioritiesService(
ICampaignRepository campaignRepository,
IMapper mapper,
IPassRepository passRepository,
IScenarioRepository scenarioRepository
)
{
_campaignRepository = campaignRepository;
_mapper = mapper;
_passRepository = passRepository;
_scenarioRepository = scenarioRepository;
}
/// <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);
}
//private readonly ILogger _logger;
public ExcelImportDataService(IScenarioRepository scenarioRepository,
IRegionRepository regionRepository,
IVariableRepository variableRepository,
IVariableXlsDescriptionRepository variableXlsDescriptionRepository,
IAgrigationXlsDescriptionRepository agrigationXlsDescriptionRepository,
ISubVariableRepository subVariableRepository,
ISubVariableDataRepository subVariableDataRepository,
IProcessSetRepository processSetRepository,
ICommodityRepository commodityRepository,
ICommoditySetRepository commoditySetRepository,
IAttributeRepository attributeRepository,
IUserConstraintRepository userConstraintRepository,
IVariableDataRepository variableDataRepository,
IRegionAgrigationTypeRepository regionAgrigationTypeRepository,
AggregationSumCulculationService aggregationSumulCalculationService,
AggregationSumWorldCulculationService aggregationSumWorldCulculationService,
IXlsFormulaUpdaterService xlsFormulaUpdaterService,
IDataRepository dataRepository,
IUnitOfWork unitOfWork,
//ILogger<ExcelImportDataService> logger,
NxsDbContext context)
{
ScenarioRepository = scenarioRepository;
RegionRepository = regionRepository;
ProcessSetRepository = processSetRepository;
CommodityRepository = commodityRepository;
CommoditySetRepository = commoditySetRepository;
AttributeRepository = attributeRepository;
UserConstraintRepository = userConstraintRepository;
VariableDataRepository = variableDataRepository;
SubVariableRepository = subVariableRepository;
SubVariableDataRepository = subVariableDataRepository;
_aggregationSumCulculationService = aggregationSumulCalculationService;
_aggregationSumWorldCulculationService = aggregationSumWorldCulculationService;
_xlsFormulaUpdaterService = xlsFormulaUpdaterService;
_variableRepository = variableRepository;
_variableXlsDescriptionRepository = variableXlsDescriptionRepository;
_agrigationXlsDescriptionRepository = agrigationXlsDescriptionRepository;
_dataRepository = dataRepository;
_context = context;
UnitOfWork = unitOfWork;
//_logger = logger;
_variableDataHandler = new VariableDataHandler(this);
_agrigationDataHandler = new AggregationDataHandler(this);
_agrigationDataHandlerWorld = new AggregationDataHandlerWorld(this);
_aggregationDataHandlerGdp = new AggregationDataHandlerGdp(this);
}
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 RecommendationsController(
AWSSettings awsSettings,
IBackgroundJobManager backgroundJobManager,
MemoryCache cache,
IRecommendationRepository recommendationRepository,
IRecommendationsResultReportCreator reportCreator,
IRunRepository runRepository,
IScenarioRepository scenarioRepository,
IFactory storageClientFactory)
{
_awsSettings = awsSettings;
_backgroundJobManager = backgroundJobManager;
_cache = cache;
_recommendationRepository = recommendationRepository;
_reportCreator = reportCreator;
_runRepository = runRepository;
_scenarioRepository = scenarioRepository;
_storageClientFactory = storageClientFactory;
}
public IReadOnlyList <string> GetRequiredAssets(IScenarioRepository scenarioRepository, string entryScenario)
{
List <string> returnList = new List <string>();
List <string> closedScenarioList = new List <string>();
List <string> openScenarioList = new List <string>();
openScenarioList.Add(entryScenario);
while (openScenarioList.Count > 0)
{
string currentScenarioName = openScenarioList[0];
openScenarioList.Remove(currentScenarioName);
closedScenarioList.Add(currentScenarioName);
var scenario = scenarioRepository.GetScenario(currentScenarioName);
var callCandidates = scenario
.Commands
.OfType <CallCommand>()
.Select((arg) => arg.file)
.Where((arg) => !string.IsNullOrEmpty(arg) && !openScenarioList.Contains(arg) && !closedScenarioList.Contains(arg))
.ToList();
var jumpCandidates = scenario
.Commands
.OfType <JumpCommand>()
.Select((arg) => arg.file)
.Where((arg) => !string.IsNullOrEmpty(arg) && !openScenarioList.Contains(arg) && !closedScenarioList.Contains(arg))
.ToList();
openScenarioList.AddRange(callCandidates.Union(jumpCandidates));
}
closedScenarioList.ForEach((obj) =>
{
var scenario = scenarioRepository.GetScenario(obj);
var additionalAssets = scenario
.Commands
.OfType <AssetCommand>()
.Select((arg) => arg.source)
.Where((arg) => !string.IsNullOrEmpty(arg) && !returnList.Contains(arg))
.ToList();
returnList.AddRange(additionalAssets);
});
return(returnList);
}
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 GenerateRecommendationsReportBackgroundJob(
AWSSettings awsSettings,
IAuditEventRepository auditEventRepository,
MemoryCache cache,
ReportExportNotificationHub exportStatusNotifier,
IRecommendationRepository recommendationRepository,
IRecommendationsResultReportCreator recommendationsResultReportCreator,
IRunRepository runRepository,
IScenarioRepository scenarioRepository,
IFactory storageClientFactory)
{
_awsSettings = awsSettings;
_cache = cache;
_exportStatusNotifier = exportStatusNotifier;
_recommendationRepository = recommendationRepository;
_recommendationsResultReportCreator = recommendationsResultReportCreator;
_runRepository = runRepository;
_scenarioRepository = scenarioRepository;
_storageClientFactory = storageClientFactory;
}
/// <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 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 SqlBulkCampaignCreatedOrUpdatedEventHandler(
ICampaignCleaner campaignCleaner,
ICampaignRepository campaignRepository,
IMapper mapper,
IScenarioRepository scenarioRepository,
IPassRepository passRepository,
ISqlServerDbContextFactory <ISqlServerTenantDbContext> dbContextFactory,
ISqlServerSalesAreaByNullableIdCacheAccessor salesAreaByIdCache,
ISqlServerSalesAreaByNameCacheAccessor salesAreaByNameCache
)
{
_campaignCleaner = campaignCleaner;
_mapper = mapper;
_dbContextFactory = dbContextFactory;
_campaignPassPrioritiesService = new CampaignPassPrioritiesService(
campaignRepository,
mapper,
passRepository,
scenarioRepository);
_salesAreaByIdCache = salesAreaByIdCache;
_salesAreaByNameCache = salesAreaByNameCache;
}
public ApplicationController(IScenarioRepository repository)
{
scenarioRepository = repository;
}
public ScenarioService(IOptions <DataSettings> options, IScenarioRepository scenarioRepository)
{
_dataSettings = options.Value;
_scenarioRepository = scenarioRepository;
}
public ChannelManager(IChannelRepository channelRepository, IScenarioRepository scenarioRepository)
{
this.channelRepository = channelRepository;
this.scenarioRepository = scenarioRepository;
}
public ReportController(IScenarioRepository repository)
{
scenarioRepository = repository;
strategyRepository = new ArchitecturalStrategyRepository();
reportRepository = new ReportRepository();
}
public ScenarioServices(IScenarioRepository scenarioRepository)
{
_scenarioRepository = scenarioRepository;
}
public ScenarioController(ScenarioRepository scenarioRepository, ScenarioServices scenarioServices)
{
this.scenarioRepository = scenarioRepository;
this.scenarioServices = scenarioServices;
}
public ScenarioController(IScenarioRepository scenarioRepository)
{
_scenarioRepository = scenarioRepository ?? throw new ArgumentNullException(nameof(scenarioRepository));
}
public UtilityRatingController(IScenarioRepository repository)
{
scenarioRepository = repository;
}
public ScenarioController(IScenarioRepository repository)
{
scenarioRepository = repository;
stepsRepository = new StepsRepository();
}
public ScenarioController(IScenarioRepository repository)
{
scenarioRepository = repository;
}
public ScenarioService(IScenarioRepository scenarioRepository,
IMapper mapper)
{
_scenarioRepository = scenarioRepository;
_mapper = mapper;
}
public static ScenarioViewModel CreateIndex(IScenarioRepository repository, long projectID)
{
var viewModel = new ScenarioViewModel();
viewModel.projectID = projectID;
viewModel.Scenarios = repository.GetByProjectID(projectID).OrderBy(x => x.Priority);
viewModel.Steps = repository.Steps().ToList();
viewModel.ProjectName = repository.GetProjectByID(projectID).Name;
viewModel.nextStepToComplete = repository.NextStepToComplete();
return viewModel;
}
public ScenarioController(IScenarioRepository scenarioRepo)
{
_scenarioRepo = scenarioRepo;
}
public static ScenarioViewModel CreateTopThird(IScenarioRepository repository, long projectID)
{
var viewModel = new ScenarioViewModel();
viewModel.UtilitiesList = repository.UtilityList(projectID).OrderBy(x => x.Scenario.Priority).ToList();
viewModel.ScenariosList = repository.GetTopThird(projectID).OrderBy(x => x.Priority).ToList();
viewModel.TopScenarios = repository.GetTopThird(projectID).OrderBy(x => x.Priority);
return viewModel;
}
