使用Golang和gorilla-xmlrpc进行增值税校验

使用gorilla-xmlrpc处理增值税校验的响应，需要正确解析XML-RPC的嵌套数据结构。以下是完整的解决方案：

package main

import (
    "bytes"
    "encoding/xml"
    "fmt"
    "io"
    "net/http"
    "github.com/gorilla/xmlrpc"
)

// 定义响应数据结构
type VATResponse struct {
    Datum      string `xmlrpc:"Datum"`
    Uhrzeit    string `xmlrpc:"Uhrzeit"`
    ErrorCode  string `xmlrpc:"ErrorCode"`
    UstId_1    string `xmlrpc:"UstId_1"`
    UstId_2    string `xmlrpc:"UstId_2"`
    Firmenname string `xmlrpc:"Firmenname"`
    Ort        string `xmlrpc:"Ort"`
    PLZ        string `xmlrpc:"PLZ"`
    Strasse    string `xmlrpc:"Strasse"`
    Erg_Name   string `xmlrpc:"Erg_Name"`
    Erg_Ort    string `xmlrpc:"Erg_Ort"`
    Erg_PLZ    string `xmlrpc:"Erg_PLZ"`
    Erg_Str    string `xmlrpc:"Erg_Str"`
    Gueltig_ab string `xmlrpc:"Gueltig_ab"`
    Gueltig_bis string `xmlrpc:"Gueltig_bis"`
    Druck      string `xmlrpc:"Druck"`
}

// 自定义XML-RPC解码器处理嵌套数组结构
func decodeVATResponse(data []byte) (*VATResponse, error) {
    type param struct {
        Value []string `xml:"array>data>value>string"`
    }
    
    type response struct {
        XMLName xml.Name `xml:"params"`
        Params  []param  `xml:"param"`
    }
    
    var resp response
    if err := xml.Unmarshal(data, &resp); err != nil {
        return nil, err
    }
    
    result := &VATResponse{}
    for _, p := range resp.Params {
        if len(p.Value) == 2 {
            key := p.Value[0]
            value := p.Value[1]
            
            switch key {
            case "Datum":
                result.Datum = value
            case "Uhrzeit":
                result.Uhrzeit = value
            case "ErrorCode":
                result.ErrorCode = value
            case "UstId_1":
                result.UstId_1 = value
            case "UstId_2":
                result.UstId_2 = value
            case "Firmenname":
                result.Firmenname = value
            case "Ort":
                result.Ort = value
            case "PLZ":
                result.PLZ = value
            case "Strasse":
                result.Strasse = value
            case "Erg_Name":
                result.Erg_Name = value
            case "Erg_Ort":
                result.Erg_Ort = value
            case "Erg_PLZ":
                result.Erg_PLZ = value
            case "Erg_Str":
                result.Erg_Str = value
            case "Gueltig_ab":
                result.Gueltig_ab = value
            case "Gueltig_bis":
                result.Gueltig_bis = value
            case "Druck":
                result.Druck = value
            }
        }
    }
    
    return result, nil
}

func XmlRpcCall(method string, args map[string]string) (*VATResponse, error) {
    // 使用gorilla-xmlrpc编码请求
    buf, err := xmlrpc.EncodeClientRequest(method, args)
    if err != nil {
        return nil, err
    }
    
    // 发送请求
    resp, err := http.Post("https://evatr.bff-online.de/evatrRPC", "text/xml", bytes.NewBuffer(buf))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    // 读取响应
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    // 解码响应
    return decodeVATResponse(body)
}

func main() {
    args := map[string]string{
        "UstId_1":   "DE123456789",
        "UstId_2":   "AB1234567890",
        "Firmenname": "Firmenname einschl. Rechtsform",
        "Ort":       "Ort der Firma",
        "PLZ":       "12345",
        "Strasse":   "Strasse der Firma",
        "Druck":     "ja",
    }
    
    response, err := XmlRpcCall("evatrRPC", args)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    // 访问具体字段
    fmt.Printf("ErrorCode: %s\n", response.ErrorCode)
    fmt.Printf("Datum: %s\n", response.Datum)
    fmt.Printf("Uhrzeit: %s\n", response.Uhrzeit)
    fmt.Printf("Firmenname: %s\n", response.Firmenname)
    fmt.Printf("Erg_Name: %s\n", response.Erg_Name)
}

如果需要使用标准库的xml包而不依赖gorilla-xmlrpc，可以使用以下替代方案：

package main

import (
    "bytes"
    "encoding/xml"
    "fmt"
    "io"
    "net/http"
    "strings"
)

// 使用xml包直接解析
func parseVATResponseXML(xmlData string) (map[string]string, error) {
    type StringValue struct {
        String string `xml:"string"`
    }
    
    type Data struct {
        Values []StringValue `xml:"value"`
    }
    
    type Array struct {
        Data Data `xml:"data"`
    }
    
    type Value struct {
        Array Array `xml:"array"`
    }
    
    type Param struct {
        Value Value `xml:"value"`
    }
    
    type Params struct {
        Params []Param `xml:"param"`
    }
    
    var result Params
    err := xml.Unmarshal([]byte(xmlData), &result)
    if err != nil {
        return nil, err
    }
    
    dataMap := make(map[string]string)
    for _, param := range result.Params {
        if len(param.Value.Array.Data.Values) == 2 {
            key := param.Value.Array.Data.Values[0].String
            value := param.Value.Array.Data.Values[1].String
            dataMap[key] = value
        }
    }
    
    return dataMap, nil
}

func makeXMLRPCRequest(method string, params map[string]string) (string, error) {
    var builder strings.Builder
    
    builder.WriteString(`<?xml version="1.0"?>`)
    builder.WriteString(`<methodCall>`)
    builder.WriteString(`<methodName>` + method + `</methodName>`)
    builder.WriteString(`<params>`)
    
    for key, value := range params {
        builder.WriteString(`<param><value><struct>`)
        builder.WriteString(`<member>`)
        builder.WriteString(`<name>` + key + `</name>`)
        builder.WriteString(`<value><string>` + value + `</string></value>`)
        builder.WriteString(`</member>`)
        builder.WriteString(`</struct></value></param>`)
    }
    
    builder.WriteString(`</params>`)
    builder.WriteString(`</methodCall>`)
    
    return builder.String(), nil
}

func main() {
    params := map[string]string{
        "UstId_1":   "DE123456789",
        "UstId_2":   "AB1234567890",
        "Firmenname": "Firmenname einschl. Rechtsform",
        "Ort":       "Ort der Firma",
        "PLZ":       "12345",
        "Strasse":   "Strasse der Firma",
        "Druck":     "ja",
    }
    
    xmlRequest, err := makeXMLRPCRequest("evatrRPC", params)
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }
    
    resp, err := http.Post("https://evatr.bff-online.de/evatrRPC", "text/xml", 
        bytes.NewBufferString(xmlRequest))
    if err != nil {
        fmt.Printf("Error making request: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response: %v\n", err)
        return
    }
    
    result, err := parseVATResponseXML(string(body))
    if err != nil {
        fmt.Printf("Error parsing response: %v\n", err)
        return
    }
    
    // 访问具体字段
    fmt.Printf("ErrorCode: %s\n", result["ErrorCode"])
    fmt.Printf("Datum: %s\n", result["Datum"])
    fmt.Printf("Firmenname: %s\n", result["Firmenname"])
    fmt.Printf("Erg_Name: %s\n", result["Erg_Name"])
}

这两种方法都能正确解析XML-RPC响应并让你通过字段名访问数据，特别是ErrorCode字段。第一种方法使用gorilla-xmlrpc处理编码，第二种方法使用标准库手动构建请求。