public ExecuteCommandAddPackageToConfiguration(IActivateItems activator, ExtractionConfiguration extractionConfiguration) : base(activator)
{
this._extractionConfiguration = extractionConfiguration;
if (extractionConfiguration.IsReleased)
{
SetImpossible("Extraction is Frozen because it has been released and is readonly, try cloning it instead");
}
if (activator.CoreChildProvider is DataExportChildProvider childProvider)
{
if (childProvider.AllPackages.Any())
{
_packages = childProvider.AllPackages;
}
else
{
SetImpossible("There are no ExtractableDatasetPackages configured");
}
}
else
{
SetImpossible("CoreChildProvider is not DataExportIconProvider");
}
}
private void SetupDataExport()
{
_extractableDataSet = new ExtractableDataSet(DataExportRepository, _catalogue);
_project = new Project(DataExportRepository, _testDatabaseName);
_project.ProjectNumber = 1;
Directory.CreateDirectory(ProjectDirectory);
_project.ExtractionDirectory = ProjectDirectory;
_project.SaveToDatabase();
_configuration = new ExtractionConfiguration(DataExportRepository, _project);
//select the dataset for extraction under this configuration
_selectedDataSet = new SelectedDataSets(RepositoryLocator.DataExportRepository, _configuration, _extractableDataSet, null);
//select all the columns for extraction
foreach (var toSelect in _extractionInformations)
{
var col = new ExtractableColumn(DataExportRepository, _extractableDataSet, _configuration, toSelect, toSelect.Order, toSelect.SelectSQL);
if (col.GetRuntimeName().Equals("PrivateID"))
{
col.IsExtractionIdentifier = true;
}
col.SaveToDatabase();
_extractableColumns.Add(col);
}
}
/// <inheritdoc cref="GlobalExtractionChecker(IBasicActivateItems,ExtractionConfiguration)"/>
public GlobalExtractionChecker(IBasicActivateItems activator, ExtractionConfiguration configuration, ExtractGlobalsCommand command, IPipeline alsoCheckPipeline)
{
this._configuration = configuration;
this._command = command;
this._alsoCheckPipeline = alsoCheckPipeline;
_activator = activator;
}
public string GetAccountExtractionConfiguration(HttpListenerContext ct, ActionInfo hi)
{
ExtractionConfiguration Ec = new ExtractionConfiguration();
Ec.DefaultDocumentSpecification = "Stuff";
Ec.OrientationDetectionMode = OrientationDetectionMode.Off;
DocumentType dt = new DocumentType();
dt.Country = "SE";
dt.DisplayName = "PDF";
dt.ExtractionName = "Thefil.pdf";
FieldGroup Fg = new FieldGroup();
Fg.IsTableGroup = true;
Fg.Name = "My Group";
Fg.Order = 23;
dt.FieldGroups.Add(Fg);
DocumentTypeField dtf = new DocumentTypeField();
dtf.FormatType = FormatType.RegularExpression;
ExtractionType et = new ExtractionType();
dtf.ExtractionType = et;
dt.Fields.Add(dtf);
dt.InternalName = "hejsan";
dt.SystemName = "Thesystemname";
dt.IsSelected = true;
Ec.SelectedDocumentTypes.Add(dt);
return(GetResponseString <ExtractionConfiguration>(Ec, ct));
}
public override void Execute()
{
base.Execute();
if (_project != null && _extractionConfiguration == null)
{
var available = _project.ExtractionConfigurations.Where(c => c.IsExtractable(out _)).Cast <ExtractionConfiguration>().ToArray();
if (available.Any())
{
_extractionConfiguration = SelectOne(available);
}
if (_extractionConfiguration == null)
{
return;
}
}
var ui = Activator.Activate <ExecuteExtractionUI, ExtractionConfiguration>(_extractionConfiguration);
if (_selectedDataSet != null)
{
ui.TickAllFor(_selectedDataSet);
}
}
public void CloneWithExtractionProgress()
{
var sds = _configuration.SelectedDataSets[0];
var ci = sds.GetCatalogue().CatalogueItems.First();
var origProgress = new ExtractionProgress(DataExportRepository, sds, null, DateTime.Now, 10, "fff drrr", ci.ID);
origProgress.ProgressDate = new DateTime(2001, 01, 01);
origProgress.SaveToDatabase();
ExtractionConfiguration deepClone = _configuration.DeepCloneWithNewIDs();
Assert.AreEqual(deepClone.Cohort_ID, _configuration.Cohort_ID);
Assert.AreNotEqual(deepClone.ID, _configuration.ID);
var clonedSds = deepClone.SelectedDataSets.Single(s => s.ExtractableDataSet_ID == sds.ExtractableDataSet_ID);
var clonedProgress = clonedSds.ExtractionProgressIfAny;
Assert.IsNotNull(clonedProgress);
Assert.IsNull(clonedProgress.StartDate);
Assert.IsNull(clonedProgress.ProgressDate, "Cloning a ExtractionProgress should reset its ProgressDate back to null in anticipation of it being extracted again");
Assert.AreEqual(clonedProgress.EndDate, origProgress.EndDate);
Assert.AreEqual(clonedProgress.NumberOfDaysPerBatch, origProgress.NumberOfDaysPerBatch);
Assert.AreEqual(clonedProgress.Name, origProgress.Name);
Assert.AreEqual(clonedProgress.ExtractionInformation_ID, origProgress.ExtractionInformation_ID);
deepClone.DeleteInDatabase();
// remove the progress so that it doesn't trip other tests
origProgress.DeleteInDatabase();
}
public ExecuteCommandAddDatasetsToConfiguration(IBasicActivateItems itemActivator, ExtractionConfiguration targetExtractionConfiguration) : base(itemActivator)
{
_targetExtractionConfiguration = targetExtractionConfiguration;
if (_targetExtractionConfiguration.IsReleased)
{
SetImpossible("Extraction is Frozen because it has been released and is readonly, try cloning it instead");
}
//if we don't yet know what datasets to add (i.e. haven't called SetExtractableDataSets)
if (_toadd == null)
{
if (itemActivator.CoreChildProvider is DataExportChildProvider childProvider)
{
//use the ones that are not already in the ExtractionConfiguration
var _datasets = childProvider.GetDatasets(targetExtractionConfiguration).Select(n => n.ExtractableDataSet).ToArray();
var _importableDataSets = childProvider.ExtractableDataSets.Except(_datasets)
//where it can be used in any Project OR this project only
.Where(ds => ds.Project_ID == null || ds.Project_ID == targetExtractionConfiguration.Project_ID).ToArray();
SetExtractableDataSets(true, _importableDataSets);
}
else
{
SetImpossible("CoreChildProvider was not DataExportChildProvider");
}
}
}
public ExtractionConfigurationMenu(RDMPContextMenuStripArgs args, ExtractionConfiguration extractionConfiguration)
: base(args, extractionConfiguration)
{
Items.Add("Edit", null, (s, e) => _activator.Activate <ExtractionConfigurationUI, ExtractionConfiguration>(extractionConfiguration));
///////////////////Change Cohorts//////////////
Add(new ExecuteCommandRelease(_activator).SetTarget(extractionConfiguration));
Add(new ExecuteCommandChooseCohort(_activator, extractionConfiguration));
/////////////////Add Datasets/////////////
Add(new ExecuteCommandAddDatasetsToConfiguration(_activator, extractionConfiguration));
Add(new ExecuteCommandAddPackageToConfiguration(_activator, extractionConfiguration));
Add(new ExecuteCommandGenerateReleaseDocument(_activator, extractionConfiguration));
if (extractionConfiguration.IsReleased)
{
Add(new ExecuteCommandUnfreezeExtractionConfiguration(_activator, extractionConfiguration));
}
else
{
Add(new ExecuteCommandFreezeExtractionConfiguration(_activator, extractionConfiguration));
}
Add(new ExecuteCommandCloneExtractionConfiguration(_activator, extractionConfiguration));
Add(new ExecuteCommandRefreshExtractionConfigurationsCohort(_activator, extractionConfiguration));
ReBrandActivateAs("Extract...", RDMPConcept.ExtractionConfiguration, OverlayKind.Execute);
}
private void dataGridView1_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
//note that this only deals with clicking cells, to see what happens hwen user clicks in blank area of datagrid see dataGridView1_MouseClick
if (e.RowIndex >= 0)
{
if (e.Button == System.Windows.Forms.MouseButtons.Right)
{
menu.Items.Clear();
_rightClickedRowExtractionConfigurationID = int.Parse(dataGridView1.Rows[e.RowIndex].Cells["ID"].Value.ToString());
ExtractionConfiguration selectedExtractionConfiguration = Activator.RepositoryLocator.DataExportRepository.GetObjectByID <ExtractionConfiguration>(_rightClickedRowExtractionConfigurationID);
menu.Items.Clear();
if (!selectedExtractionConfiguration.IsReleased)
{
menu.Items.Add(mi_SetDescription);
}
menu.Show(Cursor.Position.X, Cursor.Position.Y);
}
}
}
private void AddChildren(ExtractionConfiguration extractionConfiguration, DescendancyList descendancy)
{
HashSet <object> children = new HashSet <object>();
var parameters = AllGlobalExtractionFilterParameters.Where(p => p.ExtractionConfiguration_ID == extractionConfiguration.ID)
.ToArray();
if (parameters.Any())
{
var parameterNode = new ParametersNode(extractionConfiguration, parameters);
children.Add(parameterNode);
}
//if it has a cohort
if (extractionConfiguration.Cohort_ID != null)
{
var cohort = Cohorts.Single(c => c.ID == extractionConfiguration.Cohort_ID);
children.Add(new LinkedCohortNode(extractionConfiguration, cohort));
}
//if it has extractable datasets add those
foreach (SelectedDataSets ds in GetDatasets(extractionConfiguration))
{
children.Add(ds);
AddChildren(ds, descendancy.Add(ds));
}
AddToDictionaries(children, descendancy);
}
public ExecuteCommandGenerateReleaseDocument(IBasicActivateItems activator, ExtractionConfiguration extractionConfiguration) : base(activator)
{
_extractionConfiguration = extractionConfiguration;
/////////////////Other stuff///////////
if (!extractionConfiguration.CumulativeExtractionResults.Any())
{
SetImpossible("No datasets have been extracted");
}
if (_extractionConfiguration.Cohort_ID == null)
{
SetImpossible("ExtractionConfiguration does not have a cohort");
}
else
{
try
{
// try to fetch the cohort (give it 2 seconds maximum).
// we don't want to freeze waiting for context menu to pop up on this
var eds = _extractionConfiguration.Cohort.GetExternalData(2);
if (eds == ExternalCohortDefinitionData.Orphan)
{
SetImpossible("Cohort did not exist");
}
}
catch (Exception)
{
SetImpossible("Cohort was unreachable");
}
}
}
/// <summary>
/// For refreshing the current extraction configuration CohortIdentificationConfiguration ONLY. The ExtractionConfiguration must have a cic and a refresh pipeline configured on it.
/// </summary>
/// <param name="configuration"></param>
public CohortCreationRequest(ExtractionConfiguration configuration)
{
_repository = (DataExportRepository)configuration.Repository;
if (configuration.CohortIdentificationConfiguration_ID == null)
{
throw new NotSupportedException("Configuration '" + configuration + "' does not have an associated CohortIdentificationConfiguration for cohort refreshing");
}
var origCohort = configuration.Cohort;
var origCohortData = origCohort.GetExternalData();
CohortIdentificationConfiguration = configuration.CohortIdentificationConfiguration;
Project = configuration.Project;
if (Project.ProjectNumber == null)
{
throw new ProjectNumberException("Project '" + Project + "' does not have a ProjectNumber");
}
var definition = new CohortDefinition(null, origCohortData.ExternalDescription, origCohortData.ExternalVersion + 1, (int)Project.ProjectNumber, origCohort.ExternalCohortTable);
definition.CohortReplacedIfAny = origCohort;
NewCohortDefinition = definition;
DescriptionForAuditLog = "Cohort Refresh";
AddInitializationObject(Project);
AddInitializationObject(CohortIdentificationConfiguration);
AddInitializationObject(FileToLoad);
AddInitializationObject(ExtractionIdentifierColumn);
AddInitializationObject(this);
GenerateContext();
}
protected override void SetBindings(BinderWithErrorProviderFactory rules, ExtractionConfiguration databaseObject)
{
base.SetBindings(rules, databaseObject);
Bind(tbUsername, "Text", "Username", c => c.Username);
Bind(tbID, "Text", "ID", c => c.ID);
Bind(tbDescription, "Text", "Description", c => c.Description);
}
private static ExtractionOptions GetRunCommand(ExtractionConfiguration ec)
{
return(new ExtractionOptions()
{
ExtractionConfiguration = ec.ID,
ExtractGlobals = true,
});
}
public IEnumerable <SelectedDataSets> GetDatasets(ExtractionConfiguration extractionConfiguration)
{
lock (WriteLock)
{
return(_configurationToDatasetMapping.TryGetValue(extractionConfiguration, out List <SelectedDataSets> result)?
(IEnumerable <SelectedDataSets>)result :new SelectedDataSets[0]);
}
}
private Project GetProjectWithConfig(out ExtractionConfiguration config)
{
var p = new Project(DataExportRepository, "Fish");
p.ProjectNumber = -5000;
config = new ExtractionConfiguration(DataExportRepository, p);
return(p);
}
public IEnumerable <SelectedDataSets> GetDatasets(ExtractionConfiguration extractionConfiguration)
{
if (_configurationToDatasetMapping.ContainsKey(extractionConfiguration))
{
return(_configurationToDatasetMapping[extractionConfiguration]);
}
return(new SelectedDataSets[0]);
}
private ExecuteCommandAddDatasetsToConfiguration(IActivateItems itemActivator, ExtractionConfiguration targetExtractionConfiguration) : base(itemActivator)
{
_targetExtractionConfiguration = targetExtractionConfiguration;
if (_targetExtractionConfiguration.IsReleased)
{
SetImpossible("Extraction is Frozen because it has been released and is readonly, try cloning it instead");
}
}
public ExecuteCommandFreezeExtractionConfiguration(IBasicActivateItems activator, ExtractionConfiguration extractionConfiguration) : base(activator)
{
_extractionConfiguration = extractionConfiguration;
if (extractionConfiguration.IsReleased)
{
SetImpossible("ExtractionConfiguration is already released)");
}
}
public ExecuteCommandGenerateReleaseDocument(IActivateItems activator, ExtractionConfiguration extractionConfiguration) : base(activator)
{
_extractionConfiguration = extractionConfiguration;
/////////////////Other stuff///////////
if (!extractionConfiguration.CumulativeExtractionResults.Any())
{
SetImpossible("No datasets have been extracted");
}
}
public ExecuteCommandCloneExtractionConfiguration(IActivateItems activator, ExtractionConfiguration extractionConfiguration) : base(activator)
{
_extractionConfiguration = extractionConfiguration;
if (!_extractionConfiguration.SelectedDataSets.Any())
{
SetImpossible("ExtractionConfiguration does not have any selected datasets");
}
}
public ExecuteCommandUnfreezeExtractionConfiguration(IActivateItems activator, ExtractionConfiguration configuration) : base(activator)
{
_configuration = configuration;
if (!_configuration.IsReleased)
{
SetImpossible("Extraction Configuration is not Frozen");
}
}
public override void Execute()
{
base.Execute();
var newConfig = new ExtractionConfiguration(Activator.RepositoryLocator.DataExportRepository, _project);
//refresh the project
Publish(_project);
Activate(newConfig);
}
protected override void Initialize()
{
_configuration = RepositoryLocator.DataExportRepository.GetObjectByID <ExtractionConfiguration>(_options.ExtractionConfiguration);
_project = _configuration.Project;
_pipeline = RepositoryLocator.CatalogueRepository.GetObjectByID <Pipeline>(_options.Pipeline);
if (HasConfigurationPreviouslyBeenReleased())
{
throw new Exception("Extraction Configuration has already been released");
}
}
public ExtractionConfigurationMenu(RDMPContextMenuStripArgs args, ExtractionConfiguration extractionConfiguration)
: base(args, extractionConfiguration)
{
_extractionConfiguration = extractionConfiguration;
_childProvider = (DataExportChildProvider)_activator.CoreChildProvider;
_datasets = _childProvider.GetDatasets(extractionConfiguration).Select(n => n.ExtractableDataSet).ToArray();
Items.Add("Edit", null, (s, e) => _activator.Activate <ExtractionConfigurationUI, ExtractionConfiguration>(extractionConfiguration));
_importableDataSets = _childProvider.ExtractableDataSets.Except(_datasets).Where(ds => ds.Project_ID == null || ds.Project_ID == extractionConfiguration.Project_ID).ToArray();
///////////////////Change Cohorts//////////////
Add(new ExecuteCommandRelease(_activator).SetTarget(extractionConfiguration));
Add(new ExecuteCommandChooseCohort(_activator, extractionConfiguration));
/////////////////Add Datasets/////////////
var addDataSets = new ToolStripMenuItem("Add DataSet(s)", _activator.CoreIconProvider.GetImage(RDMPConcept.ExtractableDataSet, OverlayKind.Link), (s, e) => AddDatasetsToConfiguration());
addDataSets.Enabled = !extractionConfiguration.IsReleased && _importableDataSets.Any();//not frozen and must be at least 1 dataset that is not in the configuration!
Items.Add(addDataSets);
if (_childProvider.AllPackages.Any())
{
var addPackageMenuItem = new ToolStripMenuItem("Add DataSet Package", _activator.CoreIconProvider.GetImage(RDMPConcept.ExtractableDataSetPackage));
foreach (ExtractableDataSetPackage package in _childProvider.AllPackages)
{
ExtractableDataSetPackage package1 = package;
addPackageMenuItem.DropDownItems.Add(package.Name, null, (s, e) => AddPackageToConfiguration(package1));
}
addPackageMenuItem.Enabled = !extractionConfiguration.IsReleased && _importableDataSets.Any();//not frozen and must be at least 1 dataset that is not in the configuration!
Items.Add(addPackageMenuItem);
}
Add(new ExecuteCommandGenerateReleaseDocument(_activator, extractionConfiguration));
var freeze = new ToolStripMenuItem("Freeze Extraction", CatalogueIcons.FrozenExtractionConfiguration, (s, e) => Freeze());
freeze.Enabled = !extractionConfiguration.IsReleased && _datasets.Any();
Items.Add(freeze);
if (extractionConfiguration.IsReleased)
{
Add(new ExecuteCommandUnfreezeExtractionConfiguration(_activator, extractionConfiguration));
}
Add(new ExecuteCommandCloneExtractionConfiguration(_activator, extractionConfiguration));
Add(new ExecuteCommandRefreshExtractionConfigurationsCohort(_activator, extractionConfiguration));
ReBrandActivateAs("Extract...", RDMPConcept.ExtractionConfiguration, OverlayKind.Execute);
}
public ExtractionConfigurationMenu(RDMPContextMenuStripArgs args, ExtractionConfiguration extractionConfiguration)
: base(args, extractionConfiguration)
{
Items.Add("Edit", null, (s, e) => _activator.Activate <ExtractionConfigurationUI, ExtractionConfiguration>(extractionConfiguration));
Add(new ExecuteCommandRelease(_activator).SetTarget(extractionConfiguration));
Add(new ExecuteCommandRefreshExtractionConfigurationsCohort(_activator, extractionConfiguration));
Add(new ExecuteCommandOpenExtractionDirectory(_activator, extractionConfiguration));
ReBrandActivateAs("Extract...", RDMPConcept.ExtractionConfiguration, OverlayKind.Execute);
}
public void ExtractionProgressConstructor_NoTimePeriodicity()
{
var cata = new Catalogue(CatalogueRepository, "MyCata");
var eds = new ExtractableDataSet(DataExportRepository, cata);
var project = new Project(DataExportRepository, "My Proj");
var config = new ExtractionConfiguration(DataExportRepository, project);
var sds = new SelectedDataSets(DataExportRepository, config, eds, null);
var ex = Assert.Throws <ArgumentException>(() => new ExtractionProgress(DataExportRepository, sds));
Assert.AreEqual("Cannot create ExtractionProgress because Catalogue MyCata does not have a time coverage column", ex.Message);
}
public string GetCustomerExtractionConfiguration(HttpListenerContext ct, ActionInfo hi)
{
ExtractionConfiguration Ec = new ExtractionConfiguration();
Ec.DefaultDocumentSpecification = "A spec";
Ec.OrientationDetectionMode = OrientationDetectionMode.Off;
DocumentType dt = new DocumentType();
dt.IsSelected = true;
dt.Languages.Add("SE");
dt.ExtractionName = "TEst.pdf";
dt.InternalName = "TeSt.pdf";
Ec.SelectedDocumentTypes.Add(dt);
return(GetResponseString <ExtractionConfiguration>(Ec, ct));
}
private void RunTestWithCleanup(Project p, ExtractionConfiguration config, ICheckNotifier notifier = null)
{
try
{
new ProjectChecker(new ThrowImmediatelyActivator(RepositoryLocator), p).Check(notifier ?? new ThrowImmediatelyCheckNotifier()
{
ThrowOnWarning = true
});
}
finally
{
config.DeleteInDatabase();
p.DeleteInDatabase();
}
}
private void TestDataExportOfTvf()
{
var config = new ExtractionConfiguration(DataExportRepository, _project);
config.Cohort_ID = DataExportRepository.GetAllObjects <ExtractableCohort>().Single().ID;
config.SaveToDatabase();
var tvfExtractable = new ExtractableDataSet(DataExportRepository, _tvfCatalogue);
var selected = new SelectedDataSets(DataExportRepository, config, tvfExtractable, null);
//make all columns part of the extraction
foreach (ExtractionInformation e in _tvfCatalogue.GetAllExtractionInformation(ExtractionCategory.Any))
{
config.AddColumnToExtraction(tvfExtractable, e);
}
//the default value should be 10
Assert.AreEqual("10", _tvfTableInfo.GetAllParameters().Single().Value);
//configure an extraction specific global of 1 so that only 1 chi number is fetched (which will be in the cohort)
var globalP = new GlobalExtractionFilterParameter(DataExportRepository, config, "DECLARE @numberOfRecords AS int;");
globalP.Value = "1";
globalP.SaveToDatabase();
var extractionCommand = new ExtractDatasetCommand(config, new ExtractableDatasetBundle(tvfExtractable));
var source = new ExecuteDatasetExtractionSource();
source.PreInitialize(extractionCommand, new ThrowImmediatelyDataLoadEventListener());
var dt = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
Assert.AreEqual(1, dt.Rows.Count);
Assert.AreEqual("ReleaseId", dt.Columns[0].ColumnName);
//should be a guid
Assert.IsTrue(dt.Rows[0][0].ToString().Length > 10);
Assert.IsTrue(dt.Rows[0][0].ToString().Contains("-"));
selected.DeleteInDatabase();
globalP.DeleteInDatabase();
config.DeleteInDatabase();
tvfExtractable.DeleteInDatabase();
}
