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/.

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) (*GoWsdl, error)
  • func (g *GoWsdl) Start() (map[string][]byte, map[string][]byte, error)
• type GoXsd
  • func NewGoXsd(file, pkg string, ignoreTls bool) (*GoXsd, error)
  • func (g *GoXsd) Start() (map[string][]byte, error)
• type HeaderElements
• type SoapBody
• type SoapClient
  • func NewSoapClient(url string, tls bool) *SoapClient
  • func (s *SoapClient) Call(soapAction string, request, response interface{}, header *SoapHeader, ...) error
• type SoapEnvelope
• type SoapFault
  • func (f *SoapFault) Error() string
• type SoapHeader
• type Wsdl
• type WsdlBinding
• type WsdlFault
• 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 XsdAny
• type XsdAttribute
• type XsdAttributeGroup
• type XsdComplexContent
• type XsdComplexType
• type XsdElement
• type XsdExtension
• type XsdGroup
• type XsdImport
• type XsdInclude
• type XsdRestriction
• type XsdRestrictionValue
• type XsdSchema
• type XsdSimpleContent
• type XsdSimpleType
• type XsdUnion

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) (*GoWsdl, error)

func (*GoWsdl) Start

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

type GoXsd

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

func NewGoXsd

func NewGoXsd(file, pkg string, ignoreTls bool) (*GoXsd, error)

func (*GoXsd) Start

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

type HeaderElements

type HeaderElements struct {
	Pkg                  string
	PkgBase              string
	ImportsNeeded        map[string]bool
	ResolvedXsdExternals map[string]*XsdSchema
}

type SoapBody

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

	RequestId   string `xml:"RequestId,attr,omitempty"`
	Transaction string `xml:"Transaction,attr,omitempty"`
}

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{}, header *SoapHeader, configureRequest func(*http.Request)) 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 {
	ReqHeader      interface{}
	RespHeader     interface{}
	BodyAttributes interface{}
	Content        string `xml:",innerxml"`
}

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:"http://schemas.xmlsoap.org/wsdl/ types"`
	Messages        []*WsdlMessage  `xml:"http://schemas.xmlsoap.org/wsdl/ message"`
	PortTypes       []*WsdlPortType `xml:"http://schemas.xmlsoap.org/wsdl/ portType"`
	Binding         []*WsdlBinding  `xml:"http://schemas.xmlsoap.org/wsdl/ binding"`
	Service         []*WsdlService  `xml:"http://schemas.xmlsoap.org/wsdl/ service"`
}

type WsdlBinding

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

type WsdlFault

type WsdlFault struct {
	Name      string        `xml:"name,attr"`
	Message   string        `xml:"message,attr"`
	Doc       string        `xml:"documentation"`
	SoapFault WsdlSoapFault `xml:"http://schemas.xmlsoap.org/wsdl/soap/ fault"`
}

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:"http://schemas.xmlsoap.org/wsdl/soap/ body"`
	SoapHeader []*WsdlSoapHeader `xml:"http://schemas.xmlsoap.org/wsdl/soap/ header"`
}

type WsdlMessage

type WsdlMessage struct {
	Name  string      `xml:"name,attr"`
	Doc   string      `xml:"documentation"`
	Parts []*WsdlPart `xml:"http://schemas.xmlsoap.org/wsdl/ 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"`
}

type WsdlOutput

type WsdlOutput struct {
	Name       string            `xml:"name,attr"`
	Message    string            `xml:"message,attr"`
	Doc        string            `xml:"documentation"`
	SoapBody   WsdlSoapBody      `xml:"http://schemas.xmlsoap.org/wsdl/soap/ body"`
	SoapHeader []*WsdlSoapHeader `xml:"http://schemas.xmlsoap.org/wsdl/soap/ 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:"http://schemas.xmlsoap.org/wsdl/soap/ address"`
}

type WsdlPortType

type WsdlPortType struct {
	Name       string           `xml:"name,attr"`
	Doc        string           `xml:"documentation"`
	Operations []*WsdlOperation `xml:"http://schemas.xmlsoap.org/wsdl/ operation"`
}

type WsdlService

type WsdlService struct {
	Name  string      `xml:"name,attr"`
	Doc   string      `xml:"documentation"`
	Ports []*WsdlPort `xml:"http://schemas.xmlsoap.org/wsdl/ 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 XsdAny

type XsdAny struct {
	XMLName         xml.Name `xml:"any"`
	ProcessContents string   `xml:"processContents,attr"`
	MinOccurs       string   `xml:"minOccurs,attr"`
	MaxOccurs       string   `xml:"maxOccurs,attr"`
}

type XsdAttribute

type XsdAttribute struct {
	Name       string         `xml:"name,attr"`
	Doc        string         `xml:"annotation>documentation"`
	Type       string         `xml:"type,attr"`
	SimpleType *XsdSimpleType `xml:"simpleType"`
}

type XsdAttributeGroup

type XsdAttributeGroup struct {
	Name       string          `xml:"name,attr"`
	Ref        string          `xml:"ref,attr"`
	Doc        string          `xml:"annotation>documentation"`
	Attributes []*XsdAttribute `xml:"attribute"`
}

type XsdComplexContent

type XsdComplexContent struct {
	XMLName   xml.Name     `xml:"complexContent"`
	Doc       string       `xml:"annotation>documentation"`
	Extension XsdExtension `xml:"extension"`
}

type XsdComplexType

type XsdComplexType struct {
	XMLName        xml.Name             `xml:"complexType"`
	Doc            string               `xml:"annotation>documentation"`
	Abstract       bool                 `xml:"abstract,attr"`
	Name           string               `xml:"name,attr"`
	Mixed          bool                 `xml:"mixed,attr"`
	Sequence       []XsdElement         `xml:"sequence>element"`
	SubSequence    []XsdElement         `xml:"sequence>sequence>element"`
	Any            []XsdAny             `xml:"sequence>any"`
	Choice         []XsdElement         `xml:"choice>element"`
	All            []XsdElement         `xml:"all>element"`
	ComplexContent XsdComplexContent    `xml:"complexContent"`
	SimpleContent  XsdSimpleContent     `xml:"simpleContent"`
	SimpleType     *XsdSimpleType       `xml:"simpleType"`
	Attributes     []*XsdAttribute      `xml:"attribute"`
	AttributeGoups []*XsdAttributeGroup `xml:"attributeGroup"`
}

type XsdElement

type XsdElement struct {
	XMLName     xml.Name        `xml:"element"`
	Name        string          `xml:"name,attr"`
	Doc         string          `xml:"annotation>documentation"`
	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"`
	Any         []XsdAny        `xml:"sequence>any"`
}

type XsdExtension

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

type XsdGroup

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

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"`
	Doc          string                 `xml:"annotation>documentation"`
	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 {
	Doc   string `xml:"annotation>documentation"`
	Value string `xml:"value,attr"`
}

type XsdSchema

type XsdSchema struct {
	Parent             string
	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"`
	AttributeGoups     []*XsdAttributeGroup `xml:"attributeGroup"`
}

type XsdSimpleContent

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

type XsdSimpleType

type XsdSimpleType struct {
	Name        string         `xml:"name,attr"`
	Doc         string         `xml:"annotation>documentation"`
	Restriction XsdRestriction `xml:"restriction"`
	UnionType   XsdUnion       `xml:"union"`
}

type XsdUnion

type XsdUnion struct {
	MemberType string           `xml:"memberTypes,attr"`
	SimpleType []*XsdSimpleType `xml:"simpleType"`
}