public override void SetDatabaseObject(IActivateItems activator, SelectedDataSets databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_extractionConfiguration = databaseObject.ExtractionConfiguration;
_extractableDataSet = databaseObject.ExtractableDataSet;
RegenerateCodeInQueryEditor();
}
/// <summary>
/// Makes the given <paramref name="column"/> SELECT Sql part of the query for linking and extracting the provided <paramref name="forDataSet"/>
/// for this <see cref="IExtractionConfiguration"/>.
/// </summary>
/// <param name="forDataSet"></param>
/// <param name="column"></param>
/// <returns></returns>
public ExtractableColumn AddColumnToExtraction(IExtractableDataSet forDataSet, IColumn column)
{
if (string.IsNullOrWhiteSpace(column.SelectSQL))
{
throw new ArgumentException("IColumn (" + column.GetType().Name + ") " + column + " has a blank value for SelectSQL, fix this in the CatalogueManager", "item");
}
string query = "";
query = column.SelectSQL;
ExtractableColumn addMe;
if (column is ExtractionInformation)
{
addMe = new ExtractableColumn((IDataExportRepository)Repository, forDataSet, this, column as ExtractionInformation, -1, query);
}
else
{
addMe = new ExtractableColumn((IDataExportRepository)Repository, forDataSet, this, null, -1, query); // its custom column of some kind, not tied to a catalogue entry
}
addMe.UpdateValuesToMatch(column);
return(addMe);
}
public DirectoryInfo GetDirectoryForDataset(IExtractableDataSet dataset)
{
if (dataset.ToString().Equals(CUSTOM_COHORT_DATA_FOLDER_NAME))
{
throw new Exception("You cannot call a dataset '" + CUSTOM_COHORT_DATA_FOLDER_NAME + "' because this string is reserved for cohort custom data the system spits out itself");
}
string reason;
if (!Catalogue.IsAcceptableName(dataset.Catalogue.Name, out reason))
{
throw new NotSupportedException("Cannot extract dataset " + dataset + " because it points at Catalogue with an invalid name, name is invalid because:" + reason);
}
var datasetDirectory = dataset.ToString();
try
{
return(ExtractionDirectoryInfo.CreateSubdirectory(datasetDirectory));
}
catch (Exception e)
{
throw new Exception("Could not create a directory called '" + datasetDirectory + "' as a subfolder of Project extraction directory " + ExtractionDirectoryInfo.Root, e);
}
}
public object GetState(IExtractableDataSet extractableData)
{
if (_options.Command == CommandLineActivity.check)
{
var sds = GetCheckNotifier(extractableData);
if (sds == null)
{
return(null);
}
return(sds.GetWorst());
}
if (_options.Command == CommandLineActivity.run)
{
lock (_oLock)
{
var sds = ExtractCommands.Keys.FirstOrDefault(k => k.ExtractableDataSet_ID == extractableData.ID);
if (sds == null)
{
return(null);
}
return(ExtractCommands[sds].State);
}
}
return(null);
}
public override string ToString()
{
if (_datasetName == null)
{
try
{
ICumulativeExtractionResults cumulativeExtractionResults = Repository.GetObjectByID <CumulativeExtractionResults>(CumulativeExtractionResults_ID);
IExtractableDataSet ds = Repository.GetObjectByID <ExtractableDataSet>(cumulativeExtractionResults.ExtractableDataSet_ID);
_datasetName = ds.ToString();
}
catch (Exception e)
{
_datasetName = e.Message;
}
}
return
(string.Format(
"ReleaseLogEntry(CumulativeExtractionResults_ID={0},DatasetName={1},DateOfRelease={2},Username={3})",
CumulativeExtractionResults_ID,
_datasetName,
DateOfRelease,
Username));
}
/// <inheritdoc/>
public void RemoveDatasetFromConfiguration(IExtractableDataSet extractableDataSet)
{
var match = SelectedDataSets.SingleOrDefault(s => s.ExtractableDataSet_ID == extractableDataSet.ID);
if (match != null)
{
match.DeleteInDatabase();
}
}
public void AddDataSetToPackage(IExtractableDataSetPackage package, IExtractableDataSet dataSet)
{
if (!_packageDictionary.ContainsKey(package))
{
_packageDictionary.Add(package, new HashSet <IExtractableDataSet>());
}
_packageDictionary[package].Add(dataSet);
}
public ExtractableDatasetBundle(IExtractableDataSet dataSet, SupportingDocument[] documents, SupportingSQLTable[] supportingSQL, ITableInfo[] lookupTables) :
base(
new [] { (object)dataSet }.Union(documents).Union(supportingSQL).Union(lookupTables).ToArray() //pass all the objects to the base class so it can allocate initial States
)
{
DataSet = dataSet;
Documents = documents.ToList();
SupportingSQL = supportingSQL.ToList();
LookupTables = lookupTables.Select(t => new BundledLookupTable(t)).Cast <IBundledLookupTable>().ToList();
}
/// <summary>
/// Makes the provided <paramref name="extractableDataSet"/> extractable in the current <see cref="IExtractionConfiguration"/>. This
/// includes selecting it (<see cref="ISelectedDataSets"/>) and replicating any mandatory filters.
/// </summary>
/// <param name="extractableDataSet"></param>
public void AddDatasetToConfiguration(IExtractableDataSet extractableDataSet)
{
//it is already part of the configuration
if (SelectedDataSets.Any(s => s.ExtractableDataSet_ID == extractableDataSet.ID))
{
return;
}
var dataExportRepo = (IDataExportRepository)Repository;
var selectedDataSet = new SelectedDataSets(dataExportRepo, this, extractableDataSet, null);
ExtractionFilter[] mandatoryExtractionFiltersToApplyToDataset = extractableDataSet.Catalogue.GetAllMandatoryFilters();
//add mandatory filters
if (mandatoryExtractionFiltersToApplyToDataset.Any())
{
//first we need a root container e.g. an AND container
//add the AND container and set it as the root container for the dataset configuration
FilterContainer rootFilterContainer = new FilterContainer(dataExportRepo);
rootFilterContainer.Operation = FilterContainerOperation.AND;
rootFilterContainer.SaveToDatabase();
selectedDataSet.RootFilterContainer_ID = rootFilterContainer.ID;
selectedDataSet.SaveToDatabase();
var globals = GlobalExtractionFilterParameters;
var importer = new FilterImporter(new DeployedExtractionFilterFactory(dataExportRepo), globals);
var mandatoryFilters = importer.ImportAllFilters(mandatoryExtractionFiltersToApplyToDataset, null);
foreach (DeployedExtractionFilter filter in mandatoryFilters.Cast <DeployedExtractionFilter>())
{
filter.FilterContainer_ID = rootFilterContainer.ID;
filter.SaveToDatabase();
}
}
var legacyColumns = GetAllExtractableColumnsFor(extractableDataSet).Cast <ExtractableColumn>().ToArray();
//add Core or ProjectSpecific columns
foreach (var all in extractableDataSet.Catalogue.GetAllExtractionInformation(ExtractionCategory.Any))
{
if (all.ExtractionCategory == ExtractionCategory.Core || all.ExtractionCategory == ExtractionCategory.ProjectSpecific)
{
if (legacyColumns.All(l => l.CatalogueExtractionInformation_ID != all.ID))
{
AddColumnToExtraction(extractableDataSet, all);
}
}
}
}
private ExtractDatasetCommand(IExtractionConfiguration configuration, IExtractableDataSet dataset) : base(configuration)
{
var selectedDataSets = configuration.SelectedDataSets.Where(ds => ds.ExtractableDataSet_ID == dataset.ID).ToArray();
if (selectedDataSets.Length != 1)
{
throw new Exception("Could not find 1 ISelectedDataSets for ExtractionConfiguration '" + configuration + "' | Dataset '" + dataset + "'");
}
SelectedDataSets = selectedDataSets[0];
ExtractionResults = new List <IExtractionResults>();
}
/// <summary>
/// Creates a new line of SELECT Sql for the given <paramref name="dataset"/> as it is extracted in the provided <paramref name="configuration"/>. The new object will
/// be created in the <paramref name="repository"/> database.
/// </summary>
/// <param name="repository"></param>
/// <param name="dataset"></param>
/// <param name="configuration"></param>
/// <param name="extractionInformation"></param>
/// <param name="order"></param>
/// <param name="selectSQL"></param>
public ExtractableColumn(IDataExportRepository repository, IExtractableDataSet dataset, ExtractionConfiguration configuration, ExtractionInformation extractionInformation, int order, string selectSQL)
{
Repository = repository;
Repository.InsertAndHydrate(this, new Dictionary <string, object>
{
{ "ExtractableDataSet_ID", dataset.ID },
{ "ExtractionConfiguration_ID", configuration.ID },
{ "CatalogueExtractionInformation_ID", extractionInformation == null ? DBNull.Value : (object)extractionInformation.ID },
{ "Order", order },
{ "SelectSQL", string.IsNullOrWhiteSpace(selectSQL) ? DBNull.Value : (object)selectSQL }
});
ClearAllInjections();
}
/// <summary>
/// Removes the given <paramref name="dataSet"/> from the <paramref name="package"/> and updates the cached package contents
/// in memory.
///
/// <para>This change is immediately written to the database</para>
///
/// <para>Throws ArgumentException if the <paramref name="dataSet"/> is not part of the package</para>
/// </summary>
/// <param name="package"></param>
/// <param name="dataSet"></param>
public void RemoveDataSetFromPackage(IExtractableDataSetPackage package, IExtractableDataSet dataSet)
{
if (!_packageContentsDictionary.Value[package.ID].Contains(dataSet.ID))
{
throw new ArgumentException("dataSet " + dataSet + " is not part of package " + package + " so cannot be removed", "dataSet");
}
using (var con = _repository.GetConnection())
{
_repository.DiscoveredServer.GetCommand(
"DELETE FROM ExtractableDataSetPackage_ExtractableDataSet WHERE ExtractableDataSetPackage_ID = " + package.ID + " AND ExtractableDataSet_ID =" + dataSet.ID,
con).ExecuteNonQuery();
}
_packageContentsDictionary.Value[package.ID].Remove(dataSet.ID);
}
public override void SetDatabaseObject(IActivateItems activator, SelectedDataSets databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
activator.RefreshBus.EstablishLifetimeSubscription(this);
SelectedDataSet = databaseObject;
_dataSet = SelectedDataSet.ExtractableDataSet;
_config = (ExtractionConfiguration)SelectedDataSet.ExtractionConfiguration;
SetupUserInterface();
SortSelectedByOrder();
CommonFunctionality.AddToMenu(new ExecuteCommandShow(activator, databaseObject.ExtractableDataSet.Catalogue, 0, true), "Show Catalogue");
CommonFunctionality.Add(new ExecuteCommandExecuteExtractionConfiguration(activator, databaseObject));
CommonFunctionality.AddChecks(new SelectedDataSetsChecker(SelectedDataSet));
}
/// <summary>
/// Adds the given <paramref name="dataSet"/> to the <paramref name="package"/> and updates the cached package contents
/// in memory.
///
/// <para>This change is immediately written to the database</para>
///
/// <para>Throws ArgumentException if the <paramref name="dataSet"/> is already part of the package</para>
/// </summary>
/// <param name="package"></param>
/// <param name="dataSet"></param>
public void AddDataSetToPackage(IExtractableDataSetPackage package, IExtractableDataSet dataSet)
{
if (_packageContentsDictionary.Value.ContainsKey(package.ID) && _packageContentsDictionary.Value[package.ID].Contains(dataSet.ID))
{
throw new ArgumentException("dataSet " + dataSet + " is already part of package '" + package + "'", "dataSet");
}
using (var con = _repository.GetConnection())
{
_repository.DiscoveredServer.GetCommand(
"INSERT INTO ExtractableDataSetPackage_ExtractableDataSet(ExtractableDataSetPackage_ID,ExtractableDataSet_ID) VALUES (" + package.ID + "," + dataSet.ID + ")",
con).ExecuteNonQuery();
}
if (!_packageContentsDictionary.Value.ContainsKey(package.ID))
{
_packageContentsDictionary.Value.Add(package.ID, new List <int>());
}
_packageContentsDictionary.Value[package.ID].Add(dataSet.ID);
}
private ExtractDatasetCommand CreateDatasetCommand(IRDMPPlatformRepositoryServiceLocator repositoryLocator, IExtractableDataSet dataset, IExtractionConfiguration configuration)
{
var catalogue = dataset.Catalogue;
//get all extractable locals AND extractable globals first time then just extractable locals
var docs = catalogue.GetAllSupportingDocuments(FetchOptions.ExtractableLocals);
var sqls = catalogue.GetAllSupportingSQLTablesForCatalogue(FetchOptions.ExtractableLocals);
//Now find all the lookups and include them into the bundle
List <ITableInfo> lookupsFound;
List <ITableInfo> normalTablesFound;
catalogue.GetTableInfos(out normalTablesFound, out lookupsFound);
//bundle consists of:
var bundle = new ExtractableDatasetBundle(
dataset, //the dataset
docs, //all non global extractable docs (SupportingDocuments)
sqls.Where(sql => sql.IsGlobal == false).ToArray(), //all non global extractable sql (SupportingSQL)
lookupsFound.ToArray()); //all lookups associated with the Catalogue (the one behind the ExtractableDataset)
return(new ExtractDatasetCommand(configuration, bundle));
}
private void SetupDataExport(string testDbName, ICatalogue catalogue, out ExtractionConfiguration extractionConfiguration, out IExtractableDataSet extractableDataSet, out IProject project)
{
extractableDataSet = new ExtractableDataSet(DataExportRepository, catalogue);
project = new Project(DataExportRepository, testDbName);
project.ProjectNumber = 1;
Directory.CreateDirectory(ProjectDirectory);
project.ExtractionDirectory = ProjectDirectory;
project.SaveToDatabase();
extractionConfiguration = new ExtractionConfiguration(DataExportRepository, project);
extractionConfiguration.AddDatasetToConfiguration(extractableDataSet);
foreach (var ei in _catalogue.GetAllExtractionInformation(ExtractionCategory.Supplemental))
{
extractionConfiguration.AddColumnToExtraction(extractableDataSet, ei);
}
}
public ExtractableDatasetBundle(IExtractableDataSet dataSet)
: this(dataSet, new SupportingDocument[0], new SupportingSQLTable[0], new TableInfo[0])
{
}
public ToMemoryCheckNotifier GetCheckNotifier(IExtractableDataSet extractableData)
{
return(GetSingleCheckerResults <SelectedDataSetsChecker>((sds) => sds.SelectedDataSet.ExtractableDataSet_ID == extractableData.ID));
}
public IEnumerable <ICumulativeExtractionResults> GetAllCumulativeExtractionResultsFor(IExtractionConfiguration configuration, IExtractableDataSet dataset)
{
return(GetAllObjects <CumulativeExtractionResults>("WHERE ExtractionConfiguration_ID=" + configuration.ID + "AND ExtractableDataSet_ID=" + dataset.ID));
}
public PackageContentNode(IExtractableDataSetPackage package, IExtractableDataSet dataSet, IExtractableDataSetPackageManager contents)
{
_contents = contents;
Package = package;
DataSet = dataSet;
}
/// <inheritdoc/>
public IContainer GetFilterContainerFor(IExtractableDataSet dataset)
{
return(Repository.GetAllObjectsWhere <SelectedDataSets>("ExtractionConfiguration_ID", ID)
.Single(sds => sds.ExtractableDataSet_ID == dataset.ID)
.RootFilterContainer);
}
/// <inheritdoc/>
public ConcreteColumn[] GetAllExtractableColumnsFor(IExtractableDataSet dataset)
{
return
(Repository.GetAllObjectsWhere <ExtractableColumn>("ExtractionConfiguration_ID", ID)
.Where(e => e.ExtractableDataSet_ID == dataset.ID).ToArray());
}
