public static void addFacets(XmlSchemaSimpleContentRestriction restriction, IEnumerable <ICctsFacet> facets)
{
foreach (var xmlFacet in createXmlFacets(facets))
{
restriction.Facets.Add(xmlFacet);
}
}
static void addEnumerationValues(XmlSchemaSimpleContentRestriction restriction, UpccEnum basicEnum)
{
foreach (var codeListEntry in basicEnum.CodelistEntries)
{
var xmlEnum = new XmlSchemaEnumerationFacet();
xmlEnum.Value = codeListEntry.Name;
restriction.Facets.Add(xmlEnum);
}
}
private static void Equal(XmlSchemaSimpleContentRestriction expected, XmlSchemaSimpleContentRestriction actual)
{
AnnotatedEqual(expected, actual);
Assert.Equal(expected.BaseTypeName, actual.BaseTypeName);
IsEquivalentTo(expected.BaseType, actual.BaseType);
FacetsEquivalentTo(expected.Facets, actual.Facets);
IsEquivalentTo(expected.Attributes, actual.Attributes);
IsEquivalentTo(expected.AnyAttribute, actual.AnyAttribute);
}
public static void ObtenerTipoDeDatoDerivadoDeXbrl(XmlSchema esquema, XmlSchemaType dataType, out XmlSchemaType dataTypeBaseQName)
{
dataTypeBaseQName = null;
if (dataType.QualifiedName != null && dataType.QualifiedName.Namespace.Equals(EspacioNombresConstantes.InstanceNamespace))
{
if (TiposDatoXBRL.TiposXBRL.Contains(dataType.QualifiedName.Name))
{
dataTypeBaseQName = dataType;
}
}
else
{
if (dataType.DerivedBy.Equals(XmlSchemaDerivationMethod.Restriction))
{
XmlQualifiedName qName = null;
if (dataType.GetType() == typeof(XmlSchemaSimpleType))
{
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)dataType;
XmlSchemaSimpleTypeRestriction simpleTypeRestriction = (XmlSchemaSimpleTypeRestriction)simpleType.Content;
qName = simpleTypeRestriction.BaseTypeName;
}
else if (dataType.GetType() == typeof(XmlSchemaComplexType))
{
XmlSchemaComplexType complexType = (XmlSchemaComplexType)dataType;
if (complexType.ContentModel == null)
{
;
}
else
{
if (complexType.ContentModel.Content.GetType() == typeof(XmlSchemaComplexContentRestriction))
{
XmlSchemaComplexContentRestriction content = (XmlSchemaComplexContentRestriction)complexType.ContentModel.Content;
qName = content.BaseTypeName;
}
else
{
XmlSchemaSimpleContentRestriction content = (XmlSchemaSimpleContentRestriction)complexType.ContentModel.Content;
qName = content.BaseTypeName;
}
}
}
if (qName != null)
{
XmlSchemaType tipo = esquema.SchemaTypes.Contains(qName) ? esquema.SchemaTypes[qName] as XmlSchemaType : null;
if (tipo != null)
{
ObtenerTipoDeDatoDerivadoDeXbrl(esquema, tipo, out dataTypeBaseQName);
}
}
}
}
}
protected virtual void Visit(XmlSchemaSimpleContentRestriction restriction)
{
Traverse(restriction.Facets);
Traverse(restriction.Attributes);
if (restriction.AnyAttribute != null)
{
Traverse(restriction.AnyAttribute);
}
}
protected virtual void WriteContentModel(XmlSchemaComplexType type,
XmlWriter writer)
{
if (type.ContentModel != null)
{
if (type.ContentModel is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent content = type.ContentModel as XmlSchemaSimpleContent;
XmlSchemaSimpleContentRestriction restriction =
content.Content as XmlSchemaSimpleContentRestriction;
if (restriction != null)
{
WriteExampleValue(type.QualifiedName.Name, restriction.BaseType, writer);
}
else
{
XmlSchemaSimpleContentExtension extension =
content.Content as XmlSchemaSimpleContentExtension;
}
}
else if (type.Particle == null && type.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent complexContent =
type.ContentModel as XmlSchemaComplexContent;
XmlSchemaComplexContentExtension ext =
type.ContentModel.Content as XmlSchemaComplexContentExtension;
if (type.BaseXmlSchemaType != null)
{
XmlSchemaComplexType baseType =
type.BaseXmlSchemaType as XmlSchemaComplexType;
if (baseType != null)
{
WriteContentModel(baseType, writer);
}
}
if (ext != null && ext.Particle != null)
{
if (ext.BaseTypeName != null)
{
object ao = Schema.Elements[ext.BaseTypeName];
//string data = ao.ToString();
}
WriteExampleParticle(ext.Particle, writer);
}
}
}
if (type.Particle != null)
{
WriteExampleParticle(type.Particle, writer);
}
}
void Parse_SimpleContent(TreeNode inner, XmlSchemaSimpleContent content)
{
XmlSchemaSimpleContentExtension ext = content.Content as XmlSchemaSimpleContentExtension;
XmlSchemaSimpleContentRestriction rst = content.Content as XmlSchemaSimpleContentRestriction;
if (ext != null)
{
Add_Attributes(inner, ext.Attributes, ext.AnyAttribute);
}
XmlQualifiedName qname = GetContentBaseType(content.Content);
TreeNode node = new TreeNode((GetBuiltInTypeName(qname)));
inner.Nodes.Add(node);
}
protected override void Visit(XmlSchemaSimpleContentRestriction restriction)
{
if (restriction.Facets.Count == 0)
{
TraverseBaseType(restriction.BaseTypeName);
}
else
{
PushNode(SimpleTypeStructureNodeType.Restriction, restriction);
TraverseBaseType(restriction.BaseTypeName);
Traverse(restriction.Facets);
PopNode();
}
}
public void GetExpectedValues(XmlSchemaType si, XmlIntellisenseList list)
{
if (si == null)
{
return;
}
if (si is XmlSchemaSimpleType)
{
XmlSchemaSimpleType st = (XmlSchemaSimpleType)si;
GetExpectedValues(st, list);
}
else if (si is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = (XmlSchemaComplexType)si;
if (ct.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent cc = (XmlSchemaComplexContent)ct.ContentModel;
if (cc.Content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension ce = (XmlSchemaComplexContentExtension)cc.Content;
GetExpectedValues(GetTypeInfo(ce.BaseTypeName), list);
}
else if (cc.Content is XmlSchemaComplexContentRestriction)
{
XmlSchemaComplexContentRestriction cr = (XmlSchemaComplexContentRestriction)cc.Content;
GetExpectedValues(GetTypeInfo(cr.BaseTypeName), list);
}
}
else if (ct.ContentModel is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent sc = (XmlSchemaSimpleContent)ct.ContentModel;
if (sc.Content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension ce = (XmlSchemaSimpleContentExtension)sc.Content;
GetExpectedValues(GetTypeInfo(ce.BaseTypeName), list);
}
else if (sc.Content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction cr = (XmlSchemaSimpleContentRestriction)sc.Content;
GetExpectedValues(GetTypeInfo(cr.BaseTypeName), list);
}
}
}
return;
}
private void Write40_XmlSchemaSimpleContentRestriction(XmlSchemaSimpleContentRestriction o)
{
if (o != null)
{
this.WriteStartElement("restriction");
this.WriteAttribute("id", "", o.Id);
this.WriteAttributes(o.UnhandledAttributes, o);
if (!o.BaseTypeName.IsEmpty)
{
this.WriteAttribute("base", "", o.BaseTypeName);
}
this.Write5_XmlSchemaAnnotation(o.Annotation);
this.Write9_XmlSchemaSimpleType(o.BaseType);
this.WriteFacets(o.Facets);
this.WriteSortedItems(o.Attributes);
this.Write33_XmlSchemaAnyAttribute(o.AnyAttribute);
this.WriteEndElement();
}
}
void Write40_XmlSchemaSimpleContentRestriction(XmlSchemaSimpleContentRestriction o)
{
if ((object)o == null)
{
return;
}
WriteStartElement("restriction");
WriteAttribute(@"id", @"", ((System.String)o.@Id));
WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o);
if ([email protected])
{
WriteAttribute(@"base", @"", o.@BaseTypeName);
}
Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation);
Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.@BaseType);
WriteFacets(o.Facets);
WriteSortedItems(o.Attributes);
Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.@AnyAttribute);
WriteEndElement();
}
public XmlQualifiedName GetBaseTypeName(XmlSchemaComplexType ct)
{
XmlSchemaSimpleContent sc = ct.ContentModel as XmlSchemaSimpleContent;
if (sc == null)
{
return(null);
}
XmlSchemaSimpleContentExtension ex = sc.Content as XmlSchemaSimpleContentExtension;
if (ex != null)
{
return(ex.BaseTypeName);
}
XmlSchemaSimpleContentRestriction cr = sc.Content as XmlSchemaSimpleContentRestriction;
if (cr != null)
{
return(cr.BaseTypeName);
}
return(null);
}
public ElementWrapper(XmlSchemaElement element, bool collectSubElements)
{
this.element = element;
this.schema = GetSchema();
XmlSchemaComplexType ct = this.ComplexType;
if (collectSubElements && ct != null)
{
GetAnnotations();
CollectSubElements();
CheckForSimpleRestriction();
CollectAttributes(ct.Attributes);
XmlSchemaSimpleContentExtension scex = this.SimpleContentExtension;
if (scex != null)
{
CollectAttributes(scex.Attributes);
}
XmlSchemaSimpleContentRestriction scr = this.SimpleContentRestriction;
if (scr != null)
{
CollectAttributes(scr.Attributes);
}
}
}
private void BuildContentModel(XmlSchemaComplexType type,
ObjectDef def)
{
if (type.ContentModel != null)
{
if (type.ContentModel is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent content = type.ContentModel as XmlSchemaSimpleContent;
XmlSchemaSimpleContentRestriction restriction =
content.Content as XmlSchemaSimpleContentRestriction;
if (restriction != null)
{
FieldDef field;
bool isEnum;
string dataType =
GetClassTypeFromDataType
(restriction.BaseType, type.QualifiedName.Name, def.Name,
out isEnum);
if (isEnum)
{
field = def.DefineElement(type.QualifiedName.Name, null);
field.SetEnum(dataType);
}
else
{
field = def.DefineElement(type.QualifiedName.Name, dataType);
}
if ((type.Particle != null && type.Particle.MinOccurs > 0) ||
(type.ContentTypeParticle != null && type.ContentTypeParticle.MinOccurs > 0))
{
field.SetFlags("M");
}
}
else
{
XmlSchemaSimpleContentExtension extension =
content.Content as XmlSchemaSimpleContentExtension;
BuildAttributes(extension.Attributes, def);
//FieldDef field = def.defineElement( type.QualifiedName.Name, extension.BaseTypeName.Name );
}
}
else if (type.Particle == null && type.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent complexContent =
type.ContentModel as XmlSchemaComplexContent;
XmlSchemaComplexContentExtension ext =
type.ContentModel.Content as XmlSchemaComplexContentExtension;
if (type.BaseXmlSchemaType != null)
{
XmlSchemaComplexType baseType =
type.BaseXmlSchemaType as XmlSchemaComplexType;
if (baseType != null)
{
BuildContentModel(baseType, def);
}
}
if (ext != null && ext.Particle != null)
{
if (ext.BaseTypeName != null)
{
object ao = Schema.Elements[ext.BaseTypeName];
//string data = ao.ToString();
}
BuildParticle(ext.Particle, def, true);
}
}
}
else if (type.Particle != null)
{
try {
BuildParticle(type.Particle, def, true);
}
catch (SchemaNotImplementedException xse) {
Console.WriteLine
("Type Not Implemented: " + type.QualifiedName + " : " +
xse.Particle.ToString() + xse.Particle.SourceUri + ":" +
xse.Particle.LineNumber);
}
}
}
static void Check(ConformanceCheckContext ctx, ConformanceChecker checker, Hashtable visitedObjects, XmlSchemaObject value)
{
if (value == null)
{
return;
}
if (visitedObjects.Contains(value))
{
return;
}
visitedObjects.Add(value, value);
if (value is XmlSchemaImport)
{
XmlSchemaImport so = (XmlSchemaImport)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaAll)
{
XmlSchemaAll so = (XmlSchemaAll)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaAnnotation)
{
XmlSchemaAnnotation so = (XmlSchemaAnnotation)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaAttribute)
{
XmlSchemaAttribute so = (XmlSchemaAttribute)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaAttributeGroup)
{
XmlSchemaAttributeGroup so = (XmlSchemaAttributeGroup)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
Check(ctx, checker, visitedObjects, so.RedefinedAttributeGroup);
}
else if (value is XmlSchemaAttributeGroupRef)
{
XmlSchemaAttributeGroupRef so = (XmlSchemaAttributeGroupRef)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaChoice)
{
XmlSchemaChoice so = (XmlSchemaChoice)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaComplexContent)
{
XmlSchemaComplexContent so = (XmlSchemaComplexContent)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension so = (XmlSchemaComplexContentExtension)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaComplexContentRestriction)
{
XmlSchemaComplexContentRestriction so = (XmlSchemaComplexContentRestriction)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaComplexType)
{
XmlSchemaComplexType so = (XmlSchemaComplexType)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.ContentModel);
Check(ctx, checker, visitedObjects, so.Particle);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
Check(ctx, checker, visitedObjects, so.ContentTypeParticle);
Check(ctx, checker, visitedObjects, so.AttributeWildcard);
}
else if (value is XmlSchemaElement)
{
XmlSchemaElement so = (XmlSchemaElement)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.SchemaType);
CheckObjects(ctx, checker, visitedObjects, so.Constraints);
}
else if (value is XmlSchemaGroup)
{
XmlSchemaGroup so = (XmlSchemaGroup)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Particle);
}
else if (value is XmlSchemaGroupRef)
{
XmlSchemaGroupRef so = (XmlSchemaGroupRef)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaIdentityConstraint)
{
XmlSchemaIdentityConstraint so = (XmlSchemaIdentityConstraint)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Fields);
Check(ctx, checker, visitedObjects, so.Selector);
}
else if (value is XmlSchemaKeyref)
{
XmlSchemaKeyref so = (XmlSchemaKeyref)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaRedefine)
{
XmlSchemaRedefine so = (XmlSchemaRedefine)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaSequence)
{
XmlSchemaSequence so = (XmlSchemaSequence)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Items);
}
else if (value is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent so = (XmlSchemaSimpleContent)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension so = (XmlSchemaSimpleContentExtension)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
}
else if (value is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction so = (XmlSchemaSimpleContentRestriction)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Attributes);
Check(ctx, checker, visitedObjects, so.AnyAttribute);
CheckObjects(ctx, checker, visitedObjects, so.Facets);
}
else if (value is XmlSchemaSimpleType)
{
XmlSchemaSimpleType so = (XmlSchemaSimpleType)value;
checker.Check(ctx, so);
Check(ctx, checker, visitedObjects, so.Content);
}
else if (value is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList so = (XmlSchemaSimpleTypeList)value;
checker.Check(ctx, so);
}
else if (value is XmlSchemaSimpleTypeRestriction)
{
XmlSchemaSimpleTypeRestriction so = (XmlSchemaSimpleTypeRestriction)value;
checker.Check(ctx, so);
CheckObjects(ctx, checker, visitedObjects, so.Facets);
}
else if (value is XmlSchemaSimpleTypeUnion)
{
XmlSchemaSimpleTypeUnion so = (XmlSchemaSimpleTypeUnion)value;
checker.Check(ctx, so);
}
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if (item == null || scope[item] != null)
{
return;
}
Type t = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(t))
{
XmlQualifiedName baseName = XmlQualifiedName.Empty;
XmlSchemaType baseType = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType ct = (XmlSchemaComplexType)item;
if (ct.ContentModel != null)
{
XmlSchemaContent content = ct.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
baseName = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
baseType = restriction.BaseType;
}
else
{
baseName = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
baseName = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content;
attributes = extension.Attributes;
baseName = extension.BaseTypeName;
}
}
else
{
attributes = ct.Attributes;
particle = ct.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef refGroup = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)schemas.Find(refGroup.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content = simpleType.Content;
if (content is XmlSchemaSimpleTypeRestriction)
{
baseType = ((XmlSchemaSimpleTypeRestriction)content).BaseType;
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (content is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content;
if (list.ItemTypeName != null && !list.ItemTypeName.IsEmpty)
{
baseName = list.ItemTypeName;
}
if (list.ItemType != null)
{
baseType = list.ItemType;
}
}
else if (content is XmlSchemaSimpleTypeRestriction)
{
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (t == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
if (baseType == null && !baseName.IsEmpty && baseName.Namespace != XmlSchema.Namespace)
{
baseType = (XmlSchemaType)schemas.Find(baseName, typeof(XmlSchemaType), false);
}
if (baseType != null)
{
AddRef(refs, baseType);
}
if (particle != null)
{
Depends(particle, refs);
}
if (attributes != null)
{
for (int i = 0; i < attributes.Count; i++)
{
Depends(attributes[i], refs);
}
}
}
else if (t == typeof(XmlSchemaElement))
{
XmlSchemaElement el = (XmlSchemaElement)item;
if (!el.SubstitutionGroup.IsEmpty)
{
if (el.SubstitutionGroup.Namespace != XmlSchema.Namespace)
{
XmlSchemaElement head = (XmlSchemaElement)schemas.Find(el.SubstitutionGroup, typeof(XmlSchemaElement), false);
AddRef(refs, head);
}
}
if (!el.RefName.IsEmpty)
{
el = (XmlSchemaElement)schemas.Find(el.RefName, typeof(XmlSchemaElement), false);
AddRef(refs, el);
}
else if (!el.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(el.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(el.SchemaType, refs);
}
}
else if (t == typeof(XmlSchemaGroup))
{
Depends(((XmlSchemaGroup)item).Particle);
}
else if (t == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(t))
{
foreach (XmlSchemaObject o in ((XmlSchemaGroupBase)item).Items)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group = (XmlSchemaAttributeGroup)schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
AddRef(refs, group);
}
else if (t == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject o in ((XmlSchemaAttributeGroup)item).Attributes)
{
Depends(o, refs);
}
}
else if (t == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute at = (XmlSchemaAttribute)item;
if (!at.RefName.IsEmpty)
{
at = (XmlSchemaAttribute)schemas.Find(at.RefName, typeof(XmlSchemaAttribute), false);
AddRef(refs, at);
}
else if (!at.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)schemas.Find(at.SchemaTypeName, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
else
{
Depends(at.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(t))
{
XmlAttribute[] attrs = (XmlAttribute[])((XmlSchemaAnnotated)item).UnhandledAttributes;
if (attrs != null)
{
for (int i = 0; i < attrs.Length; i++)
{
XmlAttribute attribute = attrs[i];
if (attribute.LocalName == Wsdl.ArrayType && attribute.NamespaceURI == Wsdl.Namespace)
{
string dims;
XmlQualifiedName qname = TypeScope.ParseWsdlArrayType(attribute.Value, out dims, item);
XmlSchemaType type = (XmlSchemaType)schemas.Find(qname, typeof(XmlSchemaType), false);
AddRef(refs, type);
}
}
}
}
}
protected override void Visit(XmlSchemaSimpleContentRestriction restriction)
{
ProcessRestriction(restriction.BaseTypeName, restriction.Attributes, restriction.AnyAttribute);
}
public override void Check(ConformanceCheckContext ctx, XmlSchemaSimpleContentRestriction value)
{
CheckSchemaQName(ctx, value, value.BaseTypeName);
}
public virtual void Check(ConformanceCheckContext ctx, XmlSchemaSimpleContentRestriction value)
{
}
static XmlSchemaElement CreateBbieSchemaElement(IBbie bbie, GeneratorContext context)
{
// R 89A6: for every BBIE a named element must be locally declared
XmlSchemaElement elementBBIE = new XmlSchemaElement();
// R AEFE, R 96D9, R9A40, R A34A are implemented in GetXsdElementNameFromBbie(...)
elementBBIE.Name = NDR.GetXsdElementNameFromBbie(bbie);
// 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.
if (bbie.Bdt != null && bbie.Bdt.Con != null)
{
if (bbie.Bdt.Con.BasicType != null && bbie.Bdt.Con.BasicType.IsEnum)
{
//figure out if the set of values is restricted
var basicEnum = bbie.Bdt.Con.BasicType.Enum as UpccEnum;
//use this method only if there are values specified in the basic enum. If not then we simply use the type
if (basicEnum != null && basicEnum.CodelistEntries.Any())
{
var sourceEnum = basicEnum.SourceElement as UpccEnum;
if (sourceEnum != null)
{
var restrictedtype = new XmlSchemaComplexType();
var sympleContent = new XmlSchemaSimpleContent();
var restriction = new XmlSchemaSimpleContentRestriction();
restriction.BaseTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetXsdTypeNameFromBdt(bbie.Bdt));
addEnumerationValues(restriction, basicEnum);
//add restriction to simplecontent
sympleContent.Content = restriction;
//add the restriction to the simple type
restrictedtype.ContentModel = sympleContent;
//set the type of the BBIE
elementBBIE.SchemaType = restrictedtype;
}
}
}
if (bbie.Bdt.isDirectXSDType)
{
var XSDtype = bbie.Bdt.xsdType;
if (!string.IsNullOrEmpty(XSDtype))
{
if (bbie.Bdt.Con.AllFacets.Any())
{
//add facets
var restrictedtype = new XmlSchemaSimpleType();
var restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName(NSPREFIX_XSD + ":" + XSDtype);
NDR.addFacets(restriction, bbie.Bdt.Con.AllFacets);
//add the restriction to the simple type
restrictedtype.Content = restriction;
//set the type of the BBIE
elementBBIE.SchemaType = restrictedtype;
}
else
{
elementBBIE.SchemaTypeName = new XmlQualifiedName(NSPREFIX_XSD + ":" + XSDtype);
}
}
}
if (bbie.Facets.Any())
{
//add facets
if (bbie.Bdt.Sups.Any())
{
//create a complex type
var complexType = new XmlSchemaComplexType();
//add the simple content extension
var simpleContent = new XmlSchemaSimpleContent();
var restriction = new XmlSchemaSimpleContentRestriction();
restriction.BaseTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetXsdTypeNameFromBdt(bbie.Bdt));
//add the facets
NDR.addFacets(restriction, bbie.Facets);
//add the simple content to the complex object
simpleContent.Content = restriction;
complexType.ContentModel = simpleContent;
//add the complex type to the element
elementBBIE.SchemaType = complexType;
}
else
{
//create a simple type
var restrictedtype = new XmlSchemaSimpleType();
var restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetXsdTypeNameFromBdt(bbie.Bdt));
NDR.addFacets(restriction, bbie.Facets);
//add the restriction to the simple type
restrictedtype.Content = restriction;
//set the type of the BBIE
elementBBIE.SchemaType = restrictedtype;
}
}
if (elementBBIE.SchemaType == null && elementBBIE.SchemaTypeName.IsEmpty)
{
//use type without facets
elementBBIE.SchemaTypeName = new XmlQualifiedName(context.NamespacePrefix + ":" + NDR.GetXsdTypeNameFromBdt(bbie.Bdt));
}
}
// R 90F9: cardinality of elements within the ABIE
elementBBIE.MinOccursString = AdjustLowerBound(bbie.LowerBound);
elementBBIE.MaxOccursString = AdjustUpperBound(bbie.UpperBound);
return(elementBBIE);
}
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
if ((item != null) && (this.scope[item] == null))
{
Type c = item.GetType();
if (typeof(XmlSchemaType).IsAssignableFrom(c))
{
XmlQualifiedName empty = XmlQualifiedName.Empty;
XmlSchemaType o = null;
XmlSchemaParticle particle = null;
XmlSchemaObjectCollection attributes = null;
if (item is XmlSchemaComplexType)
{
XmlSchemaComplexType type3 = (XmlSchemaComplexType)item;
if (type3.ContentModel != null)
{
XmlSchemaContent content = type3.ContentModel.Content;
if (content is XmlSchemaComplexContentRestriction)
{
empty = ((XmlSchemaComplexContentRestriction)content).BaseTypeName;
attributes = ((XmlSchemaComplexContentRestriction)content).Attributes;
}
else if (content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction)content;
if (restriction.BaseType != null)
{
o = restriction.BaseType;
}
else
{
empty = restriction.BaseTypeName;
}
attributes = restriction.Attributes;
}
else if (content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content;
attributes = extension.Attributes;
particle = extension.Particle;
empty = extension.BaseTypeName;
}
else if (content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension extension2 = (XmlSchemaSimpleContentExtension)content;
attributes = extension2.Attributes;
empty = extension2.BaseTypeName;
}
}
else
{
attributes = type3.Attributes;
particle = type3.Particle;
}
if (particle is XmlSchemaGroupRef)
{
XmlSchemaGroupRef ref2 = (XmlSchemaGroupRef)particle;
particle = ((XmlSchemaGroup)this.schemas.Find(ref2.RefName, typeof(XmlSchemaGroup), false)).Particle;
}
else if (particle is XmlSchemaGroupBase)
{
particle = (XmlSchemaGroupBase)particle;
}
}
else if (item is XmlSchemaSimpleType)
{
XmlSchemaSimpleType type4 = (XmlSchemaSimpleType)item;
XmlSchemaSimpleTypeContent content2 = type4.Content;
if (content2 is XmlSchemaSimpleTypeRestriction)
{
o = ((XmlSchemaSimpleTypeRestriction)content2).BaseType;
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (content2 is XmlSchemaSimpleTypeList)
{
XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList)content2;
if ((list.ItemTypeName != null) && !list.ItemTypeName.IsEmpty)
{
empty = list.ItemTypeName;
}
if (list.ItemType != null)
{
o = list.ItemType;
}
}
else if (content2 is XmlSchemaSimpleTypeRestriction)
{
empty = ((XmlSchemaSimpleTypeRestriction)content2).BaseTypeName;
}
else if (c == typeof(XmlSchemaSimpleTypeUnion))
{
XmlQualifiedName[] memberTypes = ((XmlSchemaSimpleTypeUnion)item).MemberTypes;
if (memberTypes != null)
{
for (int i = 0; i < memberTypes.Length; i++)
{
XmlSchemaType type5 = (XmlSchemaType)this.schemas.Find(memberTypes[i], typeof(XmlSchemaType), false);
this.AddRef(refs, type5);
}
}
}
}
if (((o == null) && !empty.IsEmpty) && (empty.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
o = (XmlSchemaType)this.schemas.Find(empty, typeof(XmlSchemaType), false);
}
if (o != null)
{
this.AddRef(refs, o);
}
if (particle != null)
{
this.Depends(particle, refs);
}
if (attributes != null)
{
for (int j = 0; j < attributes.Count; j++)
{
this.Depends(attributes[j], refs);
}
}
}
else if (c == typeof(XmlSchemaElement))
{
XmlSchemaElement element = (XmlSchemaElement)item;
if (!element.SubstitutionGroup.IsEmpty && (element.SubstitutionGroup.Namespace != "http://www.w3.org/2001/XMLSchema"))
{
XmlSchemaElement element2 = (XmlSchemaElement)this.schemas.Find(element.SubstitutionGroup, typeof(XmlSchemaElement), false);
this.AddRef(refs, element2);
}
if (!element.RefName.IsEmpty)
{
element = (XmlSchemaElement)this.schemas.Find(element.RefName, typeof(XmlSchemaElement), false);
this.AddRef(refs, element);
}
else if (!element.SchemaTypeName.IsEmpty)
{
XmlSchemaType type6 = (XmlSchemaType)this.schemas.Find(element.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type6);
}
else
{
this.Depends(element.SchemaType, refs);
}
}
else if (c == typeof(XmlSchemaGroup))
{
this.Depends(((XmlSchemaGroup)item).Particle);
}
else if (c == typeof(XmlSchemaGroupRef))
{
XmlSchemaGroup group = (XmlSchemaGroup)this.schemas.Find(((XmlSchemaGroupRef)item).RefName, typeof(XmlSchemaGroup), false);
this.AddRef(refs, group);
}
else if (typeof(XmlSchemaGroupBase).IsAssignableFrom(c))
{
foreach (XmlSchemaObject obj2 in ((XmlSchemaGroupBase)item).Items)
{
this.Depends(obj2, refs);
}
}
else if (c == typeof(XmlSchemaAttributeGroupRef))
{
XmlSchemaAttributeGroup group2 = (XmlSchemaAttributeGroup)this.schemas.Find(((XmlSchemaAttributeGroupRef)item).RefName, typeof(XmlSchemaAttributeGroup), false);
this.AddRef(refs, group2);
}
else if (c == typeof(XmlSchemaAttributeGroup))
{
foreach (XmlSchemaObject obj3 in ((XmlSchemaAttributeGroup)item).Attributes)
{
this.Depends(obj3, refs);
}
}
else if (c == typeof(XmlSchemaAttribute))
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)item;
if (!attribute.RefName.IsEmpty)
{
attribute = (XmlSchemaAttribute)this.schemas.Find(attribute.RefName, typeof(XmlSchemaAttribute), false);
this.AddRef(refs, attribute);
}
else if (!attribute.SchemaTypeName.IsEmpty)
{
XmlSchemaType type7 = (XmlSchemaType)this.schemas.Find(attribute.SchemaTypeName, typeof(XmlSchemaType), false);
this.AddRef(refs, type7);
}
else
{
this.Depends(attribute.SchemaType, refs);
}
}
if (typeof(XmlSchemaAnnotated).IsAssignableFrom(c))
{
XmlAttribute[] unhandledAttributes = ((XmlSchemaAnnotated)item).UnhandledAttributes;
if (unhandledAttributes != null)
{
for (int k = 0; k < unhandledAttributes.Length; k++)
{
XmlAttribute attribute2 = unhandledAttributes[k];
if ((attribute2.LocalName == "arrayType") && (attribute2.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/"))
{
string str;
XmlQualifiedName name = TypeScope.ParseWsdlArrayType(attribute2.Value, out str, item);
XmlSchemaType type8 = (XmlSchemaType)this.schemas.Find(name, typeof(XmlSchemaType), false);
this.AddRef(refs, type8);
}
}
}
}
}
}
protected override void Visit(XmlSchemaSimpleContentRestriction restriction)
{
AddBaseTypeUsage(restriction.BaseTypeName);
base.Visit(restriction);
}
protected override void Visit(XmlSchemaSimpleContentRestriction restriction)
{
// Don't visit the base type. Complex Type restrictions replace
// the base type's nodes and attributes.
}
internal static XmlSchema BuildSchema(DiscoveryVersion version)
{
var schema = new XmlSchema()
{
TargetNamespace = version.Namespace
};
var anyAttr = new XmlSchemaAnyAttribute()
{
Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax
};
var probePart = new XmlSchemaSequence();
probePart.Items.Add(new XmlSchemaElement()
{
RefName = new XmlQualifiedName("Types", version.Namespace), MinOccurs = 0
});
probePart.Items.Add(new XmlSchemaElement()
{
RefName = new XmlQualifiedName("Scopes", version.Namespace), MinOccurs = 0
});
probePart.Items.Add(new XmlSchemaAny()
{
MinOccurs = 0, MaxOccursString = "unbounded", Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax
});
var ct = new XmlSchemaComplexType()
{
Name = "ProbeType", Particle = probePart, AnyAttribute = anyAttr
};
schema.Items.Add(ct);
schema.Items.Add(new XmlSchemaSimpleType()
{
Name = "QNameListType", Content = new XmlSchemaSimpleTypeList()
{
ItemTypeName = new XmlQualifiedName("QName", XmlSchema.Namespace)
}
});
var scr = new XmlSchemaSimpleContentRestriction()
{
BaseTypeName = new XmlQualifiedName("UriListType", version.Namespace), AnyAttribute = anyAttr
};
scr.Attributes.Add(new XmlSchemaAttribute()
{
Name = "matchBy", SchemaTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace)
});
schema.Items.Add(new XmlSchemaComplexType()
{
Name = "ScopesType", ContentModel = new XmlSchemaSimpleContent()
{
Content = scr
}
});
schema.Items.Add(new XmlSchemaSimpleType()
{
Name = "UriListType", Content = new XmlSchemaSimpleTypeList()
{
ItemTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace)
}
});
schema.Items.Add(new XmlSchemaElement()
{
Name = "Types", SchemaTypeName = new XmlQualifiedName("QNameListType", version.Namespace)
});
schema.Items.Add(new XmlSchemaElement()
{
Name = "Scopes", SchemaTypeName = new XmlQualifiedName("ScopesType", version.Namespace)
});
return(schema);
}
