如何解析包装的json对象

Question

some API endpoint may return successful result or error like this:

// ok
{
    "status": "ok",
    "payload": {
        "id": 10,
        "title": "Sample"
    },
    "request_id": "lx-VHr4OLm"
}
// error
{
    "status": "error",
    "payload": {
        "message": "internal error"
    },
    "trace_id": "lx-VHr4OLm"
}

I'm trying to find elegant way to parse with Go, something like this

.... some code
if status == "ok" {
    struct := AppStruct{} // AppStruct contains 2 fields: id and title
    _ := json.Unmarshall(payloadBody, &struct)
    return struct 
} else {
    errorStruct := ErrorStruct{} // contains 1 field for message.
    _ := json.Unmarshall(payloadBody, &errorStruct) 
    return nil, errors.New(errorStruct.Message)
}

My current code not works for success payload:

var result map[string]interface{}
jsonErr := json.Unmarshal(body, &result)
if jsonErr != nil {
    return nil, jsonErr
}
if result["status"] == "error" {
    errorPayload := result["payload"].(map[string]string)
    return nil, errors.New(errorPayload["message"])
} else if result["status"] == "ok" {
    apiResponse := AppInfo{}
    jsonErr := json.Unmarshal([]byte(result["payload"].(string)), &apiResponse)
    if jsonErr != nil {
        return nil, jsonErr
    }
    return &apiResponse, nil
}

And I got runtime error on line json.Unmarshal([]byte(result["payload"].(string)), &apiResponse)

http: panic serving [::1]:51091: interface conversion: interface {} is map[string]interface {}, not string

Surely, I may have 2 structs: for success response and for error one but I assume it's too complicated way to solve my problem.

How to parse this JSON in elegant way?

Answer 1

Thanks https://stackoverflow.com/users/965900/mkopriva for idea to use json.RawMessage

My final solution:

func parsePayload(response []byte, successPayload interface{}) error {
    var result map[string]json.RawMessage
    jsonErr := json.Unmarshal(response, &result)
    if jsonErr != nil {
        return jsonErr
    }
    var status string
    jsonErr = json.Unmarshal(result["status"], &status)
    if jsonErr != nil {
        return jsonErr
    }
    if status == "ok" {
        jsonErr = json.Unmarshal(result["payload"], &successPayload)
        if jsonErr != nil {
            return jsonErr
        }
        return nil
    } else if status == "error" {
        errorPayload := ErrorPayload{}
        jsonErr = json.Unmarshal(result["payload"], &errorPayload)
        if jsonErr != nil {
            return jsonErr
        }
        return errors.New(errorPayload.Message)
    }
    log.Printf("Unknown http result status: %s", status)
    return errors.New("internal error")
}

type ErrorPayload struct {
    Message string `json:"message"`
}

//usage

type AppInfo struct {
    Id    int    `json:"app_id"`
    Title string `json:"app_title"`
}

body := ... // read body
appInfo := AppInfo{}
parseErr := parsePayload(body, &appInfo)
if parseErr != nil {
    return nil, parseErr
}
log.Printf("Parsed app %v", appInfo)
return &appInfo, nil