Beispiel #1
0
        public string Handle(string requestBody)
        {
            var reader = new XmlReaderImpl();

            reader.SetString(requestBody);

            var writer = new XmlWriterImpl();

            writer.SetString();

            writer.WriteStartElement("Envelope", xmlns_soap);
            writer.WriteNamespaceMapping("soap", xmlns_soap);
            writer.WriteStartElement("Body", xmlns_soap);

            try
            {
                Handle(reader, writer);
            }
            catch (Exception exc)
            {
                WriteFault(writer, exc.Message);
            }

            writer.WriteEndElement();              // Body
            writer.WriteEndElement();              // Envelope

            var responseText = writer.Close().AsString();

            return(responseText);
        }
Beispiel #2
0
        private void WriteFault(XmlWriterImpl writer, string faultString)
        {
            writer.WriteStartElement("Fault", xmlns_soap);
            writer.WriteStartElement("faultString", xmlns_soap);

            writer.WriteText(faultString);

            writer.WriteEndElement();              // faultString
            writer.WriteEndElement();              // Fault
        }
Beispiel #3
0
        public void WriteRequestBody(XmlWriterImpl writer,
                                     XdtoSerializerImpl serializer,
                                     IValue [] arguments)
        {
            foreach (var messagePart in Parameters.Parts)
            {
                writer.WriteStartElement(messagePart.ElementName, messagePart.NamespaceUri);

                foreach (var param in messagePart.Parameters)
                {
                    if (param.ParameterDirection == ParameterDirectionEnum.Out)
                    {
                        continue;
                    }

                    var argumentIndex  = _indexes [param.Name];
                    var typeAssignment = XmlTypeAssignmentEnum.Implicit;

                    if (param.Type is XdtoValueType)
                    {
                        typeAssignment = XmlTypeAssignmentEnum.Explicit;
                    }
                    serializer.WriteXml(writer, arguments [argumentIndex], param.Name, messagePart.NamespaceUri, typeAssignment);
                }

                writer.WriteEndElement();                  // messagePart.ElementName
            }
        }
Beispiel #4
0
        public void WriteXml(XmlWriterImpl xmlWriter,
                             IXdtoValue value,
                             string localName,
                             string namespaceUri = null,
                             XmlTypeAssignmentEnum?typeAssignment = null,
                             XmlFormEnum?xmlForm = null)
        {
            xmlForm        = xmlForm ?? XmlFormEnum.Element;
            typeAssignment = typeAssignment ?? XmlTypeAssignmentEnum.Implicit;

            if (xmlForm == XmlFormEnum.Element)
            {
                xmlWriter.WriteStartElement(localName, namespaceUri);

                if (typeAssignment == XmlTypeAssignmentEnum.Implicit)
                {
                    WriteTypeAttribute(xmlWriter, ValueFactory.Create(value));
                }

                if (value == null)
                {
                    xmlWriter.WriteAttribute("nil", XmlNs.xsi, "true");
                }
                else if (value is XdtoDataObject)
                {
                    WriteXdtoObject(xmlWriter, value as XdtoDataObject);
                }
                else if (value is XdtoDataValue)
                {
                    var dataValue = value as XdtoDataValue;
                    xmlWriter.WriteText(dataValue.LexicalValue);
                }
                else
                {
                    xmlWriter.WriteText(value.ToString());
                }

                xmlWriter.WriteEndElement();
            }
            else if (xmlForm == XmlFormEnum.Attribute)
            {
                xmlWriter.WriteAttribute(localName, namespaceUri, value.ToString());
            }
            else if (xmlForm == XmlFormEnum.Text)
            {
                xmlWriter.WriteText(value.ToString());                   // TODO: XmlString ??
            }
            else
            {
                throw new NotSupportedException("Какой-то новый тип для XML");
            }
        }
Beispiel #5
0
        private void WriteXMLUndefined(XmlWriterImpl xmlWriter, string name, XMLForm form)
        {
            if (form == XMLForm.Element)
            {
                XmlNamespaceContext namespaceContext = xmlWriter.NamespaceContext;
                AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);
                AddNamespaceMapping(namespaceContext, xmlWriter, "xsi", XmlSchema.InstanceNamespace);

                xmlWriter.WriteStartElement(name);
                xmlWriter.WriteStartAttribute("nil", XmlSchema.InstanceNamespace);
                xmlWriter.WriteText("true");
                xmlWriter.WriteEndAttribute();
                xmlWriter.WriteEndElement();
            }
        }
Beispiel #6
0
        private void WriteXMLSimpleData(XmlWriterImpl xmlWriter,
                                        string name,
                                        IValue value,
                                        XMLExpandedName type,
                                        XMLTypeAssignment typeAssigment,
                                        XMLForm form)
        {
            XmlNamespaceContext namespaceContext;
            string xmlValue = XMLString(value);

            switch (form)
            {
            case XMLForm.Attribute:
                namespaceContext = xmlWriter.NamespaceContext;
                AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);

                xmlWriter.WriteStartAttribute(name);
                xmlWriter.WriteText(xmlValue);
                xmlWriter.WriteEndAttribute();
                break;

            case XMLForm.Text:
                xmlWriter.WriteText(xmlValue);
                break;

            default:

                xmlWriter.WriteStartElement(name);

                namespaceContext = xmlWriter.NamespaceContext;
                AddNamespaceMapping(namespaceContext, xmlWriter, "", XmlSchema.Namespace);
                AddNamespaceMapping(namespaceContext, xmlWriter, "xsi", XmlSchema.InstanceNamespace);

                if (typeAssigment == XMLTypeAssignment.Explicit)
                {
                    xmlWriter.WriteStartAttribute("type", XmlSchema.InstanceNamespace);
                    xmlWriter.WriteText(type.LocalName);
                    xmlWriter.WriteEndAttribute();
                }

                xmlWriter.WriteText(xmlValue);

                xmlWriter.WriteEndElement();
                break;
            }
        }
Beispiel #7
0
        // Особенности реализации: возвращаемое значение и исходящие параметры
        // передаём ОДНИМ сообщением, хотя протокол разрешает несколько сообщений

        public void WriteResponseBody(XmlWriterImpl writer,
                                      XdtoSerializerImpl serializer,
                                      IValue returnValue,
                                      IValue [] arguments)
        {
            writer.WriteStartElement(ReturnValue.MessagePartName, NamespaceUri);

            serializer.WriteXml(writer, returnValue, "return", NamespaceUri);
            foreach (var param in Parameters)
            {
                if (param.ParameterDirection == ParameterDirectionEnum.In)
                {
                    continue;
                }

                var argumentIndex = _indexes [param.Name];
                serializer.WriteXml(writer, arguments [argumentIndex], param.Name, NamespaceUri);
            }

            writer.WriteEndElement();              // messagePartName
        }
Beispiel #8
0
        public string GenerateWsdl()
        {
            var writer = new XmlWriterImpl();

            writer.SetString();
            writer.WriteXMLDeclaration();

            writer.WriteStartElement("definitions");

            writer.WriteNamespaceMapping("", "http://schemas.xmlsoap.org/wsdl/");
            writer.WriteNamespaceMapping("soap12bind", "http://schemas.xmlsoap.org/wsdl/soap12/");
            writer.WriteNamespaceMapping("soapbind", "http://schemas.xmlsoap.org/wsdl/soap/");
            writer.WriteNamespaceMapping("tns", NamespaceUri);
            writer.WriteAttribute("name", Name);
            writer.WriteAttribute("targetNamespace", NamespaceUri);

            #region definitions/types

            writer.WriteStartElement("types");

            writer.WriteStartElement("xs:schema");
            writer.WriteNamespaceMapping("xs", "http://www.w3.org/2001/XMLSchema");
            writer.WriteNamespaceMapping("tns", NamespaceUri);

            writer.WriteAttribute("targetNamespace", NamespaceUri);
            writer.WriteAttribute("attributeFormDefault", "unqualified");
            writer.WriteAttribute("elementFormDefault", "qualified");

            foreach (var operation in operations.Values)
            {
                foreach (var part in operation.Parameters.Parts)
                {
                    writer.WriteStartElement("xs:element");
                    writer.WriteAttribute("name", part.Name);

                    writer.WriteStartElement("xs:complexType");
                    writer.WriteStartElement("xs:sequence");
                    foreach (var param in part.Parameters)
                    {
                        if (param.ParameterDirection == ParameterDirectionEnum.Out)
                        {
                            continue;
                        }

                        writer.WriteStartElement("xs:element");
                        writer.WriteAttribute("name", param.Name);
                        writer.WriteAttribute("type", "xs:anyType");
                        writer.WriteEndElement();                          // xs:element
                    }

                    writer.WriteEndElement();                      // xs:sequence
                    writer.WriteEndElement();                      // xs:complexType
                    writer.WriteEndElement();                      // xs:element
                }

                writer.WriteStartElement("xs:element");
                writer.WriteAttribute("name", operation.ReturnValue.MessagePartName);

                writer.WriteStartElement("xs:complexType");
                writer.WriteStartElement("xs:sequence");

                writer.WriteStartElement("xs:element");
                writer.WriteAttribute("name", "return");
                writer.WriteAttribute("type", "xs:anyType");
                writer.WriteEndElement();                  // xs:element

                foreach (var param in operation.Parameters)
                {
                    if (param.ParameterDirection == ParameterDirectionEnum.In)
                    {
                        continue;
                    }

                    writer.WriteStartElement("xs:element");
                    writer.WriteAttribute("name", param.Name);
                    writer.WriteAttribute("type", "xs:anyType");
                    writer.WriteEndElement();                      // xs:element
                }

                writer.WriteEndElement();                  // xs:sequence
                writer.WriteEndElement();                  // xs:complexType
                writer.WriteEndElement();                  // xs:element
            }


            writer.WriteEndElement();              // xs:schema
            writer.WriteEndElement();              // types
            #endregion

            #region definitions/messages
            foreach (var operation in operations.Values)
            {
                writer.WriteStartElement("message");
                writer.WriteAttribute("name", string.Format("{0}RequestMessage", operation.Name));

                foreach (var part in operation.Parameters.Parts)
                {
                    writer.WriteStartElement("part");
                    writer.WriteAttribute("name", part.Name);
                    writer.WriteAttribute("element", part.ElementName);
                    writer.WriteEndElement();              // part
                }
                writer.WriteEndElement();                  // message

                writer.WriteStartElement("message");
                writer.WriteAttribute("name", string.Format("{0}ResponseMessage", operation.Name));

                writer.WriteStartElement("part");
                writer.WriteAttribute("name", "parameters");
                writer.WriteAttribute("element", operation.ReturnValue.MessagePartName);
                writer.WriteEndElement();                  // part

                writer.WriteEndElement();                  // message
            }
            #endregion

            #region definitions/portType
            var portTypeName = string.Format("{0}PortType", Name);

            writer.WriteStartElement("portType");
            writer.WriteAttribute("name", portTypeName);

            foreach (var operation in operations.Values)
            {
                writer.WriteStartElement("operation");
                writer.WriteAttribute("name", operation.Name);

                writer.WriteStartElement("input");
                writer.WriteAttribute("message", string.Format("{0}RequestMessage", operation.Name));
                writer.WriteEndElement();                  // input

                writer.WriteStartElement("output");
                writer.WriteAttribute("message", string.Format("{0}ResponseMessage", operation.Name));
                writer.WriteEndElement();                  // output

                writer.WriteEndElement();                  // operation
            }

            writer.WriteEndElement();              // portType
            #endregion

            #region definitions/binding
            var mainBindingName = string.Format("{0}Binding", Name);

            writer.WriteStartElement("binding");
            writer.WriteAttribute("name", mainBindingName);
            writer.WriteAttribute("type", portTypeName);

            writer.WriteStartElement("soapbind:binding");
            writer.WriteAttribute("style", "document");
            writer.WriteAttribute("transport", "http://schemas.xmlsoap.org/soap/http");
            writer.WriteEndElement();              // soapbind:binding

            foreach (var operation in operations.Values)
            {
                var soapActionString = string.Format("{0}#{1}:{2}", NamespaceUri, Name, operation.Name);

                writer.WriteStartElement("operation");
                writer.WriteAttribute("name", operation.Name);

                writer.WriteStartElement("soapbind:operation");
                writer.WriteAttribute("style", "document");
                writer.WriteAttribute("soapAction", soapActionString);

                writer.WriteStartElement("input");
                writer.WriteStartElement("soapbind:body");
                writer.WriteAttribute("use", "literal");
                writer.WriteEndElement();                  // soapbind:body
                writer.WriteEndElement();                  // input

                writer.WriteStartElement("output");
                writer.WriteStartElement("soapbind:body");
                writer.WriteAttribute("use", "literal");
                writer.WriteEndElement();                  // soapbind:body
                writer.WriteEndElement();                  // output

                writer.WriteEndElement();                  // soapbind:operation
                writer.WriteEndElement();                  // operation
            }

            writer.WriteEndElement();              // binding

            #endregion

            #region definitions/service
            var serviceUrl = "http://localhost/service";

            writer.WriteStartElement("service");
            writer.WriteStartElement("port");

            var mainPortName = string.Format("{0}Soap", Name);
            writer.WriteAttribute("name", mainPortName);
            writer.WriteAttribute("binding", string.Format("tns:{0}", mainBindingName));

            writer.WriteStartElement("documentation");
            writer.WriteEndElement();              // documentation

            writer.WriteStartElement("soapbind:address");
            writer.WriteAttribute("location", serviceUrl);
            writer.WriteEndElement();              // soapbind:address


            writer.WriteEndElement();              // port
            writer.WriteEndElement();              // service

            #endregion

            writer.WriteEndElement();              // definitions

            return(writer.Close().AsString());
        }