private void testMetadataStructure()
{
MetadataStructureManager mdsManager = new MetadataStructureManager();
MetadataPackageManager mdpManager = new MetadataPackageManager();
MetadataAttributeManager mdaManager = new MetadataAttributeManager();
MetadataStructure root = mdsManager.Repo.Get(p => p.Name == "Root").FirstOrDefault();
if (root == null) root = mdsManager.Create("Root", "This is the root metadata structure", "", "", null);
MetadataStructure s1 = mdsManager.Repo.Get(p => p.Name == "S1").FirstOrDefault();
if (s1 == null) s1 = mdsManager.Create("S1", "This is S1 metadata structure", "", "", root);
MetadataStructure s11 = mdsManager.Repo.Get(p => p.Name == "S1.1").FirstOrDefault();
if (s11 == null) s11 = mdsManager.Create("S1.1", "This is S1.1 metadata structure", "", "", s1);
MetadataStructure s2 = mdsManager.Repo.Get(p => p.Name == "S2").FirstOrDefault();
if (s2 == null) s2 = mdsManager.Create("S2", "This is S2 metadata structure", "", "", root);
MetadataPackage p1 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P1").FirstOrDefault();
if (p1 == null) p1 = mdpManager.Create("P1", "Sample Package 1", true);
MetadataPackage p2 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P2").FirstOrDefault();
if (p2 == null) p2 = mdpManager.Create("P2", "Sample Package 2", true);
MetadataPackage p3 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P3").FirstOrDefault();
if (p3 == null) p3 = mdpManager.Create("P3", "Sample Package 3", true);
MetadataPackage p4 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P4").FirstOrDefault();
if (p4 == null) p4 = mdpManager.Create("P4", "Sample Package 4", true);
if (s1.MetadataPackageUsages.Where(p => p.MetadataPackage == p1).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s1, p1, "P1 in S1", "", 0, 1);
if (s1.MetadataPackageUsages.Where(p => p.MetadataPackage == p2).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s1, p2, "P2 in S1", "", 1, 1);
if (s11.MetadataPackageUsages.Where(p => p.MetadataPackage == p3).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s11, p3, "P3 in S1.1", "", 0, 10);
if (s11.MetadataPackageUsages.Where(p => p.MetadataPackage == p4).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s11, p4, "P4 in S1.1", "", 2, 5);
var usages = mdsManager.GetEffectivePackages(3);
}
public long GenerateMetadataStructure(string nameOfStartNode,string schemaName)
{
if (!String.IsNullOrEmpty(schemaName))
SchemaName = schemaName;
string rootElementName = nameOfStartNode;
newXsdFilePath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "Metadata", schemaName, FileName);
#region prepare mappingFiles
#region intern to extern
// add schema to mappingfile
mappingFileInternalToExternal.Header.AddToSchemas(schemaName, "Metadata/" + schemaName + "/" + FileName);
#endregion
#region extern to intern
mappingFileExternalToInternal.Header.AddToDestination("Metadata");
mappingFileExternalToInternal.Header.AddToSchemas(schemaName, "Metadata/" + schemaName + "/" + FileName);
// id and name of metadatastructure fehlt
#endregion
#endregion
//List<MetadataAttribute> metadataAttributes = new List<MetadataAttribute>();
//metadataAttributes = GenerateAllMetadataAttributes();
List<XmlSchemaElement> elementsWithSimpleType = GetAllElementsTypeIsSimpleType();
List<XmlSchemaComplexType> complexTypesWithSimpleTypesAsChildrensOnly = GetAllComplextTypesWithSimpleTypesAsChildrens();
// create default
MetadataStructureManager mdsManager = new MetadataStructureManager();
MetadataPackageManager mdpManager = new MetadataPackageManager();
// create default metadataStructure
MetadataStructure test = null; //mdsManager.Repo.Get(p => p.Name == SchemaName).FirstOrDefault();
if (test == null) test = mdsManager.Create(SchemaName, SchemaName, "", "", null);
XmlSchemaObject root = new XmlSchemaElement();
string xpathFromRoot = "";
int count = 0;
foreach(XmlSchemaObject obj in Schema.Items)
{
if (obj is XmlSchemaElement)
{
count++;
if (count > 1)
{
throw new Exception("Root node is not able to declare");
}
}
}
foreach(XmlSchemaObject obj in Schema.Items)
{
if (obj is XmlSchemaElement)
root = (XmlSchemaElement)obj;
}
if (String.IsNullOrEmpty(nameOfStartNode))
{
XmlSchemaElement rootElement = (XmlSchemaElement)root;
mappingFileInternalToExternal.Header.AddToDestination(rootElement.Name, rootElement.Name);
rootElementName = rootElement.Name;
xpathFromRoot = rootElementName;
}
else
{
//XXX finde path from rootnode the defined root node
//XPath in mapping file needs to be complete based on the original xsd
xpathFromRoot = findPathFromRoot((XmlSchemaElement)root, nameOfStartNode, "");
root = Elements.Where(e => e.Name.ToLower().Equals(nameOfStartNode.ToLower())).FirstOrDefault();
if (root == null)
{
root = Groups.Where(g => g.Name.ToLower().Equals(nameOfStartNode.ToLower())).FirstOrDefault();
}
if (nameOfStartNode != "")
{
XmlSchemaElement rootElement = (XmlSchemaElement)root;
mappingFileInternalToExternal.Header.AddToDestination(nameOfStartNode, rootElement.Name);
}
}
List<XmlSchemaElement> childrenOfRoot = XmlSchemaUtility.GetAllElements(root, false, Elements);
List<XmlSchemaElement> packages = new List<XmlSchemaElement>();
if (XmlSchemaUtility.IsAllSimpleType(childrenOfRoot))
{
#region root with only simple type childrens
XmlSchemaGroup rootAsGroup = (XmlSchemaGroup)root;
MetadataPackage package = getExistingMetadataPackage(rootAsGroup.Name);
if (package == null)
{
package = mdpManager.Create(rootAsGroup.Name, GetDescription(rootAsGroup.Annotation), true);
createdPackagesDic.Add(package.Id, package.Name);
}
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
string xpath = "Metadata/" + rootAsGroup.Name;
foreach (XmlSchemaElement child in childrenOfRoot)
{
//Debug.Writeline("packageChild : " + child.Name);
//Debug.Writeline("-->");
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpath, rootAsGroup.Name);
}
else
{
List<string> parents = new List<string>();
parents.Add(rootAsGroup.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpath, rootAsGroup.Name);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
mdsManager.AddMetadataPackageUsage(test, package, rootAsGroup.Name, GetDescription(rootAsGroup.Annotation), 1, 1);
}
#endregion
}
else
{
packages.AddRange(childrenOfRoot);
#region packages with complext types
#region create a basic package of SimpleAttributes from Root Node
// get all simpleTypes
// for the main package
List<XmlSchemaElement> simpleElements = XmlSchemaUtility.GetAllSimpleElements(packages);
string rootNodePackageUsage = "Basic";
string rootNodePackage = "BasicType";
string rootNodePackageDescription = "Attributes from the root node";
if (simpleElements.Count > 0)
{
MetadataPackage package = getExistingMetadataPackage(rootNodePackage);// = mdpManager.MetadataPackageRepo.Get(p => p.Name == rootNodePackage).FirstOrDefault();
if (package == null)
{
package = mdpManager.Create(rootNodePackage, rootNodePackageDescription, true);
createdPackagesDic.Add(package.Id, package.Name);
}
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
foreach (XmlSchemaElement child in simpleElements)
{
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child,"Metadata/Basic/BasicType", xpathFromRoot);
}
}
mdsManager.AddMetadataPackageUsage(test, package, rootNodePackageUsage, rootNodePackageDescription, 1, 1);
}
}
#endregion
#region create Packages
List<XmlSchemaElement> otherElements = XmlSchemaUtility.GetAllComplexElements(packages);
foreach (XmlSchemaElement element in otherElements)
{
//Debug.Writeline("package : " + element.Name);
//Debug.Writeline("--------------------------");
string typeName = GetTypeOfName(element.Name);
string rootName = ((XmlSchemaElement)root).Name;
string xpathInternal = "Metadata/" + element.Name+"/"+typeName;
string xpathExternal = xpathFromRoot+"/" + element.Name;
if (!XmlSchemaUtility.IsSimpleType(element))
{
#region complexType
MetadataPackage package = getExistingMetadataPackage(element.Name);// = mdpManager.MetadataPackageRepo.Get(p => p.Name == element.Name).FirstOrDefault();
if (package == null)
{
package = mdpManager.Create(typeName, GetDescription(element.Annotation), true);
createdPackagesDic.Add(package.Id, package.Name);
}
// add package to structure
if (test.MetadataPackageUsages != null && test.MetadataPackageUsages.Where(p => p.Label.Equals(element.Name)).Count() > 0)
{
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
List<XmlSchemaElement> childrens = XmlSchemaUtility.GetAllElements(element, false, Elements);
foreach (XmlSchemaElement child in childrens)
{
//Debug.Writeline("packageChild : " + child.Name);
//Debug.Writeline("-->");
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpathInternal, xpathExternal);
}
else
{
List<string> parents = new List<string>();
parents.Add(element.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpathInternal, xpathExternal);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
int min = 0;
if (element.MinOccurs > int.MinValue)
min = Convert.ToInt32(element.MinOccurs);
else
min = int.MinValue;
int max = 0;
if (element.MaxOccurs < int.MaxValue)
max = Convert.ToInt32(element.MaxOccurs);
else
max = int.MaxValue;
mdsManager.AddMetadataPackageUsage(test, package, element.Name, GetDescription(element.Annotation), min, max);
}
}
else
{
List<XmlSchemaElement> childrens = XmlSchemaUtility.GetAllElements(element, false, Elements);
foreach (XmlSchemaElement child in childrens)
{
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpathInternal, xpathExternal);
}
else
{
List<string> parents = new List<string>();
parents.Add(element.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpathInternal, xpathExternal);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
int min = 0;
if (element.MinOccurs > int.MinValue)
min = Convert.ToInt32(element.MinOccurs);
else
min = int.MinValue;
int max = 0;
if (element.MaxOccurs < int.MaxValue)
max = Convert.ToInt32(element.MaxOccurs);
else
max = int.MaxValue;
//check if element is a choice
if (!XmlSchemaUtility.IsChoiceType(element))
{
MetadataPackageUsage mpu = mdsManager.AddMetadataPackageUsage(test, package,
element.Name, GetDescription(element.Annotation), min, max);
}
else
{
// if mpu is a choice, add a info to extra
MetadataPackageUsage mpu = mdsManager.AddMetadataPackageUsage(test, package,
element.Name, GetDescription(element.Annotation), min, max,
XmlDatasetHelper.AddReferenceToXml(new XmlDocument(), "choice", "true", "elementType", @"extra/type"));
}
}
#endregion
}
}
#endregion
#endregion
}
if (!File.Exists(newXsdFilePath))
{
checkDirectory(newXsdFilePath);
MoveFile(xsdFilePath, newXsdFilePath);
}
#region store additionaly xsds
string tmpDestinationPath = Path.GetDirectoryName(newXsdFilePath);
string tmpSourcePath = Path.GetDirectoryName(xsdFilePath);
if (additionalFiles != null)
{
foreach (var filename in additionalFiles.Distinct())
{
MoveFile(Path.Combine(tmpSourcePath, filename), Path.Combine(tmpDestinationPath, filename));
}
}
#endregion
#region Generate Mapping File
string internalMetadataStructrueName = schemaName;
mappingFileExternalToInternal.Id = test.Id;
//generate mapping file Xml Document
generateXmlMappingFile(mappingFileInternalToExternal, internalMetadataStructrueName, FileName);
generateXmlMappingFile(mappingFileExternalToInternal, FileName, internalMetadataStructrueName, 1);
#endregion
return test.Id;
}
