soap_tmpl.go

package gowsdl

var soapTmpl = `
var timeout = time.Duration(30 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
	return net.DialTimeout(network, addr, timeout)
}

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

type SoapHeader struct {
	Header interface{}
}

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

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

type BasicAuth struct {
	Login string
	Password string
}

type SoapClient struct {
	url string
	tls bool
	auth *BasicAuth
}

func (f *SoapFault) Error() string {
	return f.Faultstring
}

func NewSoapClient(url string, tls bool, auth *BasicAuth) *SoapClient {
	return &SoapClient{
		url: url,
		tls: tls,
		auth: auth,
	}
}

func (s *SoapClient) Call(soapAction string, request, response interface{}) error {
	envelope := SoapEnvelope{
	//Header:        SoapHeader{},
	}

	if request != nil {
		reqXml, err := xml.Marshal(request)
		if err != nil {
			return err
		}

		envelope.Body.Content = string(reqXml)
	}
	buffer := &bytes.Buffer{}

	encoder := xml.NewEncoder(buffer)
	//encoder.Indent("  ", "    ")

	err := encoder.Encode(envelope)
	if err == nil {
		err = encoder.Flush()
	}
	log.Println(buffer.String())
	if err != nil {
		return err
	}

	req, err := http.NewRequest("POST", s.url, buffer)
	if s.auth != nil {
		req.SetBasicAuth(s.auth.Login, s.auth.Password)
	}
	req.Header.Add("Content-Type", "text/xml; charset=\"utf-8\"")
	if soapAction != "" {
		req.Header.Add("SOAPAction", soapAction)
	}
	req.Header.Set("User-Agent", "gowsdl/0.1")
	req.Close = true

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: s.tls,
		},
		Dial: dialTimeout,
	}

	client := &http.Client{Transport: tr}
	res, err := client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	rawbody, err := ioutil.ReadAll(res.Body)
	if len(rawbody) == 0 {
		log.Println("empty response")
		return nil
	}
	log.Println(string(rawbody))
	respEnvelope := &SoapEnvelope{}

	err = xml.Unmarshal(rawbody, respEnvelope)
	if err != nil {
		return err
	}

	body := respEnvelope.Body.Content
	fault := respEnvelope.Body.Fault
	if body == "" {
		log.Println("empty response body", "envelope", respEnvelope, "body", body)
		return nil
	}

	log.Println("response", "envelope", respEnvelope, "body", body)
	if fault != nil {
		return fault
	}

	err = xml.Unmarshal([]byte(body), response)
	if err != nil {
		return err
	}

	return nil
}

func main() {
}
`