public static async Task <Projection> BuildAsync(IDiagnosticsCallback diagnosticsCallback, string mappingFile, string connectionString)
{
SqlConnection connection = null;
try { connection = new SqlConnection(connectionString); }
catch (InvalidOperationException) { throw new ConnectionStringFormatException(connectionString); }
var diagnosticsCallbackScope = new DiagnosticsCallbackScope(
diagnosticsCallback,
$"{Path.GetFileName(mappingFile)} <-> [{connection.DataSource}].[{connection.Database}] >");
var catalogReader = new CatalogReader(connectionString, diagnosticsCallback);
var mappingReader = new MappingReader(mappingFile, diagnosticsCallback);
var modelReader = new ProjectionBuilder(catalogReader, mappingReader, diagnosticsCallbackScope);
return(await modelReader.BuildAsync());
}
public void GenerateSeedData()
{
FeatureManager featureManager = null;
FeaturePermissionManager featurePermissionManager = new FeaturePermissionManager();
OperationManager operationManager = new OperationManager();
try
{
featureManager = new FeatureManager();
List <Feature> features = featureManager.FeatureRepository.Get().ToList();
Feature dataPlanning = features.FirstOrDefault(f => f.Name.Equals("Data Planning"));
if (dataPlanning == null)
{
dataPlanning = featureManager.Create("Data Planning", "Data Planning Management");
}
Feature datastructureFeature = features.FirstOrDefault(f =>
f.Name.Equals("Datastructure Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (datastructureFeature == null)
{
datastructureFeature = featureManager.Create("Datastructure Management", "Datastructure Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "DataStructureSearch", "*"))
{
operationManager.Create("RPM", "DataStructureSearch", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "DataStructureEdit", "*"))
{
operationManager.Create("RPM", "DataStructureEdit", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "Structures", "*"))
{
operationManager.Create("RPM", "Structures", "*", datastructureFeature);
}
if (!operationManager.Exists("RPM", "DataStructureIO", "*"))
{
operationManager.Create("RPM", "DataStructureIO", "*", datastructureFeature);
}
Feature atributeFeature = features.FirstOrDefault(f =>
f.Name.Equals("Variable Template Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (atributeFeature == null)
{
atributeFeature = featureManager.Create("Variable Template Management", "Variable Template Management", dataPlanning);
}
;
if (!operationManager.Exists("RPM", "DataAttribute", "*"))
{
operationManager.Create("RPM", "DataAttribute", "*", atributeFeature);
}
Feature unitFeature = features.FirstOrDefault(f =>
f.Name.Equals("Unit Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (unitFeature == null)
{
unitFeature = featureManager.Create("Unit Management", "Unit Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "Unit", "*"))
{
operationManager.Create("RPM", "Unit", "*", unitFeature);
}
Feature dataTypeFeature = features.FirstOrDefault(f =>
f.Name.Equals("Data Type Management") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (dataTypeFeature == null)
{
dataTypeFeature = featureManager.Create("Data Type Management", "Data Type Management", dataPlanning);
}
if (!operationManager.Exists("RPM", "Home", "*"))
{
operationManager.Create("RPM", "Home", "*", dataTypeFeature);
}
if (!operationManager.Exists("RPM", "Help", "*"))
{
operationManager.Create("RPM", "Help", "*");
}
Feature api = features.FirstOrDefault(f =>
f.Name.Equals("API") &&
f.Parent != null &&
f.Parent.Id.Equals(dataPlanning.Id));
if (api == null)
{
api = featureManager.Create("API", "API", dataPlanning);
}
if (!operationManager.Exists("API", "Structures", "*"))
{
operationManager.Create("API", "Structures", "*", api);
}
//set api public
featurePermissionManager.Create(null, api.Id, Security.Entities.Authorization.PermissionType.Grant);
}
finally
{
featureManager.Dispose();
featurePermissionManager.Dispose();
operationManager.Dispose();
}
//create seed data from csv files
MappingReader mappingReader = new MappingReader();
AttributeCreator attributeCreator = new AttributeCreator();
string filePath = AppConfiguration.GetModuleWorkspacePath("RPM");
// read data types from csv file
DataTable mappedDataTypes = mappingReader.readDataTypes(filePath);
// create read data types in bpp
attributeCreator.CreateDataTypes(ref mappedDataTypes);
//// read dimensions from csv file
DataTable mappedDimensions = mappingReader.readDimensions(filePath);
// create dimensions in bpp
attributeCreator.CreateDimensions(ref mappedDimensions);
//// read units from csv file
DataTable mappedUnits = mappingReader.readUnits(filePath);
// create read units in bpp
attributeCreator.CreateUnits(ref mappedUnits);
//// read attributes from csv file
DataTable mappedAttributes = mappingReader.readAttributes(filePath);
// free memory
mappedDataTypes.Clear();
mappedDimensions.Clear();
// create read attributes in bpp
attributeCreator.CreateAttributes(ref mappedAttributes);
createResearchPlan();
//createSeedDataTypes();
//createSIUnits();
//createEmlDatasetAdv();
//createABCD();
//ImportSchema("Basic ABCD", "ABCD_2.06.XSD","Dataset","BExIS.Dlm.Entities.Data.Dataset");
//ImportSchema("Basic Eml", "eml.xsd","dataset","BExIS.Dlm.Entities.Data.Dataset");
DataStructureManager dsm = null;
try
{
dsm = new DataStructureManager();
foreach (StructuredDataStructure sds in dsm.StructuredDataStructureRepo.Get())
{
DataStructureIO.convertOrder(sds);
}
}
finally
{
dsm.Dispose();
}
}
public void DataSetTransfer()
{
string filePath = AppConfiguration.GetModuleWorkspacePath("BMM");
//string xsdPath = @"C:\Data\Temp\Administrator";
string xsdPath = Path.Combine(AppConfiguration.DataPath, "Temp", "Administrator");
string xsdUserName = "******";
string researchPlanName = "Research plan";
MappingReader mappingReader = new MappingReader();
AttributeCreator attributeCreator = new AttributeCreator();
MetadataCreator metadataCreator = new MetadataCreator();
MigrationHelpers migrationHelpers = new MigrationHelpers();
#region create datatypes, unit, dimensions for datastructure from mapping file
// read data types from excel mapping file
DataTable mappedDataTypes = mappingReader.readDataTypes(filePath);
// create read data types in bpp
attributeCreator.CreateDataTypes(ref mappedDataTypes);
// read dimensions from excel mapping file
DataTable mappedDimensions = mappingReader.readDimensions(filePath);
// create dimensions in bpp
attributeCreator.CreateDimensions(ref mappedDimensions);
// read units from excel mapping file
DataTable mappedUnits = mappingReader.readUnits(filePath, mappedDimensions);
// create read units in bpp
attributeCreator.CreateUnits(ref mappedUnits, mappedDataTypes);
// read attributes from excel mapping file
DataTable mappedAttributes = mappingReader.readAttributes(filePath, mappedUnits, mappedDataTypes);
// Speicher freigeben
mappedDataTypes.Clear();
mappedDimensions.Clear();
// create read attributes in bpp
attributeCreator.CreateAttributes(ref mappedAttributes);
// read variables from XLSX or TSV (tab seperated values) mapping file
//DataTable mappedVariables = mappingReader.readVariables(filePath, mappedAttributes);
DataTable mappedVariables = mappingReader.readVariablesTSV(filePath, mappedAttributes, mappedUnits);
// Speicher freigeben
mappedAttributes.Clear();
mappedUnits.Clear();
#endregion
#region create metadatastructure and prepare a xmltemplate based on the structure
// if not existing: import METADATA structure, using file "schema.xsd" similar to bexis1 schema
long metadataStructureId = metadataCreator.importMetadataStructure(xsdPath, xsdUserName);
// create BppmetadataXmlTemplate to get XmlAttributes
XmlDocument metadataXmlTemplate = BExIS.Xml.Helpers.XmlMetadataWriter.ToXmlDocument(metadataCreator.createXmlTemplate(metadataStructureId));
#endregion
#region create Dataset(Metadata,Datastructure)
// the dataStructure, metadata and dataset of these bexis1 datasets will be transfered
DataStructureCreator dataStructureCreator = new DataStructureCreator();
DatasetCreator datasetCreator = new DatasetCreator();
List<string> datasetIds = migrationHelpers.getDatasets(filePath);
foreach (string dataSetID in datasetIds)
{
dataStructureCreator = new DataStructureCreator();
datasetCreator = new DatasetCreator();
XmlDocument metadataXml = new XmlDocument();
List<string> variableNames = new List<string>();
string fileType = "";
// get metadata from Bexis1 DB and restructure it for Bpp using xml-mapping file
metadataXml = metadataCreator.createMetadata(dataSetID, filePath, DataBase, ref variableNames, ref fileType);
//long dataStructureId = -1;
BExIS.Dlm.Entities.DataStructure.DataStructure dataStructure = null;
if (fileType == "structuredData" || fileType == "lookupTable")
{
// create dataStructure on bpp
dataStructure = dataStructureCreator.CreateDataStructure(dataSetID, mappedVariables, variableNames);
}
else if (fileType.Length > 0)
{
// create unstructured dataStructure on bpp
dataStructure = dataStructureCreator.CreateDataStructure(fileType);
}
long datasetId = -1;
if (dataStructure.Id > 0)
{
datasetId = datasetCreator.DatasetExistsByOldDatasetId(dataSetID, dataStructure.Id);
}
if (datasetId <= 0) // dataset not exists => create dataset
{
// integrate BppXmlAttributes by using metadataXmlTemplate
metadataXml = metadataCreator.fillInXmlAttributes(metadataXml, metadataXmlTemplate);
// create dataset with Bexis1_metadata
datasetId = datasetCreator.createDataset(dataSetID, metadataXml, metadataStructureId, dataStructure, researchPlanName);
}
string DatasetMappingPath = Path.Combine(AppConfiguration.DataPath, "DatasetMapping.txt");
string[] DatasetMappingtexts = File.ReadAllLines(DatasetMappingPath);
string DatasetMappingtext = DatasetMappingtexts.FirstOrDefault(item => item.Split('\t')[0] == dataSetID);
//to prevent of repeating data
if (DatasetMappingtext != null)
File.WriteAllLines(DatasetMappingPath, DatasetMappingtexts.Where(item => item != DatasetMappingtext));
File.AppendAllText(DatasetMappingPath, dataSetID + "\t" + datasetId + "\r\n");
}
#endregion
}
