public override MetadataSet GetGeneratedMetadata()
{
if (metadata != null)
{
return(metadata);
}
metadata = new MetadataSet();
foreach (WSServiceDescription sd in GeneratedWsdlDocuments)
{
metadata.MetadataSections.Add(
MetadataSection.CreateFromServiceDescription(sd));
}
foreach (XmlSchema xs in GeneratedXmlSchemas.Schemas())
{
if (xs.TargetNamespace != XmlSchema.Namespace)
{
metadata.MetadataSections.Add(
MetadataSection.CreateFromSchema(xs));
}
}
return(metadata);
}
XmlSchema GetSchema(string ns)
{
ICollection colln = GeneratedXmlSchemas.Schemas(ns);
if (colln.Count > 0)
{
if (colln.Count > 1)
{
throw new Exception("More than 1 schema found for ns = " + ns);
}
//FIXME: HORRIBLE!
foreach (object o in colln)
{
return(o as XmlSchema);
}
}
XmlSchema schema = new XmlSchema();
schema.TargetNamespace = ns;
schema.ElementFormDefault = XmlSchemaForm.Qualified;
GeneratedXmlSchemas.Add(schema);
return(schema);
}
//Exports <xs:type for SMMessage
//FIXME: complex type for this can be made static
QName ExportTypeMessage()
{
XmlSchema xs = GetSchema("http://schemas.microsoft.com/Message");
QName qname = new QName("MessageBody", xs.TargetNamespace);
foreach (XmlSchemaObject o in xs.Items)
{
XmlSchemaComplexType ct = o as XmlSchemaComplexType;
if (ct == null)
{
continue;
}
if (ct.Name == "MessageBody")
{
//Already exported
return(qname);
}
}
XmlSchemaComplexType complex_type = new XmlSchemaComplexType();
complex_type.Name = "MessageBody";
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaAny any = new XmlSchemaAny();
any.MinOccurs = 0;
any.MaxOccursString = "unbounded";
any.Namespace = "##any";
sequence.Items.Add(any);
complex_type.Particle = sequence;
xs.Items.Add(complex_type);
GeneratedXmlSchemas.Reprocess(xs);
return(qname);
}
QName ExportParameters(MessageBodyDescription msgbody, string name, string ns)
{
XmlSchema xs = GetSchema(ns);
//FIXME: Extract to a HasElement method ?
foreach (XmlSchemaObject o in xs.Items)
{
XmlSchemaElement e = o as XmlSchemaElement;
if (e == null)
{
continue;
}
if (e.Name == name)
{
throw new InvalidOperationException(String.Format(
"Message element named '{0}:{1}' has already been exported.",
ns, name));
}
}
//Create the element for "parameters"
XmlSchemaElement schema_element = new XmlSchemaElement();
schema_element.Name = name;
XmlSchemaComplexType complex_type = new XmlSchemaComplexType();
//Generate Sequence representing the message/parameters
//FIXME: MessageContractAttribute
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaElement element = null;
if (msgbody.ReturnValue == null)
{
//parameters
foreach (MessagePartDescription part in msgbody.Parts)
{
if (part.Type == null)
{
//FIXME: Eg. when WsdlImporter is used to import a wsdl
throw new NotImplementedException();
}
element = GetSchemaElementForPart(part, xs);
sequence.Items.Add(element);
}
}
else
{
//ReturnValue
if (msgbody.ReturnValue.Type != typeof(void))
{
element = GetSchemaElementForPart(msgbody.ReturnValue, xs);
sequence.Items.Add(element);
}
}
complex_type.Particle = sequence;
schema_element.SchemaType = complex_type;
xs.Items.Add(schema_element);
GeneratedXmlSchemas.Reprocess(xs);
return(new QName(schema_element.Name, xs.TargetNamespace));
}
ContractExportMap ExportContractInternal(ContractDescription contract)
{
if (ExportedContracts.ContainsKey(contract))
{
return(ExportedContracts [contract]);
}
QName qname = new QName(contract.Name, contract.Namespace);
if (ExportedContracts.Any(m => m.Value.QName == qname))
{
throw new ArgumentException(String.Format(
"A ContractDescription with Namespace : {0} and Name : {1} has already been exported.",
contract.Namespace, contract.Name));
}
WSServiceDescription sd = GetServiceDescription(contract.Namespace);
List <IWsdlExportExtension> extensions = new List <IWsdlExportExtension> ();
foreach (IWsdlExportExtension extn in contract.Behaviors.FindAll <IWsdlExportExtension> ())
{
extensions.Add(extn);
}
XmlDocument xdoc = new XmlDocument();
PortType ws_port = new PortType();
ws_port.Name = contract.Name;
foreach (OperationDescription sm_op in contract.Operations)
{
Operation ws_op = new Operation();
ws_op.Name = sm_op.Name;
foreach (MessageDescription sm_md in sm_op.Messages)
{
//OperationMessage
OperationMessage ws_opmsg;
WSMessage ws_msg = new WSMessage();
MessagePart ws_msgpart;
if (sm_md.Direction == MessageDirection.Input)
{
ws_opmsg = new OperationInput();
ws_msg.Name = String.Concat(ws_port.Name, "_", ws_op.Name, "_", "InputMessage");
ws_msgpart = ExportMessageBodyDescription(sm_md.Body, ws_op.Name, sd.TargetNamespace);
}
else
{
ws_opmsg = new OperationOutput();
ws_msg.Name = String.Concat(ws_port.Name, "_", ws_op.Name, "_", "OutputMessage");
ws_msgpart = ExportMessageBodyDescription(sm_md.Body, ws_op.Name + "Response", sd.TargetNamespace);
}
ws_msg.Parts.Add(ws_msgpart);
/* FIXME: Faults */
//Action
XmlAttribute attr = xdoc.CreateAttribute("wsaw", "Action", "http://www.w3.org/2006/05/addressing/wsdl");
attr.Value = sm_md.Action;
ws_opmsg.ExtensibleAttributes = new XmlAttribute [] { attr };
//FIXME: Set .Input & .Output
ws_opmsg.Message = new QName(ws_msg.Name, sd.TargetNamespace);
ws_op.Messages.Add(ws_opmsg);
sd.Messages.Add(ws_msg);
}
ws_port.Operations.Add(ws_op);
foreach (IWsdlExportExtension extn in sm_op.Behaviors.FindAll <IWsdlExportExtension> ())
{
extensions.Add(extn);
}
}
//Add Imports for <types
XmlSchema xs_import = new XmlSchema();
xs_import.TargetNamespace = String.Concat(
contract.Namespace,
contract.Namespace.EndsWith("/") ? "" : "/",
"Imports");
foreach (XmlSchema schema in GeneratedXmlSchemas.Schemas())
{
XmlSchemaImport imp = new XmlSchemaImport();
imp.Namespace = schema.TargetNamespace;
xs_import.Includes.Add(imp);
}
sd.Types.Schemas.Add(xs_import);
sd.PortTypes.Add(ws_port);
var map = new ContractExportMap(qname, contract, extensions);
ExportedContracts.Add(contract, map);
WsdlContractConversionContext context = new WsdlContractConversionContext(contract, ws_port);
foreach (IWsdlExportExtension extn in extensions)
{
extn.ExportContract(this, context);
}
return(map);
}
