gosoap

README

Go Soap

package to help with SOAP integrations (client)

Install

go get github.com/tiaguinho/gosoap

Example

package main

import (
	"encoding/xml"
	"log"

	"github.com/tiaguinho/gosoap"
)

// GetIPLocationResponse will hold the Soap response
type GetIPLocationResponse struct {
	GetIPLocationResult string `xml:"GetIpLocationResult"`
}

// GetIPLocationResult will
type GetIPLocationResult struct {
	XMLName xml.Name `xml:"GeoIP"`
	Country string   `xml:"Country"`
	State   string   `xml:"State"`
}

var (
	r GetIPLocationResponse
)

func main() {
	soap, err := gosoap.SoapClient("http://wsgeoip.lavasoft.com/ipservice.asmx?WSDL")
	if err != nil {
		log.Fatalf("SoapClient error: %s", err)
	}

	params := gosoap.Params{
		"sIp": "8.8.8.8",
	}

	res, err := soap.Call("GetIpLocation", params)
	if err != nil {
		log.Fatalf("Call error: %s", err)
	}

	res.Unmarshal(&r)

	// GetIpLocationResult will be a string. We need to parse it to XML
	result := GetIPLocationResult{}
	err = xml.Unmarshal([]byte(r.GetIPLocationResult), &result)
	if err != nil {
		log.Fatalf("xml.Unmarshal error: %s", err)
	}

	if result.Country != "US" {
		log.Fatalf("error: %+v", r)
	}

	log.Println("Country: ", result.Country)
	log.Println("State: ", result.State)
}

Documentation

Index

• func GetPayloadFromError(err error) []byte
• type Client
  • func SoapClient(wsdl string) (*Client, error)
  • func (c *Client) Call(m string, p Params) (res *Response, err error)
  • func (c *Client) CallByStruct(s RequestStruct) (res *Response, err error)
  • func (c *Client) Do(req *Request) (res *Response, err error)
  • func (c *Client) SetWSDL(wsdl string)
• type ErrorWithPayload
• type Fault
• type HeaderParams
• type Params
• type Request
  • func NewRequest(m string, p Params) *Request
  • func NewRequestByStruct(s RequestStruct) (*Request, error)
• type RequestStruct
• type Response
  • func (r *Response) Unmarshal(v interface{}) error
• type SoapBody
• type SoapEnvelope
• type SoapHeader

Functions

func GetPayloadFromError

func GetPayloadFromError(err error) []byte

Types

type Client

type Client struct {
	HttpClient   *http.Client
	URL          string
	HeaderName   string
	HeaderParams HeaderParams
	Definitions  *wsdlDefinitions
	ForceHTTPS   bool
	// Must be set before first request otherwise has no effect, minimum is 15 minutes.
	RefreshDefinitionsAfter time.Duration
	Username                string
	Password                string
	// contains filtered or unexported fields
}

Client struct hold all the informations about WSDL, request and response of the server

func SoapClient

func SoapClient(wsdl string) (*Client, error)

SoapClient return new *Client to handle the requests with the WSDL

func (*Client) Call

func (c *Client) Call(m string, p Params) (res *Response, err error)

Call call's the method m with Params p

func (*Client) CallByStruct

func (c *Client) CallByStruct(s RequestStruct) (res *Response, err error)

Call call's by struct

func (*Client) Do

func (c *Client) Do(req *Request) (res *Response, err error)

Process Soap Request

func (*Client) SetWSDL

func (c *Client) SetWSDL(wsdl string)

type ErrorWithPayload

type ErrorWithPayload struct {
	Payload []byte
	// contains filtered or unexported fields
}

type Fault

type Fault struct {
	Code        string `xml:"faultcode"`
	Description string `xml:"faultstring"`
	Detail      string `xml:"detail"`
}

Fault response

type HeaderParams

type HeaderParams map[string]interface{}

HeaderParams holds params specific to the header

type Params

type Params interface{}

Params type is used to set the params in soap request

type Request

type Request struct {
	Method string
	Params Params
}

Soap Request

func NewRequest

func NewRequest(m string, p Params) *Request

func NewRequestByStruct

func NewRequestByStruct(s RequestStruct) (*Request, error)

type RequestStruct

type RequestStruct interface {
	SoapBuildRequest() *Request
}

type Response

type Response struct {
	Body    []byte
	Header  []byte
	Payload []byte
}

Soap Response

func (*Response) Unmarshal

func (r *Response) Unmarshal(v interface{}) error

Unmarshal get the body and unmarshal into the interface

type SoapBody

type SoapBody struct {
	XMLName  struct{} `xml:"Body"`
	Contents []byte   `xml:",innerxml"`
}

SoapBody struct

type SoapEnvelope

type SoapEnvelope struct {
	XMLName struct{} `xml:"Envelope"`
	Header  SoapHeader
	Body    SoapBody
}

SoapEnvelope struct

type SoapHeader

type SoapHeader struct {
	XMLName  struct{} `xml:"Header"`
	Contents []byte   `xml:",innerxml"`
}

SoapHeader struct