public PkmlFileFromFolderRunner(IMoBiContext context, IBatchLogger logger, ISimulationBatchRunner simulationBatchRunner, IProjectTask projectTask)
{
_context = context;
_logger = logger;
_simulationBatchRunner = simulationBatchRunner;
_projectTask = projectTask;
}
public ProjectFromFolderRunner(IBatchLogger logger, ISerializationTask serializationTask, IMoBiContext context, ISimulationBatchRunner simulationBatchRunner)
{
_logger = logger;
_serializationTask = serializationTask;
_context = context;
_simulationBatchRunner = simulationBatchRunner;
}
public ProjectOverviewRunner(IBatchLogger logger, IWorkspacePersistor workspacePersistor, IWorkspace workspace,
ILazyLoadTask lazyLoadTask)
{
_logger = logger;
_workspacePersistor = workspacePersistor;
_workspace = workspace;
_lazyLoadTask = lazyLoadTask;
}
public IndividualMapper(IIndividualFactory individualFactory, IOriginDataMapper originDataMapper,
IIndividualMoleculeFactoryResolver moleculeFactoryResolver, IBatchLogger batchLogger)
{
_individualFactory = individualFactory;
_originDataMapper = originDataMapper;
_moleculeFactoryResolver = moleculeFactoryResolver;
_batchLogger = batchLogger;
}
public SimulationConstructor(ISimulationFactory simulationFactory, ISimulationBuildingBlockUpdater buildingBlockUpdater,
ISimulationModelCreator simulationModelCreator, IRegistrationTask registrationTask, IBatchLogger batchLogger)
{
_simulationFactory = simulationFactory;
_buildingBlockUpdater = buildingBlockUpdater;
_simulationModelCreator = simulationModelCreator;
_registrationTask = registrationTask;
_batchLogger = batchLogger;
}
public SimulationExporter(ISimulationEngineFactory simulationEngineFactory, IBatchLogger logger, IParametersReportCreator parametersReportCreator,
ISimulationResultsExporter simulationResultsExporter, ISimulationExportTask simulationExportTask)
{
_simulationEngineFactory = simulationEngineFactory;
_logger = logger;
_parametersReportCreator = parametersReportCreator;
_simulationResultsExporter = simulationResultsExporter;
_simulationExportTask = simulationExportTask;
}
public SimulationBatchRunner(IBatchLogger logger, IModelConstructor modelConstructor, IBuildConfigurationFactory buildConfigurationFactory,
IMoBiContext context, ISimModelManager simModelManager)
{
_logger = logger;
_modelConstructor = modelConstructor;
_buildConfigurationFactory = buildConfigurationFactory;
_context = context;
_simModelManager = simModelManager;
}
protected BatchPresenter(TView view, TBatchRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger)
: base(view)
{
_batchRunner = batchRunner;
_dialogCreator = dialogCreator;
_logPresenter = logPresenter;
_batchLogger = batchLogger;
_view.AddLogView(_logPresenter.View);
}
protected AbstractBatchPresenter(TView view, ILogPresenter logPresenter, IDialogCreator dialogCreator, IBatchLogger batchLogger) : base(view)
{
_logPresenter = logPresenter;
_dialogCreator = dialogCreator;
_batchLogger = batchLogger;
_startedFromCommandLine = false;
_isRunning = false;
_view.AddLogView(logPresenter.View);
}
public JsonSimulationRunner(ISimulationLoader simulationLoader, ISimulationExporter simulationExporter, IBatchLogger logger,
IEntitiesInContainerRetriever entitiesInContainerRetriever, IExecutionContext executionContext, ICommandTask commandTask)
{
_simulationLoader = simulationLoader;
_simulationExporter = simulationExporter;
_logger = logger;
_entitiesInContainerRetriever = entitiesInContainerRetriever;
_executionContext = executionContext;
_commandTask = commandTask;
}
public SimulationMapper(ICompoundMapper compoundMapper, IIndividualMapper individualMapper,
IApplicationProtocolMapper protocolMapper, ISimulationConstructor simulationConstructor,
IModelPropertiesMapper modelPropertiesMapper, IFormulationMapper formulationMapper, IBatchLogger logger)
{
_compoundMapper = compoundMapper;
_individualMapper = individualMapper;
_protocolMapper = protocolMapper;
_simulationConstructor = simulationConstructor;
_modelPropertiesMapper = modelPropertiesMapper;
_formulationMapper = formulationMapper;
_logger = logger;
}
public CompoundMapper(ICompoundFactory compoundFactory, ICompoundProcessRepository compoundProcessRepository,
IBatchLogger batchLogger, ICloner cloner,
ICompoundCalculationMethodCategoryRepository calculationMethodCategoryRepository,
ICalculationMethodRepository calculationMethodRepository, ICompoundProcessTask compoundProcessTask, ISpeciesRepository speciesRepository)
{
_compoundFactory = compoundFactory;
_compoundProcessRepository = compoundProcessRepository;
_batchLogger = batchLogger;
_cloner = cloner;
_calculationMethodCategoryRepository = calculationMethodCategoryRepository;
_calculationMethodRepository = calculationMethodRepository;
_compoundProcessTask = compoundProcessTask;
_speciesRepository = speciesRepository;
}
public ProjectComparisonRunner(IWorkspacePersistor workspacePersistor, IWorkspace workspace,
ILazyLoadTask lazyLoadTask, IBatchLogger logger, ISimulationEngineFactory simulationEngineFactory, ISimulationExportTask simulationExportTask,
IMoBiExportTask moBiExportTask, ISimulationFactory simulationFactory, IExecutionContext executionContext, ISimulationModelCreator simulationModelCreator)
{
_workspacePersistor = workspacePersistor;
_workspace = workspace;
_lazyLoadTask = lazyLoadTask;
_logger = logger;
_simulationExportTask = simulationExportTask;
_moBiExportTask = moBiExportTask;
_simulationFactory = simulationFactory;
_executionContext = executionContext;
_simulationModelCreator = simulationModelCreator;
_simulationEngine = simulationEngineFactory.Create <IndividualSimulation>();
}
public TrainingMaterialTask(IBuildingBlockTask buildingBlockTask, IWorkspace workspace, IBatchLogger logger, IBatchToCoreMapper mapper,
ISimulationEngineFactory simulationEngineFactory, ISimulationConstructor simulationConstructor, ISimulationSettingsRetriever simulationSettingsRetriever,
IObservedDataTask observedDataTask, IProjectTask projectTask, IParameterAlternativeFactory parameterAlternativeFactory,
ICompoundAlternativeTask compoundAlternativeTask, ITrainingObservedDataRepository observedDataRepository)
{
_buildingBlockTask = buildingBlockTask;
_workspace = workspace;
_logger = logger;
_mapper = mapper;
_simulationEngineFactory = simulationEngineFactory;
_simulationConstructor = simulationConstructor;
_simulationSettingsRetriever = simulationSettingsRetriever;
_observedDataTask = observedDataTask;
_projectTask = projectTask;
_parameterAlternativeFactory = parameterAlternativeFactory;
_compoundAlternativeTask = compoundAlternativeTask;
_observedDataRepository = observedDataRepository;
}
protected override void Context()
{
_simulationEngineFactory = A.Fake <ISimulationEngineFactory>();
_logger = A.Fake <IBatchLogger>();
_parameterReportCreator = A.Fake <IParametersReportCreator>();
_simulationResultsExporter = A.Fake <ISimulationResultsExporter>();
_simulationExportTask = A.Fake <ISimulationExportTask>();
sut = new SimulationExporter(_simulationEngineFactory, _logger, _parameterReportCreator, _simulationResultsExporter, _simulationExportTask);
_simulation = new IndividualSimulation {
DataRepository = new DataRepository("Rep")
};
_outputFolder = "OutputFolder";
_exportName = "ExportName";
_configuration = new SimulationConfiguration();
_simulationEngine = A.Fake <ISimulationEngine <IndividualSimulation> >();
A.CallTo(() => _simulationEngineFactory.Create <IndividualSimulation>()).Returns(_simulationEngine);
}
static void Main(string[] args)
{
ILogger logger = LoggerService.GetLogger();
logger.Info("Simple logger: Info message");
logger.Warn("Simple logger: Warn message");
logger.Error("Simple logger: Error message");
logger.Debug("Simple logger: Debug message");
logger.Fatal("Simple logger: Fatal message");
Console.WriteLine("************************");
IBatchLogger batchLogger = LoggerService.GetBatchLogger();
batchLogger.Info("Batch logger: Info message");
batchLogger.Warn("Batch logger: Warn message");
batchLogger.Error("Batch logger: Error message");
batchLogger.Debug("Batch logger: Debug message");
batchLogger.Fatal("Batch logger: Fatal message");
batchLogger.Flush();
Console.WriteLine("************************");
}
public BatchLoggerDisposer(IBatchLogger batchLogger, string logFilePath, NotificationType notificationType)
{
_streamWriter = new StreamWriter(logFilePath, append: false);
batchLogger.InitializeWith(_streamWriter, notificationType);
}
public ProjectOverviewRunner(IBatchLogger logger, IContextPersistor contextPersistor, IMoBiContext context)
{
_logger = logger;
_contextPersistor = contextPersistor;
_context = context;
}
protected FileFromFolderPresenter(IFileFromFolderRunnerView view, ILogPresenter logPresenter, IDialogCreator dialogCreator, IBatchLogger batchLogger) : base(view, logPresenter, dialogCreator, batchLogger)
{
_dto = new FileFromFolderDTO();
_view.BindTo(_dto);
}
public GenerateProjectOverviewPresenter(IGenerateProjectOverviewView view, ProjectOverviewRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger) : base(view, batchRunner, dialogCreator, logPresenter, batchLogger)
{
}
public InputAndOutputBatchPresenter(IInputAndOutputBatchView view, TBatchRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger)
: base(view, batchRunner, dialogCreator, logPresenter, batchLogger)
{
}
public JsonSimulationBatchPresenter(IInputAndOutputBatchView view, JsonSimulationRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger) :
base(view, batchRunner, dialogCreator, logPresenter, batchLogger)
{
view.Caption = "PK-Sim BatchTool: Batch runner for json based PK-Sim simulations";
}
public ModelPropertiesMapper(IModelPropertiesTask modelPropertiesTask, IBatchLogger batchLogger)
{
_modelPropertiesTask = modelPropertiesTask;
_batchLogger = batchLogger;
}
public ProjectComparisonPresenter(IInputAndOutputBatchView view, ProjectComparisonRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger)
: base(view, batchRunner, dialogCreator, logPresenter, batchLogger)
{
view.Caption = "PK-Sim BatchTool: Comparison of simulation results in existing projects";
}
public ApplicationProtocolMapper(IProtocolFactory protocolFactory, IBatchLogger logger)
{
_protocolFactory = protocolFactory;
_logger = logger;
}
public GenerateTrainingMaterialPresenter(IGenerateTrainingMaterialView view, TrainingMaterialRunner batchRunner, IDialogCreator dialogCreator, ILogPresenter logPresenter, IBatchLogger batchLogger)
: base(view, batchRunner, dialogCreator, logPresenter, batchLogger)
{
}
public ProjectFromFolderPresenter(IFileFromFolderRunnerView view, IDialogCreator dialogCreator,
ILogPresenter logPresenter, IBatchLogger batchLogger, ProjectFromFolderRunner runner) : base(view, logPresenter, dialogCreator, batchLogger)
{
_runner = runner;
_view.Caption = "MoBi Project Files Runner";
}
public TrainingMaterialRunner(IBatchLogger logger, IRepository <ITrainingMaterialExercise> trainingMaterialExercises)
{
_logger = logger;
_trainingMaterialExercises = trainingMaterialExercises.All().ToList();
}
public FormulationMapper(IFormulationRepository formulationRepository, ICloner cloner, IBatchLogger batchLogger)
{
_formulationRepository = formulationRepository;
_cloner = cloner;
_batchLogger = batchLogger;
}
