public static void GenerateXSD(GeneratorContext context, XmlSchema schema)
{
var enums = new List <IEnum>();
var generatedBDTs = new List <string>();
//loop the bdt's
foreach (IBdt bdt in context.Elements
.OfType <IBdt>().Where(x => !x.isDirectXSDType))
{
var xsdBdtName = NDR.GetXsdTypeNameFromBdt(bdt);
//get the enum from the CON attribute and add it to the enums list.
var enumToAdd = bdt.Con?.BasicType?.Enum;
if (enumToAdd != null && !enums.Any(x => x.Name == enumToAdd.Name))
{
enums.Add(enumToAdd);
}
//make sure we don't generate two BDT's witht he same xsdBdtName
if (!generatedBDTs.Contains(xsdBdtName))
{
//add the xsdBdtName to the list
generatedBDTs.Add(xsdBdtName);
var sups = new List <IBdtSup>(bdt.Sups);
if (!sups.Any())
{
var simpleType = new XmlSchemaSimpleType {
Name = xsdBdtName
};
var simpleTypeRestriction = new XmlSchemaSimpleTypeRestriction();
simpleTypeRestriction.BaseTypeName = GetXmlQualifiedName(NDR.getConBasicTypeName(bdt), context, bdt.Con?.BasicType);
simpleType.Content = simpleTypeRestriction;
if (bdt.Con != null &&
bdt.Con.BasicType != null &&
bdt.Con.BasicType.Prim != null)
{
var XSDtype = bdt.Con.BasicType.Prim.xsdType;
if (!string.IsNullOrEmpty(XSDtype))
{
simpleTypeRestriction.BaseTypeName = new XmlQualifiedName(NSPREFIX_XSD + ":" + XSDtype);
}
}
if (context.Annotate)
{
simpleType.Annotation = GetTypeAnnotation(bdt);
}
schema.Items.Add(simpleType);
}
else
{
//create the complex type
var complexType = new XmlSchemaComplexType();
complexType.Name = xsdBdtName;
//add the simple content extension
var simpleContent = new XmlSchemaSimpleContent();
var simpleContentExtension = new XmlSchemaSimpleContentExtension();
//get the xsd type if the con is a primitive
if (bdt.Con.BasicType != null &&
bdt.Con.BasicType.Prim != null)
{
simpleContentExtension.BaseTypeName = GetXmlQualifiedName(bdt.Con.BasicType.Prim.xsdType, context, bdt.Con.BasicType);
}
else
{
var basicEnum = bdt.Con?.BasicType?.Enum;
if (basicEnum != null)
{
//enum was already added tot he list above
simpleContentExtension.BaseTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetBasicTypeName(basicEnum));
}
else
{
simpleContentExtension.BaseTypeName = GetXmlQualifiedName(NDR.getConBasicTypeName(bdt), context, bdt.Con.BasicType);
}
}
foreach (IBdtSup sup in sups)
{
var attribute = new XmlSchemaAttribute();
// Deviation from rule [R ABC1]: Using only attribute name and type as xml attribute name (instead of complete DEN), following the examples given in the specification.
attribute.Name = sup.Name;
//set optional or required
attribute.Use = sup.IsOptional() ? XmlSchemaUse.Optional : XmlSchemaUse.Required;
//set the type of the attribute
if (sup.BasicType != null &&
sup.BasicType.IsEnum)
{
//figure out if the set of values is restricted
var basicEnum = sup.BasicType.Enum as UpccEnum;
//add the enum to the list
if (!enums.Any(x => x.Name == basicEnum.Name))
{
enums.Add(basicEnum);
}
if (basicEnum.CodelistEntries.Any())
{
//add the restrictions
var restrictedtype = new XmlSchemaSimpleType();
var restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetBasicTypeName(basicEnum));
addEnumerationValues(restriction, basicEnum);
//add the restriction to the simple type
restrictedtype.Content = restriction;
//set the type of the attribute
attribute.SchemaType = restrictedtype;
}
else
{
attribute.SchemaTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetBasicTypeName(basicEnum));
}
}
//set regular type name if not restricted
if (attribute.SchemaTypeName.IsEmpty &&
attribute.SchemaType == null)
{
attribute.SchemaTypeName = GetXmlQualifiedName(NDR.GetBasicTypeName(sup as UpccAttribute), context, sup.BasicType);
}
//annotate if needed
if (context.Annotate)
{
attribute.Annotation = GetAttributeAnnotation(sup);
}
//add the attribute
simpleContentExtension.Attributes.Add(attribute);
}
simpleContent.Content = simpleContentExtension;
complexType.ContentModel = simpleContent;
if (context.Annotate)
{
complexType.Annotation = GetTypeAnnotation(bdt);
}
schema.Items.Add(complexType);
}
}
}
context.AddElements(enums);
}
private static XmlSchemaComplexType GenerateComplexTypeForMa(GeneratorContext context, XmlSchema schema, IMa ma, string abiePrefix)
{
var maType = new XmlSchemaComplexType();
maType.Name = ma.Name + "Type";
var sequence = new XmlSchemaSequence();
foreach (IAsma asma in ma.Asmas.OrderBy(a => a.Name))
{
XmlSchemaElement elementAsma = null;
// Take care of ASMAS aggregating ABIEs
if (asma.AssociatedBieAggregator.IsAbie)
{
elementAsma = new XmlSchemaElement
{
Name = NDR.GetXsdElementNameFromAsma(asma),
SchemaTypeName =
new XmlQualifiedName(NSPREFIX_BIE + ":" +
asma.AssociatedBieAggregator.Name +
"Type")
};
}
else if (asma.AssociatedBieAggregator.IsMa)
{
elementAsma = new XmlSchemaElement
{
Name = NDR.GetXsdElementNameFromAsma(asma),
SchemaTypeName =
new XmlQualifiedName(context.NamespacePrefix + ":" +
asma.AssociatedBieAggregator.Name +
"Type")
};
}
var refAsma = new XmlSchemaElement
{
RefName =
new XmlQualifiedName(context.NamespacePrefix + ":" +
NDR.GetXsdElementNameFromAsma(asma))
};
// every shared ASCC may only appear once in the XSD file
if (!globalAsmas.Contains(elementAsma.Name))
{
// R 9241: for ASBIEs with AggregationKind = shared a global element must be declared.
schema.Items.Add(elementAsma);
globalAsmas.Add(elementAsma.Name);
}
sequence.Items.Add(refAsma);
}
maType.Particle = sequence;
if (context.Annotate)
{
maType.Annotation = GetMaAnnotation(ma);
}
return(maType);
}
public static void GenerateXSD(GeneratorContext context, IEnumerable <IBdt> bdts, XmlSchema schema)
{
context.AddElements(bdts);
GenerateXSD(context, schema);
}
private static void AddGlobalTypeDefinitions(XmlSchema schema, IEnumerable <IMa> mas, GeneratorContext context)
{
foreach (IMa ma in mas)
{
schema.Items.Add(GenerateComplexTypeForMa(context, schema, ma,
context.NamespacePrefix));
}
}
internal static XmlSchemaComplexType GenerateComplexTypeACC(GeneratorContext context, XmlSchema schema, IAcc acc, string accPrefix)
{
// R A4CE, R AF95: a complex type must be defined for each ABIE
XmlSchemaComplexType complexTypeACC = new XmlSchemaComplexType();
// R 9D83: the name of the ABIE must be the DictionaryEntryName with all whitespace and separators
// removed. The 'Details' suffix is replaced with 'Type'.
complexTypeACC.Name = acc.Name + "Type";
if (context.Annotate)
{
complexTypeACC.Annotation = GetACCAnnotation(acc);
}
// create the sequence for the BBIEs within the ABIE
XmlSchemaSequence sequenceBCCs = new XmlSchemaSequence();
foreach (IBcc bcc in acc.Bccs.OrderBy(a => a.Name))
{
// R 89A6: for every BBIE a named element must be locally declared
XmlSchemaElement elementBCC = new XmlSchemaElement();
// R AEFE, R 96D9, R9A40, R A34A are implemented in GetXsdElementNameFromBbie(...)
elementBCC.Name = NDR.GenerateBCCName(bcc);
// R 8B85: every BBIE type must be named the property term and qualifiers and the
// representation term of the basic business information entity (BBIE) it represents
// with the word 'Type' appended.
elementBCC.SchemaTypeName =
new XmlQualifiedName(NSPREFIX_CDT + ":" + bcc.Cdt.Name + bcc.Cdt.Con.BasicType.Name + "Type");
// R 90F9: cardinality of elements within the ABIE
elementBCC.MinOccursString = AdjustLowerBound(bcc.LowerBound);
elementBCC.MaxOccursString = AdjustUpperBound(bcc.UpperBound);
if (context.Annotate)
{
elementBCC.Annotation = GetBCCAnnotation(bcc);
}
// add the element created to the sequence
sequenceBCCs.Items.Add(elementBCC);
}
foreach (IAscc ascc in acc.Asccs.OrderBy(a => a.Name))
{
XmlSchemaElement elementASCC = new XmlSchemaElement();
// R A08A: name of the ASBIE
elementASCC.Name = NDR.GenerateASCCName(ascc);
elementASCC.SchemaTypeName =
new XmlQualifiedName(accPrefix + ":" + ascc.AssociatedAcc.Name + "Type");
if (context.Annotate)
{
elementASCC.Annotation = GetASCCAnnotiation(ascc);
}
// R 9241: for ASBIEs with AggregationKind = shared a global element must be declared.
// ASCCs are always shared (as defined in UPCC)
XmlSchemaElement refASCC = new XmlSchemaElement();
refASCC.RefName = new XmlQualifiedName(accPrefix + ":" + elementASCC.Name);
// every shared ASCC may only appear once in the XSD file
if (!globalASCCs.Contains(elementASCC.Name))
{
schema.Items.Add(elementASCC);
globalASCCs.Add(elementASCC.Name);
}
sequenceBCCs.Items.Add(refASCC);
}
// add the sequence created to the complex type
complexTypeACC.Particle = sequenceBCCs;
return(complexTypeACC);
}
internal static XmlSchemaComplexType GenerateComplexTypeACC(GeneratorContext context, XmlSchema schema, IAcc acc)
{
return(GenerateComplexTypeACC(context, schema, acc, context.NamespacePrefix));
}
///<summary>
///</summary>
///<param name="context"></param>
///<param name="accs"></param>
public static void GenerateXSD(GeneratorContext context, IEnumerable <IAcc> accs)
{
// Create XML schema file and prepare the XML schema header
// R 88E2: all XML schema files must use UTF-8 encoding
// R B387: every XML schema must have a declared target namespace
globalASCCs = new List <string>();
var schema = new XmlSchema {
TargetNamespace = context.TargetNamespace
};
schema.Namespaces.Add(context.NamespacePrefix, context.TargetNamespace);
schema.Version = context.DocLibrary.VersionIdentifier.DefaultTo("1");
// TODO: discuss R A0E5 and R A9C5 with Christian E. and Michi S. since this is something that should be added to the context
// R A0E5: all XML schemas must contain elementFormDefault and set it to qualified
schema.ElementFormDefault = XmlSchemaForm.Qualified;
// R A9C5: All XML schemas must contain attributeFormDefault and set it to unqualified
schema.AttributeFormDefault = XmlSchemaForm.Unqualified;
// R 9B18: all XML schemas must utilize the xsd prefix when referring to the W3C XML schema namespace
schema.Namespaces.Add(NSPREFIX_XSD, NS_XSD);
if (context.Annotate)
{
XmlSchemaImport import = new XmlSchemaImport
{
Namespace =
"urn:un:unece:uncefact:documentation:standard:XMLNDRDocumentation:3",
SchemaLocation = "documentation/standard/XMLNDR_Documentation_3p0.xsd"
};
schema.Includes.Add(import);
schema.Namespaces.Add(NSPREFIX_DOC, NS_DOC);
}
// add namespace to be able to utilize BDTs
schema.Namespaces.Add(NSPREFIX_CDT, context.TargetNamespace);
// R 8FE2: include BDT XML schema file
// TODO: check with christian e. if we can retrieve the bdt schema file from the context
XmlSchemaInclude cdtInclude = new XmlSchemaInclude();
cdtInclude.SchemaLocation = "CoreDataType_" + schema.Version + ".xsd";
schema.Includes.Add(cdtInclude);
foreach (IAcc acc in accs.OrderBy(a => a.Name))
{
// finally add the complex type to the schema
schema.Items.Add(GenerateComplexTypeACC(context, schema, acc));
// R 9DA0: for each ABIE a named element must be globally declared
// R 9A25: the name of the ABIE element must be the DictionaryEntryName with whitespace
// and the 'Details' suffix removed
// R B27B: every ABIE global element declaration must be of the complexType that represents
// the ABIE
XmlSchemaElement elementACC = new XmlSchemaElement();
elementACC.Name = acc.Name;
elementACC.SchemaTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + acc.Name + "Type");
schema.Items.Add(elementACC);
}
context.AddSchema(schema, "CoreComponent_" + schema.Version + ".xsd", UpccSchematype.ACC);
}
///<summary>
///</summary>
///<param name="context"></param>
///<param name="cdts"></param>
public static void GenerateXSD(GeneratorContext context, IEnumerable <ICdt> cdts)
{
var schema = new XmlSchema {
TargetNamespace = context.TargetNamespace
};
schema.Namespaces.Add(context.NamespacePrefix, context.TargetNamespace);
schema.Namespaces.Add("xsd", "http://www.w3.org/2001/XMLSchema");
schema.Namespaces.Add("ccts", "urn:un:unece:uncefact:documentation:standard:XMLNDRDocumentation:3");
schema.Version = context.DocLibrary.VersionIdentifier.DefaultTo("1");
foreach (ICdt cdt in cdts)
{
var sups = new List <ICdtSup>(cdt.Sups);
if (sups.Count == 0)
{
var simpleType = new XmlSchemaSimpleType {
Name = GetTypeName(cdt)
};
var simpleTypeRestriction = new XmlSchemaSimpleTypeRestriction
{
BaseTypeName = GetXmlQualifiedName(cdt.Con.BasicType.Name)
};
simpleType.Content = simpleTypeRestriction;
if (context.Annotate)
{
simpleType.Annotation = GetTypeAnnotation(cdt);
}
schema.Items.Add(simpleType);
}
else
{
var complexType = new XmlSchemaComplexType
{
// Deviation from rule [R 90FB]: Using simpler and shorter names for CDT complex types.
Name = GetTypeName(cdt)
};
var simpleContent = new XmlSchemaSimpleContent();
var simpleContentExtension = new XmlSchemaSimpleContentExtension
{
BaseTypeName = GetXmlQualifiedName(cdt.Con.BasicType.Name)
};
foreach (ICdtSup sup in sups)
{
var attribute = new XmlSchemaAttribute
{
// Deviation from rule [R ABC1]: Using only attribute name and type as xml attribute name (instead of complete DEN), following the examples given in the specification.
Name = GetAttributeName(sup),
SchemaTypeName = new XmlQualifiedName(GetXSDType(sup.BasicType.Name),
"http://www.w3.org/2001/XMLSchema"),
};
if (context.Annotate)
{
attribute.Annotation = GetAttributeAnnotation(sup);
}
simpleContentExtension.Attributes.Add(attribute);
}
simpleContent.Content = simpleContentExtension;
complexType.ContentModel = simpleContent;
if (context.Annotate)
{
complexType.Annotation = GetTypeAnnotation(cdt);
}
schema.Items.Add(complexType);
}
}
context.AddSchema(schema, "CoreDataType_" + schema.Version + ".xsd");
}
