generator

Documentation

Overview

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

Index

• Variables
• type GoWsdl
  • func NewGoWsdl(file, pkg string, ignoreTls bool, noXmlName bool) (*GoWsdl, error)
  • func (g *GoWsdl) Start() (map[string][]byte, error)
• type SoapBody
• type SoapClient
  • func NewSoapClient(url string, tls bool) *SoapClient
  • func (s *SoapClient) Call(soapAction string, request, response interface{}) error
• type SoapEnvelope
• type SoapFault
  • func (f *SoapFault) Error() string
• type SoapHeader
• type Wsdl
• type WsdlBinding
• type WsdlFault
• type WsdlHttpBinding
• type WsdlHttpOperation
• type WsdlImport
• type WsdlInput
• type WsdlMessage
• type WsdlOperation
• type WsdlOutput
• type WsdlPart
• type WsdlPort
• type WsdlPortType
• type WsdlService
• type WsdlSoapAddress
• type WsdlSoapBinding
• type WsdlSoapBody
• type WsdlSoapFault
• type WsdlSoapHeader
• type WsdlSoapHeaderFault
• type WsdlSoapOperation
• type WsdlType
• type XsdAnnotation
• type XsdAttribute
• type XsdComplexContent
• type XsdComplexType
• type XsdElement
• type XsdExtension
• type XsdGroup
• type XsdImport
• type XsdInclude
• type XsdRestriction
• type XsdRestrictionValue
• type XsdSchema
• type XsdSequence
• type XsdSimpleContent
• type XsdSimpleType

Variables

var Log = log15.New()

Types

type GoWsdl

type GoWsdl struct {
	// contains filtered or unexported fields
}

func NewGoWsdl

func NewGoWsdl(file, pkg string, ignoreTls bool, noXmlName bool) (*GoWsdl, error)

func (*GoWsdl) Start

func (g *GoWsdl) Start() (map[string][]byte, error)

type SoapBody

type SoapBody struct {
	Fault   *SoapFault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
	Content string     `xml:",innerxml"`
}

type SoapClient

type SoapClient struct {
	// contains filtered or unexported fields
}

func NewSoapClient

func NewSoapClient(url string, tls bool) *SoapClient

func (*SoapClient) Call

func (s *SoapClient) Call(soapAction string, request, response interface{}) error

type SoapEnvelope

type SoapEnvelope struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
	//Header SoapHeader `xml:"http://schemas.xmlsoap.org/soap/envelope/ Header,omitempty"`
	Body SoapBody `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`
}

type SoapFault

type SoapFault struct {
	Faultcode   string `xml:"faultcode,omitempty"`
	Faultstring string `xml:"faultstring,omitempty"`
	Faultactor  string `xml:"faultactor,omitempty"`
	Detail      string `xml:"detail,omitempty"`
}

func (*SoapFault) Error

func (f *SoapFault) Error() string

type SoapHeader

type SoapHeader struct {
	Header interface{}
}

type Wsdl

type Wsdl struct {
	Name            string          `xml:"name,attr"`
	TargetNamespace string          `xml:"targetNamespace,attr"`
	Imports         []*WsdlImport   `xml:"import"`
	Doc             string          `xml:"documentation"`
	Types           WsdlType        `xml:"types"`
	Messages        []*WsdlMessage  `xml:"message"`
	PortTypes       []*WsdlPortType `xml:"portType"`
	Binding         []*WsdlBinding  `xml:"binding"`
	Service         []*WsdlService  `xml:"service"`
}

type WsdlBinding

type WsdlBinding struct {
	Name        string           `xml:"name,attr"`
	Type        string           `xml:"type,attr"`
	Doc         string           `xml:"documentation"`
	HttpBinding WsdlHttpBinding  `xml:"http://schemas.xmlsoap.org/wsdl/http/ binding"`
	SoapBinding WsdlSoapBinding  `xml:"http://schemas.xmlsoap.org/wsdl/soap/ binding"`
	Operations  []*WsdlOperation `xml:"operation"`
}

type WsdlFault

type WsdlFault struct {
	Name      string        `xml:"name,attr"`
	Message   string        `xml:"message,attr"`
	Doc       string        `xml:"documentation"`
	SoapFault WsdlSoapFault `xml:"fault"`
}

type WsdlHttpBinding

type WsdlHttpBinding struct {
	Verb string `xml:"verb,attr"`
}

type WsdlHttpOperation

type WsdlHttpOperation struct {
	Location string `xml:"location,attr"`
}

type WsdlImport

type WsdlImport struct {
	Namespace string `xml:"namespace,attr"`
	Location  string `xml:"location,attr"`
}

type WsdlInput

type WsdlInput struct {
	Name       string            `xml:"name,attr"`
	Message    string            `xml:"message,attr"`
	Doc        string            `xml:"documentation"`
	SoapBody   WsdlSoapBody      `xml:"body"`
	SoapHeader []*WsdlSoapHeader `xml:"header"`
}

type WsdlMessage

type WsdlMessage struct {
	Name  string      `xml:"name,attr"`
	Doc   string      `xml:"documentation"`
	Parts []*WsdlPart `xml:"part"`
}

type WsdlOperation

type WsdlOperation struct {
	Name          string            `xml:"name,attr"`
	Doc           string            `xml:"documentation"`
	Input         WsdlInput         `xml:"input"`
	Output        WsdlOutput        `xml:"output"`
	Faults        []*WsdlFault      `xml:"fault"`
	SoapOperation WsdlSoapOperation `xml:"http://schemas.xmlsoap.org/wsdl/soap/ operation"`
	HttpOperation WsdlHttpOperation `xml:"http://schemas.xmlsoap.org/wsdl/http/ operation"`
}

type WsdlOutput

type WsdlOutput struct {
	Name       string            `xml:"name,attr"`
	Message    string            `xml:"message,attr"`
	Doc        string            `xml:"documentation"`
	SoapBody   WsdlSoapBody      `xml:"body"`
	SoapHeader []*WsdlSoapHeader `xml:"header"`
}

type WsdlPart

type WsdlPart struct {
	Name    string `xml:"name,attr"`
	Element string `xml:"element,attr"`
	Type    string `xml:"type,attr"`
}

type WsdlPort

type WsdlPort struct {
	Name        string          `xml:"name,attr"`
	Binding     string          `xml:"binding,attr"`
	Doc         string          `xml:"documentation"`
	SoapAddress WsdlSoapAddress `xml:"address"`
}

type WsdlPortType

type WsdlPortType struct {
	Name       string           `xml:"name,attr"`
	Doc        string           `xml:"documentation"`
	Operations []*WsdlOperation `xml:"operation"`
}

type WsdlService

type WsdlService struct {
	Name  string      `xml:"name,attr"`
	Doc   string      `xml:"documentation"`
	Ports []*WsdlPort `xml:"port"`
}

type WsdlSoapAddress

type WsdlSoapAddress struct {
	Location string `xml:"location,attr"`
}

type WsdlSoapBinding

type WsdlSoapBinding struct {
	Style     string `xml:"style,attr"`
	Transport string `xml:"transport,attr"`
}

type WsdlSoapBody

type WsdlSoapBody struct {
	Parts         string `xml:"parts,attr"`
	Use           string `xml:"use,attr"`
	EncodingStyle string `xml:"encodingStyle,attr"`
	Namespace     string `xml:"namespace,attr"`
}

type WsdlSoapFault

type WsdlSoapFault struct {
	Parts         string `xml:"parts,attr"`
	Use           string `xml:"use,attr"`
	EncodingStyle string `xml:"encodingStyle,attr"`
	Namespace     string `xml:"namespace,attr"`
}

type WsdlSoapHeader

type WsdlSoapHeader struct {
	Message       string                 `xml:"message,attr"`
	Part          string                 `xml:"part,attr"`
	Use           string                 `xml:"use,attr"`
	EncodingStyle string                 `xml:"encodingStyle,attr"`
	Namespace     string                 `xml:"namespace,attr"`
	HeadersFault  []*WsdlSoapHeaderFault `xml:"headerfault"`
}

type WsdlSoapHeaderFault

type WsdlSoapHeaderFault struct {
	Message       string `xml:"message,attr"`
	Part          string `xml:"part,attr"`
	Use           string `xml:"use,attr"`
	EncodingStyle string `xml:"encodingStyle,attr"`
	Namespace     string `xml:"namespace,attr"`
}

type WsdlSoapOperation

type WsdlSoapOperation struct {
	SoapAction string `xml:"soapAction,attr"`
	Style      string `xml:"style,attr"`
}

type WsdlType

type WsdlType struct {
	Doc     string       `xml:"documentation"`
	Schemas []*XsdSchema `xml:"schema"`
}

type XsdAnnotation

type XsdAnnotation struct {
	Documentation string `xml:"documentation"`
}

type XsdAttribute

type XsdAttribute struct {
	Name string `xml:"name,attr"`
	Type string `xml:"type,attr"`
}

type XsdComplexContent

type XsdComplexContent struct {
	XMLName   xml.Name     `xml:"complexContent"`
	Extension XsdExtension `xml:"extension"`
}

type XsdComplexType

type XsdComplexType struct {
	XMLName        xml.Name          `xml:"complexType"`
	Abstract       bool              `xml:"abstract,attr"`
	Name           string            `xml:"name,attr"`
	Mixed          bool              `xml:"mixed,attr"`
	Annotation     XsdAnnotation     `xml:"annotation"`
	Sequence       XsdSequence       `xml:"sequence"`
	Choice         []XsdElement      `xml:"choice>element"`
	All            []XsdElement      `xml:"all>element"`
	ComplexContent XsdComplexContent `xml:"complexContent"`
	SimpleContent  XsdSimpleContent  `xml:"simpleContent"`
	Attributes     []*XsdAttribute   `xml:"attribute"`
}

type XsdElement

type XsdElement struct {
	XMLName     xml.Name        `xml:"element"`
	Name        string          `xml:"name,attr"`
	Nillable    bool            `xml:"nillable,attr"`
	Type        string          `xml:"type,attr"`
	Ref         string          `xml:"ref,attr"`
	MinOccurs   string          `xml:"minOccurs,attr"`
	MaxOccurs   string          `xml:"maxOccurs,attr"`
	ComplexType *XsdComplexType `xml:"complexType"` //local
	SimpleType  *XsdSimpleType  `xml:"simpleType"`
	Groups      []*XsdGroup     `xml:"group"`
}

type XsdExtension

type XsdExtension struct {
	XMLName    xml.Name        `xml:"extension"`
	Base       string          `xml:"base,attr"`
	Attributes []*XsdAttribute `xml:"attribute"`
	Sequence   XsdSequence     `xml:"sequence"`
}

type XsdGroup

type XsdGroup struct {
	Name     string       `xml:"name,attr"`
	Ref      string       `xml:"ref,attr"`
	Sequence XsdSequence  `xml:"sequence"`
	Choice   []XsdElement `xml:"choice"`
	All      []XsdElement `xml:"all"`
}

type XsdImport

type XsdImport struct {
	XMLName        xml.Name `xml:"import"`
	SchemaLocation string   `xml:"schemaLocation,attr"`
	Namespace      string   `xml:"namespace,attr"`
}

type XsdInclude

type XsdInclude struct {
	SchemaLocation string `xml:"schemaLocation,attr"`
}

type XsdRestriction

type XsdRestriction struct {
	Base         string                `xml:"base,attr"`
	Enumeration  []XsdRestrictionValue `xml:"enumeration"`
	Pattern      XsdRestrictionValue   `xml:"pattern"`
	MinInclusive XsdRestrictionValue   `xml:"minInclusive"`
	MaxInclusive XsdRestrictionValue   `xml:"maxInclusive"`
	WhiteSpace   XsdRestrictionValue   `xml:"whitespace"`
	Length       XsdRestrictionValue   `xml:"length"`
	MinLength    XsdRestrictionValue   `xml:"minLength"`
	MaxLength    XsdRestrictionValue   `xml:"maxLength"`
}

type XsdRestrictionValue

type XsdRestrictionValue struct {
	Value string `xml:"value,attr"`
}

type XsdSchema

type XsdSchema struct {
	XMLName            xml.Name          `xml:"schema"`
	Tns                string            `xml:"xmlns tns,attr"`
	Xs                 string            `xml:"xmlns xs,attr"`
	Version            string            `xml:"version,attr"`
	TargetNamespace    string            `xml:"targetNamespace,attr"`
	ElementFormDefault string            `xml:"elementFormDefault,attr"`
	Includes           []*XsdInclude     `xml:"include"`
	Imports            []*XsdImport      `xml:"import"`
	Elements           []*XsdElement     `xml:"element"`
	ComplexTypes       []*XsdComplexType `xml:"complexType"` //global
	SimpleType         []*XsdSimpleType  `xml:"simpleType"`
}

type XsdSequence

type XsdSequence struct {
	Elements []XsdElement `xml:"element"`
}

type XsdSimpleContent

type XsdSimpleContent struct {
	XMLName   xml.Name     `xml:"simpleContent"`
	Extension XsdExtension `xml:"extension"`
}

type XsdSimpleType

type XsdSimpleType struct {
	Name        string         `xml:"name,attr"`
	Restriction XsdRestriction `xml:"restriction"`
}