private double text = double.NaN; // double for future generalization
#region constructors
public IntBox()
{
baseSchema = new XmlSchema();
//<xs:complexType name="IntBoxN"> first time is empty
XmlSchemaComplexType newType = new XmlSchemaComplexType();
newType.Name = "";
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="IntBox">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("IntBox");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:integer"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("integer", "http://www.w3.org/2001/XMLSchema");
}
public FiscalCode()
{
baseSchema = new XmlSchema();
//<xs:complexType name="FiscalCodeN">
XmlSchemaComplexType newType = new XmlSchemaComplexType();
// the name must be filled later
newType.Name = "";
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="FiscalCode">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("FiscalCode");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:string"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
this.AddPatternConstraint(@"[a-zA-Z]{6}\d\d[a-zA-Z]\d\d[a-zA-Z]\d\d\d[a-zA-Z]");
}
public CheckBoxField()
{
baseSchema = new XmlSchema();
//<xs:complexType name="CheckBoxN">
XmlSchemaComplexType newType = new XmlSchemaComplexType();
// the name must be filled later
newType.Name = "";
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="CheckBox">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("CheckBoxField");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:boolean" defeult="false" />
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("boolean", "http://www.w3.org/2001/XMLSchema");
elem.DefaultValue = "false";
}
internal void ReflectStringParametersMessage()
{
Message inputMessage = InputMessage;
foreach (ParameterInfo parameterInfo in Method.InParameters)
{
MessagePart part = new MessagePart();
part.Name = XmlConvert.EncodeLocalName(parameterInfo.Name);
if (parameterInfo.ParameterType.IsArray)
{
string typeNs = DefaultNamespace;
if (typeNs.EndsWith("/", StringComparison.Ordinal))
{
typeNs += "AbstractTypes";
}
else
{
typeNs += "/AbstractTypes";
}
string typeName = "StringArray";
if (!ServiceDescription.Types.Schemas.Contains(typeNs))
{
XmlSchema schema = new XmlSchema();
schema.TargetNamespace = typeNs;
ServiceDescription.Types.Schemas.Add(schema);
XmlSchemaElement element = new XmlSchemaElement();
element.Name = "String";
element.SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace);
element.MinOccurs = decimal.Zero;
element.MaxOccurs = decimal.MaxValue;
XmlSchemaSequence all = new XmlSchemaSequence();
all.Items.Add(element);
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
restriction.BaseTypeName = new XmlQualifiedName(Soap.ArrayType, Soap.Encoding);
restriction.Particle = all;
XmlSchemaImport import = new XmlSchemaImport();
import.Namespace = restriction.BaseTypeName.Namespace;
XmlSchemaComplexContent model = new XmlSchemaComplexContent();
model.Content = restriction;
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.Name = typeName;
type.ContentModel = model;
schema.Items.Add(type);
schema.Includes.Add(import);
}
part.Type = new XmlQualifiedName(typeName, typeNs);
}
else
{
part.Type = new XmlQualifiedName("string", XmlSchema.Namespace);
}
inputMessage.Parts.Add(part);
}
}
public static IEnumerable <XmlSchemaElement> LocalXsdElements(this XmlSchemaType ty)
{
XmlSchemaComplexType iteratorVariable0 = ty as XmlSchemaComplexType;
if (iteratorVariable0 != null)
{
if (iteratorVariable0.ContentModel != null)
{
XmlSchemaComplexContent contentModel = iteratorVariable0.ContentModel as XmlSchemaComplexContent;
if (contentModel != null)
{
XmlSchemaComplexContentExtension content = contentModel.Content as XmlSchemaComplexContentExtension;
if (content != null)
{
foreach (XmlSchemaElement iteratorVariable4 in content.Particle.LocalXsdElements())
{
yield return(iteratorVariable4);
}
}
}
}
else
{
foreach (XmlSchemaElement iteratorVariable1 in iteratorVariable0.Particle.LocalXsdElements())
{
yield return(iteratorVariable1);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ColorPicker"/> class.
/// </summary>
public ColorPicker()
{
baseSchema = new XmlSchema();
//<xs:complexType name="ColorPickerN">
XmlSchemaComplexType newType = new XmlSchemaComplexType();
// the name must be filled later
newType.Name = "";
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="ColorPicker">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("ColorPicker");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:string"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
}
static XmlSchemaType AddElementTypeToXmlSchema(IUxmlFactory factory, SchemaInfo schemaInfo, FactoryProcessingHelper processingData)
{
// We always have complex types with complex content.
XmlSchemaComplexType elementType = new XmlSchemaComplexType();
elementType.Name = factory.uxmlName + k_TypeSuffix;
XmlSchemaComplexContent content = new XmlSchemaComplexContent();
elementType.ContentModel = content;
// We only support restrictions of base types.
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
content.Content = restriction;
if (factory.substituteForTypeName == String.Empty)
{
restriction.BaseTypeName = new XmlQualifiedName("anyType", k_XmlSchemaNamespace);
}
else
{
restriction.BaseTypeName = new XmlQualifiedName(factory.substituteForTypeName + k_TypeSuffix, factory.substituteForTypeNamespace);
schemaInfo.importNamespaces.Add(factory.substituteForTypeNamespace);
}
if (factory.canHaveAnyAttribute)
{
XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
anyAttribute.ProcessContents = XmlSchemaContentProcessing.Lax;
restriction.AnyAttribute = anyAttribute;
}
foreach (UxmlAttributeDescription attrDesc in factory.uxmlAttributesDescription)
{
XmlQualifiedName typeName = AddAttributeTypeToXmlSchema(schemaInfo, attrDesc, factory, processingData);
if (typeName != null)
{
AddAttributeToXmlSchema(restriction, attrDesc, typeName);
schemaInfo.importNamespaces.Add(attrDesc.typeNamespace);
}
}
bool hasChildElements = false;
foreach (UxmlChildElementDescription childDesc in factory.uxmlChildElementsDescription)
{
hasChildElements = true;
schemaInfo.importNamespaces.Add(childDesc.elementNamespace);
}
if (hasChildElements)
{
restriction.Particle = MakeChoiceSequence(factory.uxmlChildElementsDescription);
}
schemaInfo.schema.Items.Add(elementType);
return(elementType);
}
public FiscalCode(XmlSchema schema, string name)
{
// in this constructor it's useful to set the ID, cause GUI is calling it
this.Name = name;
baseSchema = new XmlSchema();
//<xs:complexType name="FiscalCodeN">
XmlSchemaComplexType newType = new XmlSchemaComplexType();
newType.Name = ((XmlSchemaComplexType)schema.Items[0]).Name;
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="FiscalCode">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("FiscalCode");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:string"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
//check empty element value
if (Common.getElementFromSchema(schema).IsNillable)
{
elem.IsNillable = true;
}
if (((XmlSchemaSimpleType)Common.getElementFromSchema(schema).SchemaType) == null)
{
return;
}
XmlSchemaObjectCollection constrColl =
((XmlSchemaSimpleTypeRestriction)
((XmlSchemaSimpleType)
Common.getElementFromSchema(schema)
.SchemaType).Content).Facets;
foreach (XmlSchemaFacet facet in constrColl)
{
Common.addFacet(facet, Common.getElementFromSchema(baseSchema));
}
}
public IntBox(XmlSchema schema, string name)
{
this.Name = name;
baseSchema = new XmlSchema();
//<xs:complexType name="IntBoxN">
XmlSchemaComplexType newType = new XmlSchemaComplexType();
newType.Name = ((XmlSchemaComplexType)schema.Items[0]).Name;
baseSchema.Items.Add(newType);
//<xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
newType.ContentModel = complexContent;
//<xs:extension base="IntBox">
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = complexContentExtension;
complexContentExtension.BaseTypeName = new XmlQualifiedName("IntBox");
//<xs:sequence>
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
//<xs:element name="Value" type="xs:integer"/>
XmlSchemaElement elem = new XmlSchemaElement();
seq.Items.Add(elem);
elem.Name = "Value";
elem.SchemaTypeName = new XmlQualifiedName("integer", "http://www.w3.org/2001/XMLSchema");
//Controlla se l'element potra' avere valore vuoto
if (Common.getElementFromSchema(schema).IsNillable)
{
elem.IsNillable = true;
}
// TODO: find another way to get Items[0], it is not correct.
if (((XmlSchemaSimpleType)Common.getElementFromSchema(schema).SchemaType) == null)
{
return;
}
XmlSchemaObjectCollection constrColl =
((XmlSchemaSimpleTypeRestriction)
((XmlSchemaSimpleType)
Common.getElementFromSchema(schema)
.SchemaType).Content).Facets;
foreach (XmlSchemaFacet facet in constrColl)
{
Common.addFacet(facet, Common.getElementFromSchema(baseSchema));
}
}
private void CopyDataType(XmlSchemaComplexType complexType)
{
if (FindDataType(destinationSchema, complexType.Name) != null)
{
return;
}
XmlSchemaComplexType newComplexType = new XmlSchemaComplexType()
{
Name = complexType.Name,
IsMixed = complexType.IsMixed,
IsAbstract = complexType.IsAbstract,
};
destinationSchema.Items.Add(newComplexType);
// Add annotation to indicate where it was copied from
newComplexType.Annotation = CreateAnnotation("Data type copied from base schema (" + sourceSchema.TargetNamespace + ")");
// Copy children
XmlSchemaSequence particleSequence = complexType.Particle as XmlSchemaSequence;
XmlSchemaComplexContent complexContent = complexType.ContentModel as XmlSchemaComplexContent;
if (particleSequence != null)
{
XmlSchemaSequence newParticleSequence = new XmlSchemaSequence();
newComplexType.Particle = newParticleSequence;
foreach (var currentObject in particleSequence.Items)
{
if (currentObject is XmlSchemaElement)
{
XmlSchemaElement newElement = Copy(currentObject as XmlSchemaElement);
newParticleSequence.Items.Add(newElement);
}
}
}
else if (complexContent != null)
{
XmlSchemaComplexContent newComplexContent = new XmlSchemaComplexContent();
newComplexType.ContentModel = newComplexContent;
newComplexContent.IsMixed = complexContent.IsMixed;
if (complexContent.Content != null)
{
XmlSchemaContent newContent = Copy(complexContent.Content);
newComplexContent.Content = newContent;
}
}
foreach (var attribute in complexType.Attributes.Cast <XmlSchemaAttribute>())
{
XmlSchemaAttribute newAttribute = this.Copy(attribute);
newComplexType.Attributes.Add(newAttribute);
}
}
XmlQualifiedName ExportArrayMapping(ArrayMapping mapping, string ns)
{
// for the Rpc ArrayMapping different mappings could have the same schema type
// we link all mappings corresponding to the same type together
// loop through all mapping that will map to the same complexType, and export only one,
// the obvious choice is the last one.
while (mapping.Next != null)
{
mapping = mapping.Next;
}
XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping];
if (type == null)
{
CheckForDuplicateType(mapping.TypeName, mapping.Namespace);
type = new XmlSchemaComplexType();
type.Name = mapping.TypeName;
types.Add(mapping, type);
// we need to add the type first, to make sure that the schema get created
AddSchemaItem(type, mapping.Namespace, ns);
AddSchemaImport(Soap.Encoding, mapping.Namespace);
AddSchemaImport(Wsdl.Namespace, mapping.Namespace);
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
XmlQualifiedName qname = ExportTypeMapping(mapping.Elements[0].Mapping, mapping.Namespace);
if (qname.IsEmpty)
{
// this is a root mapping
qname = new XmlQualifiedName(Soap.UrType, XmlSchema.Namespace);
}
//<attribute ref="soapenc:arrayType" wsdl:arrayType="xsd:float[]"/>
XmlSchemaAttribute attr = new XmlSchemaAttribute();
attr.RefName = ArrayTypeQName;
XmlAttribute attribute = new XmlAttribute("wsdl", Wsdl.ArrayType, Wsdl.Namespace, Document);
attribute.Value = qname.Namespace + ":" + qname.Name + "[]";
attr.UnhandledAttributes = new XmlAttribute[] { attribute };
restriction.Attributes.Add(attr);
restriction.BaseTypeName = ArrayQName;
XmlSchemaComplexContent model = new XmlSchemaComplexContent();
model.Content = restriction;
type.ContentModel = model;
if (qname.Namespace != XmlSchema.Namespace)
{
AddSchemaImport(qname.Namespace, mapping.Namespace);
}
}
else
{
AddSchemaImport(mapping.Namespace, ns);
}
return(new XmlQualifiedName(mapping.TypeName, mapping.Namespace));
}
XmlQualifiedName ExportStructMapping(StructMapping mapping, string ns)
{
if (mapping.TypeDesc.IsRoot)
{
needToExportRoot = true;
return(XmlQualifiedName.Empty);
}
XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping];
if (type == null)
{
if (!mapping.IncludeInSchema)
{
throw new InvalidOperationException(Res.GetString(Res.XmlCannotIncludeInSchema, mapping.TypeDesc.Name));
}
CheckForDuplicateType(mapping.TypeName, mapping.Namespace);
type = new XmlSchemaComplexType();
type.Name = mapping.TypeName;
types.Add(mapping, type);
AddSchemaItem(type, mapping.Namespace, ns);
type.IsAbstract = mapping.TypeDesc.IsAbstract;
if (mapping.BaseMapping != null && mapping.BaseMapping.IncludeInSchema)
{
if (mapping.HasSimpleContent)
{
XmlSchemaSimpleContent model = new XmlSchemaSimpleContent();
XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension();
extension.BaseTypeName = ExportStructMapping(mapping.BaseMapping, mapping.Namespace);
model.Content = extension;
type.ContentModel = model;
}
else
{
XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension();
extension.BaseTypeName = ExportStructMapping(mapping.BaseMapping, mapping.Namespace);
XmlSchemaComplexContent model = new XmlSchemaComplexContent();
model.Content = extension;
model.IsMixed = XmlSchemaImporter.IsMixed((XmlSchemaComplexType)types[mapping.BaseMapping]);
type.ContentModel = model;
}
}
ExportTypeMembers(type, mapping.Members, mapping.TypeName, mapping.Namespace, mapping.HasSimpleContent);
ExportDerivedMappings(mapping);
if (mapping.XmlnsMember != null)
{
AddXmlnsAnnotation(type, mapping.XmlnsMember.Name);
}
}
else
{
AddSchemaImport(mapping.Namespace, ns);
}
return(new XmlQualifiedName(type.Name, mapping.Namespace));
}
public RadioButtonList(XmlSchema schema, string name)
{
this.Name = name;
baseSchema = new XmlSchema();
XmlSchemaComplexType ctype = new XmlSchemaComplexType();
ctype.Name = ((XmlSchemaComplexType)schema.Items[0]).Name;
baseSchema.Items.Add(ctype);
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
XmlSchemaComplexContentExtension complexContentExtension = new XmlSchemaComplexContentExtension();
complexContentExtension.BaseTypeName = new XmlQualifiedName("RadioButtonList");
ctype.ContentModel = complexContent;
complexContent.Content = complexContentExtension;
XmlSchemaSequence seq = new XmlSchemaSequence();
complexContentExtension.Particle = seq;
XmlSchemaElement elem = new XmlSchemaElement();
elem.Name = "Value";
seq.Items.Add(elem);
if (Common.getElementFromSchema(schema).IsNillable)
{
elem.IsNillable = true;
}
XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType();
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");
elem.SchemaType = simpleType;
simpleType.Content = restriction;
//for direct access
elemPointer = elem;
//addning enumerations
XmlSchemaElement schemaElem = ((XmlSchemaElement)((XmlSchemaSequence)((XmlSchemaComplexContentExtension)((XmlSchemaComplexContent)((XmlSchemaComplexType)schema.Items[0]).ContentModel).Content).Particle).Items[0]);
XmlSchemaSimpleTypeRestriction schemaRestriction = ((XmlSchemaSimpleTypeRestriction)((XmlSchemaSimpleType)schemaElem.SchemaType).Content);
foreach (XmlSchemaFacet i in schemaRestriction.Facets)
{
XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet();
enumeration.Value = i.Value;
restriction.Facets.Add(enumeration);
}
}
static void AddAppSequenceType(DiscoveryVersion discoveryVersion, XmlSchema schema)
{
//<xs:complexType name="AppSequenceType" >
XmlSchemaComplexType appSequenceType = new XmlSchemaComplexType();
appSequenceType.Name = ProtocolStrings.SchemaNames.AppSequenceType;
// <xs:complexContent>
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
appSequenceType.ContentModel = complexContent;
// <xs:restriction base="xs:anyType" >
XmlSchemaComplexContentRestriction contentRestriction = new XmlSchemaComplexContentRestriction();
complexContent.Content = contentRestriction;
contentRestriction.BaseTypeName = discoveryVersion.Implementation.QualifiedNames.AnyType;
// <xs:attribute name="InstanceId" type="xs:unsignedInt" use="required" />
XmlSchemaAttribute instanceId = new XmlSchemaAttribute();
instanceId.Name = ProtocolStrings.SchemaNames.AppSequenceInstanceId;
instanceId.SchemaTypeName = discoveryVersion.Implementation.QualifiedNames.UnsignedIntType;
instanceId.Use = XmlSchemaUse.Required;
// <xs:attribute name="SequenceId" type="xs:anyURI" />
XmlSchemaAttribute sequenceId = new XmlSchemaAttribute();
sequenceId.Name = ProtocolStrings.SchemaNames.AppSequenceSequenceId;
sequenceId.SchemaTypeName = discoveryVersion.Implementation.QualifiedNames.AnyUriType;
// <xs:attribute name="MessageNumber" type="xs:unsignedInt" use="required" />
XmlSchemaAttribute messageNumber = new XmlSchemaAttribute();
messageNumber.Name = ProtocolStrings.SchemaNames.AppSequenceMessageNumber;
messageNumber.SchemaTypeName = discoveryVersion.Implementation.QualifiedNames.UnsignedIntType;
messageNumber.Use = XmlSchemaUse.Required;
// <xs:anyAttribute namespace="##other" processContents="lax" />
XmlSchemaAnyAttribute anyAttribue = new XmlSchemaAnyAttribute();
anyAttribue.Namespace = "##other";
anyAttribue.ProcessContents = XmlSchemaContentProcessing.Lax;
contentRestriction.Attributes.Add(instanceId);
contentRestriction.Attributes.Add(sequenceId);
contentRestriction.Attributes.Add(messageNumber);
contentRestriction.AnyAttribute = anyAttribue;
schema.Items.Add(appSequenceType);
}
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);
}
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidAnyAttributeUse, type.Name, type.QualifiedName.Namespace));
}
XmlSchemaObjectCollection items = type.Attributes;
for (int i = 0; i < items.Count; i++)
{
object item = items[i];
if (item is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(SR.Format(SR.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
if (item is XmlSchemaAttribute)
{
XmlSchemaAttribute attr = (XmlSchemaAttribute)item;
if (attr.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(SR.Format(SR.XmlSoapInvalidAttributeUse, type.Name, type.QualifiedName.Namespace));
}
}
}
if (type.Particle != null)
{
ImportGroup(type.Particle, members, typeNs);
}
else if (type.ContentModel != null && type.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent model = (XmlSchemaComplexContent)type.ContentModel;
if (model.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension)model.Content).Particle != null)
{
ImportGroup(((XmlSchemaComplexContentExtension)model.Content).Particle, members, typeNs);
}
}
else if (model.Content is XmlSchemaComplexContentRestriction)
{
if (((XmlSchemaComplexContentRestriction)model.Content).Particle != null)
{
ImportGroup(((XmlSchemaComplexContentRestriction)model.Content).Particle, members, typeNs);
}
}
}
return((MemberMapping[])members.ToArray(typeof(MemberMapping)));
}
private void GetProperties(XmlSchema xmlSchema, string elementname)
{
foreach (object xItem in xmlSchema.SchemaTypes.Values)
{
XmlSchemaComplexType item = xItem as XmlSchemaComplexType;
#region item
if (item != null)
{
if (item.Name.Equals(elementname))
{
XmlSchemaContentModel model = item.ContentModel;
XmlSchemaComplexContent complex = model as XmlSchemaComplexContent;
SoapClasses newClass = this.GetClass(elementname);
if (complex != null && newClass != null)
{
XmlSchemaComplexContentExtension extension = complex.Content as XmlSchemaComplexContentExtension;
XmlSchemaParticle particle = extension.Particle;
XmlSchemaSequence sequence = particle as XmlSchemaSequence;
if (extension != null)
{
newClass.SuperClassType = extension.BaseTypeName.Name;
}
if (sequence != null)
{
foreach (XmlSchemaElement childElement in sequence.Items)
{
if (newClass != null)
{
SoapClassProperties newProp = new SoapClassProperties(XpoDefault.Session);
newProp.Name = childElement.Name;
newProp.PropertyClassType = childElement.SchemaTypeName.Name;
newProp.IsArray = childElement.SchemaTypeName.Name.StartsWith("ArrayOf");//.Equals("unbounded"));
newClass.Properties.Add(newProp);
}
}
}
newClass.Save();
}
return;
}
}
#endregion
}
}
void Parse_ComplexContent(TreeNode inner, string ns, XmlSchemaComplexContent content)
{
XmlQualifiedName qname;
XmlSchemaComplexContentExtension ext = content.Content as XmlSchemaComplexContentExtension;
if (ext != null)
{
qname = ext.BaseTypeName;
}
else
{
XmlSchemaComplexContentRestriction rest = (XmlSchemaComplexContentRestriction)content.Content;
qname = rest.BaseTypeName;
if (qname == arrayType)
{
Parse_ArrayType(rest, out qname);
XmlSchemaElement elem = new XmlSchemaElement();
elem.Name = "Item";
elem.SchemaTypeName = qname;
TreeNode node = new TreeNode("arrayType" + SoapEncodingNamespace + qname.Name + "[2]");
inner.Nodes.Add(node);
Add_Item(inner, ns, elem, true);
return;
}
}
// Add base map members to this map
XmlSchemaComplexType ctype = GetComplexTypeByName(qname);
Add_ComplexAttributes(inner, ctype);
//Add base content first
Add_ComplexElements(inner, ns, ctype);
if (ext != null)
{
// Add the members of this map
Add_Attributes(inner, ext.Attributes, ext.AnyAttribute);
if (ext.Particle != null)
{
Parse_ParticleComplexContent(inner, ns, ext.Particle);
}
}
}
/// <summary>
/// Creates an element representing a conditional "Switch" block, which recursively contains another type
/// </summary>
/// <param name="InnerType">The base type for the do block to contain</param>
/// <returns>New schema element for the block</returns>
static XmlSchemaElement CreateSwitchElement(ScriptSchemaStandardType InnerType)
{
// Create the "Option" element
XmlSchemaComplexContentExtension CaseExtension = new XmlSchemaComplexContentExtension();
CaseExtension.BaseTypeName = GetQualifiedTypeName(InnerType);
CaseExtension.Attributes.Add(CreateSchemaAttribute("If", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Required));
XmlSchemaComplexContent CaseContentModel = new XmlSchemaComplexContent();
CaseContentModel.Content = CaseExtension;
XmlSchemaComplexType CaseSchemaType = new XmlSchemaComplexType();
CaseSchemaType.ContentModel = CaseContentModel;
XmlSchemaElement CaseElement = new XmlSchemaElement();
CaseElement.Name = "Case";
CaseElement.SchemaType = CaseSchemaType;
CaseElement.MinOccurs = 0;
CaseElement.MaxOccursString = "unbounded";
// Create the "Otherwise" element
XmlSchemaElement OtherwiseElement = new XmlSchemaElement();
OtherwiseElement.Name = "Default";
OtherwiseElement.SchemaTypeName = GetQualifiedTypeName(InnerType);
OtherwiseElement.MinOccurs = 0;
OtherwiseElement.MaxOccurs = 1;
// Create the "Switch" element
XmlSchemaSequence SwitchSequence = new XmlSchemaSequence();
SwitchSequence.Items.Add(CaseElement);
SwitchSequence.Items.Add(OtherwiseElement);
XmlSchemaComplexType SwitchSchemaType = new XmlSchemaComplexType();
SwitchSchemaType.Particle = SwitchSequence;
XmlSchemaElement SwitchElement = new XmlSchemaElement();
SwitchElement.Name = "Switch";
SwitchElement.SchemaType = SwitchSchemaType;
return(SwitchElement);
}
/// <summary>
/// Handle derivation by extension.
/// If type is null, it'll create a new complexType
/// with an XmlAny node in its sequence child node.
/// </summary>
public XmlSchemaType WriteComplexSchemaType(Type type)
{
//
// Recursively generate schema for all parent types
//
if (type != null && type.BaseType == typeof(object))
{
return(WriteSchemaType(type));
}
XmlSchemaComplexType complexType = new XmlSchemaComplexType();
XmlSchemaSequence sequence;
XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension();
XmlSchemaComplexContent content = new XmlSchemaComplexContent();
complexType.ContentModel = content;
content.Content = extension;
XmlSchemaType baseSchemaType = WriteSchemaType(type.BaseType);
complexType.Name = type.Name;
FieldInfo [] fields = type.GetFields(flags);
PropertyInfo [] properties = type.GetProperties(flags);
try {
sequence = PopulateSequence(fields, properties);
if (attributes != null)
{
foreach (object o in attributes)
{
MemberInfo member = (MemberInfo)o;
Type attribute_type = (Type)attributes [o];
complexType.Attributes.Add(WriteSchemaAttribute(member, attribute_type));
}
}
} catch (ArgumentException e) {
throw new ArgumentException(String.Format("There is an error in '{0}'\n\t{1}", type.Name, e.Message));
}
extension.BaseTypeName = new XmlQualifiedName(baseSchemaType.Name);
extension.Particle = sequence;
generatedSchemaTypes.Add(type.FullName, complexType);
return(complexType);
}
private XmlQualifiedName ExportArrayMapping(ArrayMapping mapping, string ns)
{
while (mapping.Next != null)
{
mapping = mapping.Next;
}
if (((XmlSchemaComplexType)this.types[mapping]) == null)
{
this.CheckForDuplicateType(mapping.TypeName, mapping.Namespace);
XmlSchemaComplexType type = new XmlSchemaComplexType {
Name = mapping.TypeName
};
this.types.Add(mapping, type);
this.AddSchemaItem(type, mapping.Namespace, ns);
this.AddSchemaImport("http://schemas.xmlsoap.org/soap/encoding/", mapping.Namespace);
this.AddSchemaImport("http://schemas.xmlsoap.org/wsdl/", mapping.Namespace);
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
XmlQualifiedName name = this.ExportTypeMapping(mapping.Elements[0].Mapping, mapping.Namespace);
if (name.IsEmpty)
{
name = new XmlQualifiedName("anyType", "http://www.w3.org/2001/XMLSchema");
}
XmlSchemaAttribute item = new XmlSchemaAttribute {
RefName = ArrayTypeQName
};
XmlAttribute attribute2 = new XmlAttribute("wsdl", "arrayType", "http://schemas.xmlsoap.org/wsdl/", this.Document)
{
Value = name.Namespace + ":" + name.Name + "[]"
};
item.UnhandledAttributes = new XmlAttribute[] { attribute2 };
restriction.Attributes.Add(item);
restriction.BaseTypeName = ArrayQName;
XmlSchemaComplexContent content = new XmlSchemaComplexContent {
Content = restriction
};
type.ContentModel = content;
if (name.Namespace != "http://www.w3.org/2001/XMLSchema")
{
this.AddSchemaImport(name.Namespace, mapping.Namespace);
}
}
else
{
this.AddSchemaImport(mapping.Namespace, ns);
}
return(new XmlQualifiedName(mapping.TypeName, mapping.Namespace));
}
void GetChildElementCompletionData(XmlCompletionDataList data, XmlSchemaComplexContent complexContent, string prefix)
{
var extension = complexContent.Content as XmlSchemaComplexContentExtension;
if (extension != null)
{
GetChildElementCompletionData(data, extension, prefix);
return;
}
var restriction = complexContent.Content as XmlSchemaComplexContentRestriction;
if (restriction != null)
{
GetChildElementCompletionData(data, restriction, prefix);
return;
}
}
public static IEnumerable <XmlSchemaAttribute> LocalXsdAttributes(this XmlSchemaType ty)
{
XmlSchemaComplexType xmlSchemaComplexType = ty as XmlSchemaComplexType;
if (xmlSchemaComplexType != null)
{
foreach (XmlSchemaAttribute attribute in xmlSchemaComplexType.Attributes)
{
yield return(attribute);
}
if (xmlSchemaComplexType.ContentModel != null)
{
XmlSchemaComplexContent contentModel = xmlSchemaComplexType.ContentModel as XmlSchemaComplexContent;
if (contentModel != null)
{
XmlSchemaComplexContentExtension content = contentModel.Content as XmlSchemaComplexContentExtension;
if (content == null)
{
goto Label0;
}
foreach (XmlSchemaAttribute xmlSchemaAttribute in content.Attributes)
{
yield return(xmlSchemaAttribute);
}
foreach (XmlSchemaAttribute xmlSchemaAttribute1 in content.Particle.LocalXsdAttributes())
{
yield return(xmlSchemaAttribute1);
}
}
else
{
goto Label0;
}
}
else
{
foreach (XmlSchemaAttribute xmlSchemaAttribute2 in xmlSchemaComplexType.Particle.LocalXsdAttributes())
{
yield return(xmlSchemaAttribute2);
}
}
}
Label0:
yield break;
goto Label0;
}
private void setXsd(XmlSchemaComplexType xsCoxType)
{
m_ClassGen.CName = xsCoxType.Name;
if (xsCoxType.ContentModel == null)
{
if (xsCoxType.Particle is XmlSchemaGroupRef)
{
// 만듬.
}
else if (xsCoxType.Particle is XmlSchemaGroupBase)
{
XmlSchemaGroupBase xgb = xsCoxType.Particle as XmlSchemaGroupBase;
roopItem(xgb);
}
}
else if (xsCoxType.ContentModel is XmlSchemaComplexContent)
{
XmlSchemaComplexContent xscc = xsCoxType.ContentModel as XmlSchemaComplexContent;
if (xscc.Content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension xscc_Extension = xscc.Content as XmlSchemaComplexContentExtension;
m_ClassGen.BaseName = xscc_Extension.BaseTypeName.Name;
// 위에 (**) 코드랑 같이 가려고 했는데 XmlSchemaComplexType 하고 같은 인터페이스를 사용하지 않음. 아옭 헷갈리
if (xscc_Extension.Particle is XmlSchemaGroupRef)
{
// 만듬.
}
else if (xscc_Extension.Particle is XmlSchemaGroupBase)
{
XmlSchemaGroupBase xgb = xscc_Extension.Particle as XmlSchemaGroupBase;
roopItem(xgb);
}
}
else if (xscc.Content is XmlSchemaComplexContentRestriction)
{
throw new NotImplementedException();
}
}
}
IEnumerable <XObject> CreateProtoComplexContent(XmlSchemaComplexContent complexContent, XmlSchemaType baseType)
{
var content = complexContent.Content as XmlSchemaComplexContentExtension;
if (baseType != null)
{
foreach (var x in CreateProtoAnyType(baseType))
{
yield return(x);
}
}
foreach (XmlSchemaAttribute attr in content.Attributes)
{
if (attr.Use == XmlSchemaUse.Required)
{
var name = attr.QualifiedName.ToXName();
string retres = null;
if (attr.FixedValue != null)
{
throw new Exception("not implemented");
}
else if (attr.DefaultValue != null)
{
retres = attr.DefaultValue;
}
else
{
retres = CreateProtoSimpleType(attr.AttributeSchemaType);
}
yield return(new XAttribute(name, retres));
}
}
if (content.Particle != null)
{
var particle = content.Particle;
if ((int)particle.MinOccurs > 0)
{
foreach (var retval in CreateProtoParticle(particle).Repeat((int)particle.MinOccurs))
{
yield return(retval);
}
}
}
}
public XmlSchemaComplexType CreateDataType(DataType dataType)
{
// create types
XmlSchemaComplexType complexType = new XmlSchemaComplexType();
complexType.Name = dataType.Name;
complexType.AddSchemaDocumentation(dataType.Description);
CogsSchema.Items.Add(complexType);
XmlSchemaSequence itemElements = new XmlSchemaSequence();
if (dataType.IsAbstract)
{
complexType.IsAbstract = true;
}
if (!string.IsNullOrWhiteSpace(dataType.ExtendsTypeName))
{
XmlSchemaComplexContent complexContent = new XmlSchemaComplexContent();
complexType.ContentModel = complexContent;
XmlSchemaComplexContentExtension contentExtension = new XmlSchemaComplexContentExtension();
complexContent.Content = contentExtension;
contentExtension.BaseTypeName = new XmlQualifiedName(dataType.ExtendsTypeName, TargetNamespace);
contentExtension.Particle = itemElements;
}
else
{
complexType.Particle = itemElements;
}
foreach (var property in dataType.Properties)
{
if (property.Name == "space")
{
continue;//TODO
}
CreateElementReference(itemElements, property);
}
return(complexType);
}
private MemberMapping[] ImportTypeMembers(XmlSchemaComplexType type, string typeNs, CodeIdentifiers members)
{
if (type.AnyAttribute != null)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidAnyAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
XmlSchemaObjectCollection attributes = type.Attributes;
for (int i = 0; i < attributes.Count; i++)
{
object obj2 = attributes[i];
if (obj2 is XmlSchemaAttributeGroup)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
if (obj2 is XmlSchemaAttribute)
{
XmlSchemaAttribute attribute = (XmlSchemaAttribute)obj2;
if (attribute.Use != XmlSchemaUse.Prohibited)
{
throw new InvalidOperationException(Res.GetString("XmlSoapInvalidAttributeUse", new object[] { type.Name, type.QualifiedName.Namespace }));
}
}
}
if (type.Particle != null)
{
this.ImportGroup(type.Particle, members, typeNs);
}
else if ((type.ContentModel != null) && (type.ContentModel is XmlSchemaComplexContent))
{
XmlSchemaComplexContent contentModel = (XmlSchemaComplexContent)type.ContentModel;
if (contentModel.Content is XmlSchemaComplexContentExtension)
{
if (((XmlSchemaComplexContentExtension)contentModel.Content).Particle != null)
{
this.ImportGroup(((XmlSchemaComplexContentExtension)contentModel.Content).Particle, members, typeNs);
}
}
else if ((contentModel.Content is XmlSchemaComplexContentRestriction) && (((XmlSchemaComplexContentRestriction)contentModel.Content).Particle != null))
{
this.ImportGroup(((XmlSchemaComplexContentRestriction)contentModel.Content).Particle, members, typeNs);
}
}
return((MemberMapping[])members.ToArray(typeof(MemberMapping)));
}
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;
}
XmlSchemaAttribute FindAttribute(XmlSchemaComplexContent complexContent, string name)
{
var extension = complexContent.Content as XmlSchemaComplexContentExtension;
if (extension != null)
{
return(FindAttribute(extension, name));
}
var restriction = complexContent.Content as XmlSchemaComplexContentRestriction;
if (restriction != null)
{
return(FindAttribute(restriction, name));
}
return(null);
}
/// <summary>
/// Creates the schema type representing the trigger type
/// </summary>
/// <returns>Type definition for a trigger</returns>
static XmlSchemaType CreateTriggerType()
{
XmlSchemaComplexContentExtension Extension = new XmlSchemaComplexContentExtension();
Extension.BaseTypeName = GetQualifiedTypeName(ScriptSchemaStandardType.TriggerBody);
Extension.Attributes.Add(CreateSchemaAttribute("Name", ScriptSchemaStandardType.QualifiedName, XmlSchemaUse.Required));
Extension.Attributes.Add(CreateSchemaAttribute("If", ScriptSchemaStandardType.BalancedString, XmlSchemaUse.Optional));
XmlSchemaComplexContent ContentModel = new XmlSchemaComplexContent();
ContentModel.Content = Extension;
XmlSchemaComplexType ComplexType = new XmlSchemaComplexType();
ComplexType.Name = GetTypeName(ScriptSchemaStandardType.Trigger);
ComplexType.ContentModel = ContentModel;
return(ComplexType);
}
