public DatasetDefinitionFieldChangesProcessor(
IFeatureToggle featureToggle,
IDatasetsApiClient datasetsApiClient,
ICalcsResiliencePolicies resiliencePolicies,
ILogger logger,
ICalculationService calculationService,
ICalculationsRepository calculationsRepository,
IMapper mapper)
{
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationService, nameof(calculationService));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_featureToggle = featureToggle;
_datasetsApiClient = datasetsApiClient;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_logger = logger;
_calculationService = calculationService;
_calculationsRepository = calculationsRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_mapper = mapper;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public SpecificationCalculationAnalysis(ICalcsResiliencePolicies policies,
ISpecificationsApiClient specifications,
ICalculationsRepository calculations,
ICalculationAnalysis calculationAnalysis,
IBuildProjectsService buildProjectsService,
IDatasetReferenceService datasetReferenceService,
IMapper mapper)
{
Guard.ArgumentNotNull(policies?.CalculationsRepository, nameof(policies.CalculationsRepository));
Guard.ArgumentNotNull(policies?.SpecificationsApiClient, nameof(policies.SpecificationsApiClient));
Guard.ArgumentNotNull(specifications, nameof(specifications));
Guard.ArgumentNotNull(calculations, nameof(calculations));
Guard.ArgumentNotNull(calculationAnalysis, nameof(calculationAnalysis));
Guard.ArgumentNotNull(buildProjectsService, nameof(buildProjectsService));
Guard.ArgumentNotNull(datasetReferenceService, nameof(datasetReferenceService));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_specificationsResilience = policies.SpecificationsApiClient;
_calculationsResilience = policies.CalculationsRepository;
_specifications = specifications;
_calculations = calculations;
_calculationAnalysis = calculationAnalysis;
_buildProjectsService = buildProjectsService;
_datasetReferenceService = datasetReferenceService;
_mapper = mapper;
}
public ApproveAllCalculationsService(
ICalculationsRepository calculationsRepository,
ICalcsResiliencePolicies resiliencePolicies,
ISpecificationsApiClient specificationsApiClient,
IResultsApiClient resultsApiClient,
ISearchRepository <CalculationIndex> searchRepository,
ICacheProvider cacheProvider,
ILogger logger,
IJobManagement jobManagement) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resultsApiClient, nameof(resultsApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsApiClient, nameof(resiliencePolicies.ResultsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
_calculationsRepository = calculationsRepository;
_logger = logger;
_calculationRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_resultsApiClient = resultsApiClient;
_resultsApiClientPolicy = resiliencePolicies.ResultsApiClient;
_searchRepository = searchRepository;
_cacheProvider = cacheProvider;
_cachePolicy = resiliencePolicies.CacheProviderPolicy;
}
private static CalculationService CreateCalculationService(
ICalculationsRepository calculationsRepository = null,
ILogger logger = null,
ISearchRepository <CalculationIndex> searchRepository = null,
IValidator <Calculation> calcValidator = null,
IBuildProjectsService buildProjectsService = null,
ISpecificationRepository specificationRepository = null,
ICacheProvider cacheProvider = null,
ICalcsResiliencePolicies resiliencePolicies = null,
IVersionRepository <CalculationVersion> calculationVersionRepository = null,
IJobsApiClient jobsApiClient = null,
ISourceCodeService sourceCodeService = null,
IFeatureToggle featureToggle = null,
IBuildProjectsRepository buildProjectsRepository = null,
ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = null)
{
return(new CalculationService
(calculationsRepository ?? CreateCalculationsRepository(),
logger ?? CreateLogger(),
searchRepository ?? CreateSearchRepository(),
calcValidator ?? CreateCalculationValidator(),
buildProjectsService ?? CreateBuildProjectsService(),
specificationRepository ?? CreateSpecificationRepository(),
cacheProvider ?? CreateCacheProvider(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
jobsApiClient ?? CreateJobsApiClient(),
sourceCodeService ?? CreateSourceCodeService(),
featureToggle ?? CreateFeatureToggle(),
buildProjectsRepository ?? CreateBuildProjectsRepository(),
calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate()));
}
public SourceCodeService(
ISourceFileRepository sourceFilesRepository,
ILogger logger,
ICalculationsRepository calculationsRepository,
ISourceFileGeneratorProvider sourceFileGeneratorProvider,
ICompilerFactory compilerFactory,
ICodeMetadataGeneratorService codeMetadataGenerator,
ICalcsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(sourceFilesRepository, nameof(sourceFilesRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(sourceFileGeneratorProvider, nameof(sourceFileGeneratorProvider));
Guard.ArgumentNotNull(compilerFactory, nameof(compilerFactory));
Guard.ArgumentNotNull(codeMetadataGenerator, nameof(codeMetadataGenerator));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies?.SourceFilesRepository, nameof(resiliencePolicies.SourceFilesRepository));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
_sourceFilesRepository = sourceFilesRepository;
_logger = logger;
_calculationsRepository = calculationsRepository;
_sourceFileGeneratorProvider = sourceFileGeneratorProvider;
_compilerFactory = compilerFactory;
_sourceFileGenerator = sourceFileGeneratorProvider.CreateSourceFileGenerator(TargetLanguage.VisualBasic);
_codeMetadataGenerator = codeMetadataGenerator;
_sourceFilesRepositoryPolicy = resiliencePolicies.SourceFilesRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
}
public CreateCalculationService(ICalculationNameInUseCheck calculationNameInUseCheck,
ICalculationsRepository calculationsRepository,
IVersionRepository <CalculationVersion> calculationVersionRepository,
ICalcsResiliencePolicies calculationsResiliencePolicies,
IValidator <CalculationCreateModel> calculationCreateModelValidator,
ICacheProvider cacheProvider,
ISearchRepository <CalculationIndex> searchRepository,
ILogger logger,
IInstructionAllocationJobCreation instructionAllocationJobCreation)
{
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(calculationNameInUseCheck, nameof(calculationNameInUseCheck));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(calculationVersionRepository, nameof(calculationVersionRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CacheProviderPolicy, nameof(calculationsResiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsVersionsRepositoryPolicy, nameof(calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy));
_calculationNameInUseCheck = calculationNameInUseCheck;
_calculationsRepository = calculationsRepository;
_calculationVersionRepository = calculationVersionRepository;
_logger = logger;
_instructionAllocationJobCreation = instructionAllocationJobCreation;
_searchRepository = searchRepository;
_cacheProvider = cacheProvider;
_calculationCreateModelValidator = calculationCreateModelValidator;
_calculationVersionsRepositoryPolicy = calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy;
_calculationRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository;
_cachePolicy = calculationsResiliencePolicies.CacheProviderPolicy;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public GraphRepository(IGraphApiClient graphApiClient,
ICalcsResiliencePolicies resiliencePolicies,
ICalculationsFeatureFlag calculationsFeatureFlag)
{
Guard.ArgumentNotNull(graphApiClient, nameof(graphApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.GraphApiClientPolicy, nameof(resiliencePolicies.GraphApiClientPolicy));
Guard.ArgumentNotNull(calculationsFeatureFlag, nameof(calculationsFeatureFlag));
_graphApiClient = graphApiClient;
_resilience = resiliencePolicies.GraphApiClientPolicy;
_calculationsFeatureFlag = calculationsFeatureFlag;
}
public ReIndexGraphRepository(IGraphApiClient graphApiClient,
ICalcsResiliencePolicies resiliencePolicies,
IMapper mapper,
ILogger logger)
{
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(graphApiClient, nameof(graphApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.GraphApiClientPolicy, nameof(resiliencePolicies.GraphApiClientPolicy));
Guard.ArgumentNotNull(logger, nameof(logger));
_graphApiClient = graphApiClient;
_logger = logger;
_mapper = mapper;
_resilience = resiliencePolicies.GraphApiClientPolicy;
}
public CalculationNameInUseCheck(ICalculationsRepository calculationsRepository,
ISpecificationsApiClient specificationsApiClient,
ICalcsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
_calculationsRepository = calculationsRepository;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsRepositoryPolicy;
_calculationRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public BuildProjectsService(
ILogger logger,
ITelemetry telemetry,
IProviderResultsRepository providerResultsRepository,
ISpecificationRepository specificationsRepository,
ICacheProvider cacheProvider,
ICalculationsRepository calculationsRepository,
IFeatureToggle featureToggle,
IJobsApiClient jobsApiClient,
ICalcsResiliencePolicies resiliencePolicies,
EngineSettings engineSettings,
ISourceCodeService sourceCodeService,
IDatasetRepository datasetRepository,
IBuildProjectsRepository buildProjectsRepository)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(providerResultsRepository, nameof(providerResultsRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(jobsApiClient, nameof(jobsApiClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(buildProjectsRepository, nameof(buildProjectsRepository));
_logger = logger;
_telemetry = telemetry;
_providerResultsRepository = providerResultsRepository;
_specificationsRepository = specificationsRepository;
_cacheProvider = cacheProvider;
_calculationsRepository = calculationsRepository;
_featureToggle = featureToggle;
_jobsApiClient = jobsApiClient;
_jobsApiClientPolicy = resiliencePolicies.JobsApiClient;
_engineSettings = engineSettings;
_sourceCodeService = sourceCodeService;
_datasetRepository = datasetRepository;
_datasetRepositoryPolicy = resiliencePolicies.DatasetsRepository;
_buildProjectsRepository = buildProjectsRepository;
_buildProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepositoryPolicy;
}
public InstructionAllocationJobCreation(ICalculationsRepository calculationsRepository,
ICalcsResiliencePolicies calculationsResiliencePolicies,
ILogger logger,
ICalculationsFeatureFlag calculationsFeatureFlag,
IJobManagement jobManagement)
{
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(calculationsFeatureFlag, nameof(calculationsFeatureFlag));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository));
_calculationsFeatureFlag = calculationsFeatureFlag;
_calculationsRepository = calculationsRepository;
_logger = logger;
_jobManagement = jobManagement;
_calculationRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository;
}
public CodeContextBuilder(IBuildProjectsService buildProjects,
ICalculationsRepository calculations,
ISourceCodeService compiler,
ICalcsResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(buildProjects, nameof(buildProjects));
Guard.ArgumentNotNull(calculations, nameof(calculations));
Guard.ArgumentNotNull(compiler, nameof(compiler));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
_buildProjects = buildProjects;
_calculations = calculations;
_calculationsResilience = resiliencePolicies.CalculationsRepository;
_compiler = compiler;
_logger = logger;
}
public CodeContextCache(ICacheProvider cache,
ICodeContextBuilder codeContextBuilder,
IJobManagement jobs,
ICalcsResiliencePolicies resiliencePolicies,
ILogger logger) : base(jobs, logger)
{
Guard.ArgumentNotNull(cache, nameof(cache));
Guard.ArgumentNotNull(codeContextBuilder, nameof(codeContextBuilder));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(jobs, nameof(jobs));
_cache = cache;
_codeContextBuilder = codeContextBuilder;
_cacheResilience = resiliencePolicies.CacheProviderPolicy;
_logger = logger;
_jobs = jobs;
}
private static SourceCodeService CreateSourceCodeService(
ISourceFileRepository sourceFilesRepository = null,
ILogger logger = null,
ICalculationsRepository calculationsRepository = null,
ISourceFileGeneratorProvider sourceFileGeneratorProvider = null,
ICompilerFactory compilerFactory = null,
ICodeMetadataGeneratorService codeMetadataGenerator = null,
ICalcsResiliencePolicies resiliencePolicies = null)
{
return(new SourceCodeService(
sourceFilesRepository ?? CreateSourceFileRepository(),
logger ?? CreateLogger(),
calculationsRepository ?? CreateCalculationsRepository(),
sourceFileGeneratorProvider ?? CreateSourceFileGeneratorProvider(),
compilerFactory ?? CreateCompilerFactory(),
codeMetadataGenerator ?? CreateCodeMetadataGeneratorService(),
resiliencePolicies ?? CreatePolicies()));
}
public ApplyTemplateCalculationsService(
ICreateCalculationService createCalculationService,
IPoliciesApiClient policiesApiClient,
ICalcsResiliencePolicies calculationsResiliencePolicies,
ICalculationsRepository calculationsRepository,
IJobManagement jobManagement,
IInstructionAllocationJobCreation instructionAllocationJobCreation,
ILogger logger,
ICalculationService calculationService,
ICacheProvider cacheProvider,
ISpecificationsApiClient specificationsApiClient,
IGraphRepository graphRepository,
ICodeContextCache codeContextCache) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(instructionAllocationJobCreation, nameof(instructionAllocationJobCreation));
Guard.ArgumentNotNull(createCalculationService, nameof(createCalculationService));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.PoliciesApiClient, nameof(calculationsResiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationService, nameof(calculationService));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CacheProviderPolicy, nameof(calculationsResiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(graphRepository, nameof(graphRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
_createCalculationService = createCalculationService;
_calculationsRepository = calculationsRepository;
_policiesApiClient = policiesApiClient;
_policiesResiliencePolicy = calculationsResiliencePolicies.PoliciesApiClient;
_calculationsRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository;
_logger = logger;
_instructionAllocationJobCreation = instructionAllocationJobCreation;
_calculationService = calculationService;
_cachePolicy = calculationsResiliencePolicies.CacheProviderPolicy;
_cacheProvider = cacheProvider;
_specificationsApiClient = specificationsApiClient;
_codeContextCache = codeContextCache;
_specificationsApiClientPolicy = calculationsResiliencePolicies.SpecificationsApiClient;
}
public PreviewService(
ILogger logger,
IBuildProjectsService buildProjectsService,
IValidator <PreviewRequest> previewRequestValidator,
ICalculationsRepository calculationsRepository,
IDatasetsApiClient datasetsApiClient,
ICacheProvider cacheProvider,
ISourceCodeService sourceCodeService,
ICalcsResiliencePolicies resiliencePolicies,
IMapper mapper,
ICalcEngineApiClient calcEngineApiClient)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(buildProjectsService, nameof(buildProjectsService));
Guard.ArgumentNotNull(previewRequestValidator, nameof(previewRequestValidator));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(resiliencePolicies.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies.CalcEngineApiClient, nameof(resiliencePolicies.CalcEngineApiClient));
Guard.ArgumentNotNull(calcEngineApiClient, nameof(calcEngineApiClient));
_logger = logger;
_buildProjectsService = buildProjectsService;
_previewRequestValidator = previewRequestValidator;
_calculationsRepository = calculationsRepository;
_datasetsApiClient = datasetsApiClient;
_cacheProvider = cacheProvider;
_sourceCodeService = sourceCodeService;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_mapper = mapper;
_calcEngineApiClient = calcEngineApiClient;
_calcEngineApiClientPolicy = resiliencePolicies.CalcEngineApiClient;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public DatasetDefinitionFieldChangesProcessor(
IFeatureToggle featureToggle,
IDatasetRepository datasetRepository,
ICalcsResiliencePolicies resiliencePolicies,
ILogger logger,
ICalculationService calculationService,
ICalculationsRepository calculationsRepository)
{
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationService, nameof(calculationService));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
_featureToggle = featureToggle;
_datasetRepository = datasetRepository;
_datasetRepositoryPolicy = resiliencePolicies.DatasetsRepository;
_logger = logger;
_calculationService = calculationService;
_calculationsRepository = calculationsRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
}
public CalculationFundingLineQueryService(IPoliciesApiClient templates,
ICalculationsRepository calculations,
ICacheProvider cache,
ISpecificationsApiClient specifications,
ICalcsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(templates, nameof(templates));
Guard.ArgumentNotNull(calculations, nameof(calculations));
Guard.ArgumentNotNull(cache, nameof(cache));
Guard.ArgumentNotNull(specifications, nameof(specifications));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(resiliencePolicies.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(resiliencePolicies.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
_templates = templates;
_calculations = calculations;
_cache = cache;
_specifications = specifications;
_policyResilience = resiliencePolicies.PoliciesApiClient;
_calculationsResilience = resiliencePolicies.CalculationsRepository;
_cacheResilience = resiliencePolicies.CacheProviderPolicy;
_specificationsResilience = resiliencePolicies.SpecificationsApiClient;
}
private static CalculationService CreateCalculationService(
ICalculationsRepository calculationsRepository = null,
ILogger logger = null,
ISearchRepository <CalculationIndex> searchRepository = null,
IBuildProjectsService buildProjectsService = null,
IPoliciesApiClient policiesApiClient = null,
ICacheProvider cacheProvider = null,
ICalcsResiliencePolicies resiliencePolicies = null,
IVersionRepository <CalculationVersion> calculationVersionRepository = null,
IJobManagement jobManagement = null,
ISourceCodeService sourceCodeService = null,
IFeatureToggle featureToggle = null,
IBuildProjectsRepository buildProjectsRepository = null,
ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = null,
IValidator <CalculationCreateModel> calculationCreateModelValidator = null,
IValidator <CalculationEditModel> calculationEditModelValidator = null,
ISpecificationsApiClient specificationsApiClient = null,
IGraphRepository graphRepository = null,
ICalculationsFeatureFlag calculationsFeatureFlag = null,
ICodeContextCache codeContextCache = null,
ISourceFileRepository sourceFileRepository = null,
IResultsApiClient resultsApiClient = null,
IDatasetsApiClient datasetsApiClient = null,
IApproveAllCalculationsJobAction approveAllCalculationsJobAction = null)
{
CalculationNameInUseCheck calculationNameInUseCheck = new CalculationNameInUseCheck(calculationsRepository ?? CreateCalculationsRepository(),
specificationsApiClient ?? CreateSpecificationsApiClient(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies());
InstructionAllocationJobCreation instructionAllocationJobCreation =
new InstructionAllocationJobCreation(
calculationsRepository ?? CreateCalculationsRepository(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
logger ?? CreateLogger(),
calculationsFeatureFlag ?? CreateCalculationsFeatureFlag(),
jobManagement ?? CreateJobManagement());
return(new CalculationService
(
calculationsRepository ?? CreateCalculationsRepository(),
logger ?? CreateLogger(),
searchRepository ?? CreateSearchRepository(),
buildProjectsService ?? CreateBuildProjectsService(),
policiesApiClient ?? CreatePoliciesApiClient(),
cacheProvider ?? CreateCacheProvider(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
sourceCodeService ?? CreateSourceCodeService(),
featureToggle ?? CreateFeatureToggle(),
buildProjectsRepository ?? CreateBuildProjectsRepository(),
calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate(),
calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
calculationEditModelValidator ?? CreateCalculationEditModelValidator(),
specificationsApiClient ?? CreateSpecificationsApiClient(),
calculationNameInUseCheck,
instructionAllocationJobCreation,
new CreateCalculationService(calculationNameInUseCheck,
calculationsRepository ?? CreateCalculationsRepository(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
cacheProvider ?? CreateCacheProvider(),
searchRepository ?? CreateSearchRepository(),
logger ?? CreateLogger(),
instructionAllocationJobCreation),
graphRepository ?? CreateGraphRepository(),
CreateJobManagement(),
codeContextCache ?? Substitute.For <ICodeContextCache>(),
resultsApiClient ?? Substitute.For <IResultsApiClient>(),
datasetsApiClient ?? Substitute.For <IDatasetsApiClient>(),
approveAllCalculationsJobAction ?? CreateApproveAllCalculationsJobAction()));
}
public BuildProjectsService(
ILogger logger,
ITelemetry telemetry,
IProvidersApiClient providersApiClient,
ICacheProvider cacheProvider,
ICalculationsRepository calculationsRepository,
IFeatureToggle featureToggle,
ICalcsResiliencePolicies resiliencePolicies,
EngineSettings engineSettings,
ISourceCodeService sourceCodeService,
IDatasetsApiClient datasetsApiClient,
IBuildProjectsRepository buildProjectsRepository,
ICalculationEngineRunningChecker calculationEngineRunningChecker,
IJobManagement jobManagement,
IGraphRepository graphRepository,
IMapper mapper,
ISpecificationsApiClient specificationsApiClient,
IPoliciesApiClient policiesApiClient,
ISourceFileRepository sourceFileRepository) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(buildProjectsRepository, nameof(buildProjectsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(calculationEngineRunningChecker, nameof(calculationEngineRunningChecker));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(graphRepository, nameof(graphRepository));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ProvidersApiClient, nameof(resiliencePolicies.ProvidersApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.BuildProjectRepositoryPolicy, nameof(resiliencePolicies.BuildProjectRepositoryPolicy));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(sourceFileRepository, nameof(sourceFileRepository));
_logger = logger;
_telemetry = telemetry;
_providersApiClient = providersApiClient;
_providersApiClientPolicy = resiliencePolicies.ProvidersApiClient;
_cacheProvider = cacheProvider;
_calculationsRepository = calculationsRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_featureToggle = featureToggle;
_engineSettings = engineSettings;
_sourceCodeService = sourceCodeService;
_datasetsApiClient = datasetsApiClient;
_jobManagement = jobManagement;
_graphRepository = graphRepository;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_buildProjectsRepository = buildProjectsRepository;
_buildProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepositoryPolicy;
_calculationEngineRunningChecker = calculationEngineRunningChecker;
_mapper = mapper;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_policiesApiClient = policiesApiClient;
_policiesApiClientPolicy = resiliencePolicies.PoliciesApiClient;
_sourceFileRepository = sourceFileRepository;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public CalculationCreateModelValidator(
ICalculationsRepository calculationRepository,
IPreviewService previewService,
ISpecificationsApiClient specificationsApiClient,
ICalcsResiliencePolicies calcsResiliencePolicies)
{
Guard.ArgumentNotNull(calculationRepository, nameof(calculationRepository));
Guard.ArgumentNotNull(previewService, nameof(previewService));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(calcsResiliencePolicies, nameof(calcsResiliencePolicies));
Guard.ArgumentNotNull(calcsResiliencePolicies?.SpecificationsApiClient, nameof(calcsResiliencePolicies.SpecificationsApiClient));
_calculationRepository = calculationRepository;
_previewService = previewService;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = calcsResiliencePolicies.SpecificationsApiClient;
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(model => model.SpecificationId)
.NotEmpty()
.NotNull()
.WithMessage("Null or empty specification id provided.");
RuleFor(model => model.ValueType)
.NotNull()
.WithMessage("Null value type was provided.");
RuleFor(model => model.Name)
.Custom((name, context) =>
{
CalculationCreateModel calculationCreateModel = context.ParentContext.InstanceToValidate as CalculationCreateModel;
if (string.IsNullOrWhiteSpace(calculationCreateModel.Name))
{
context.AddFailure("Null or empty calculation name provided.");
}
else
{
if (!string.IsNullOrWhiteSpace(calculationCreateModel.SpecificationId))
{
Calculation calculation = _calculationRepository.GetCalculationsBySpecificationIdAndCalculationName(calculationCreateModel.SpecificationId, calculationCreateModel.Name).Result;
if (calculation != null)
{
context.AddFailure($"A calculation already exists with the name: '{calculationCreateModel.Name}' for this specification");
}
}
}
});
RuleFor(model => model.SourceCode)
.Custom((sc, context) =>
{
CalculationCreateModel calculationCreateModel = context.ParentContext.InstanceToValidate as CalculationCreateModel;
if (string.IsNullOrWhiteSpace(calculationCreateModel.SourceCode))
{
context.AddFailure("Null or empty source code provided.");
}
else
{
if (calculationCreateModel.CalculationType == CalculationType.Additional)
{
PreviewRequest previewRequest = new PreviewRequest
{
SpecificationId = calculationCreateModel.SpecificationId,
CalculationId = calculationCreateModel.Id,
Name = calculationCreateModel.Name,
SourceCode = calculationCreateModel.SourceCode
};
IActionResult result = _previewService.Compile(previewRequest).Result;
OkObjectResult okObjectResult = result as OkObjectResult;
PreviewResponse response = okObjectResult.Value as PreviewResponse;
if (response != null)
{
if (!response.CompilerOutput.CompilerMessages.IsNullOrEmpty())
{
context.AddFailure("There are errors in the source code provided");
}
}
}
}
});
RuleFor(model => model.FundingStreamId)
.Custom((fs, context) =>
{
CalculationCreateModel calculationCreateModel = context.ParentContext.InstanceToValidate as CalculationCreateModel;
//only validate funding stream id for template calcs
var isTemplateCalculation = calculationCreateModel.CalculationType == CalculationType.Template;
if (isTemplateCalculation &&
string.IsNullOrWhiteSpace(calculationCreateModel.FundingStreamId))
{
context.AddFailure("Null or empty funding stream id provided.");
}
else
{
ApiResponse <SpecModel.SpecificationSummary> specificationApiResponse = _specificationsApiClientPolicy.ExecuteAsync(() => _specificationsApiClient.GetSpecificationSummaryById(calculationCreateModel.SpecificationId)).GetAwaiter().GetResult();
if (specificationApiResponse == null || !specificationApiResponse.StatusCode.IsSuccess() || specificationApiResponse.Content == null)
{
context.AddFailure("Failed to find specification for provided specification id.");
}
else
{
SpecModel.SpecificationSummary specificationSummary = specificationApiResponse.Content;
//I don't want to have to fetch the spec summary again outside of this method to get the name and funding stream so we set them on input model here
calculationCreateModel.SpecificationName = specificationSummary.Name;
//only validate funding stream ids for template calcs
if (!isTemplateCalculation)
{
return;
}
Reference fundingStream = specificationSummary.FundingStreams.FirstOrDefault(m => m.Id == calculationCreateModel.FundingStreamId);
if (fundingStream == null)
{
context.AddFailure("The funding stream id provided is not associated with the provided specification.");
}
else
{
calculationCreateModel.FundingStreamName = fundingStream.Name;
}
}
}
});
}
