Cast a json in a properly struct instead of use an interface

Question

i'm struggling to create a data structure for unmarshal the following json:

{
    "asks": [
        ["2.049720", "183.556", 1576323009],
        ["2.049750", "555.125", 1576323009],
        ["2.049760", "393.580", 1576323008],
        ["2.049980", "206.514", 1576322995]
    ],
    "bids": [
        ["2.043800", "20.691", 1576322350],
        ["2.039080", "755.396", 1576323007],
        ["2.036960", "214.621", 1576323006],
        ["2.036930", "700.792", 1576322987]
    ]
}

If I use the following struct with interfaces, there is no problem:

type OrderBook struct {
    Asks [][]interface{} `json:"asks"`
    Bids [][]interface{} `json:"bids"`
}

But i need a more strict typing, so i've tried with:

type BitfinexOrderBook struct {
    Pair string            `json:"pair"`
    Asks [][]BitfinexOrder `json:"asks"`
    Bids [][]BitfinexOrder `json:"bids"`
}

type BitfinexOrder struct {
    Price     string
    Volume    string
    Timestamp time.Time
}

But unfortunately i had not success.

This is the code that I have used for parse the Kraken API for retrieve the order book:

// loadKrakenOrderBook is delegated to load the data related to pairs info
func loadKrakenOrderBook(data []byte) (datastructure.BitfinexOrderBook, error) {
    var err error

    // Creating the maps for the JSON data
    m := map[string]interface{}{}
    var orderbook datastructure.BitfinexOrderBook

    // Parsing/Unmarshalling JSON
    err = json.Unmarshal(data, &m)

    if err != nil {
        zap.S().Debugw("Error unmarshalling data: " + err.Error())
        return orderbook, err
    }

    a := reflect.ValueOf(m["result"])

    if a.Kind() == reflect.Map {
        key := a.MapKeys()[0]
        log.Println("KEY: ", key)
        strct := a.MapIndex(key)
        log.Println("MAP: ", strct)
        m, _ := strct.Interface().(map[string]interface{})
        log.Println("M: ", m)
        data, err := json.Marshal(m)
        if err != nil {
            zap.S().Warnw("Panic on key: ", key.String(), " ERR: "+err.Error())
            return orderbook, err
        }
        log.Println("DATA: ", string(data))
        err = json.Unmarshal(data, &orderbook)
        if err != nil {
            zap.S().Warnw("Panic on key: ", key.String(), " during unmarshal. ERR: "+err.Error())
            return orderbook, err
        }
        return orderbook, nil

    }
    return orderbook, errors.New("UNABLE_PARSE_VALUE")
}

The data that i use for test are the following:

{
    "error": [],
    "result": {
        "LINKUSD": {
            "asks": [
                ["2.049720", "183.556", 1576323009],
                ["2.049750", "555.125", 1576323009],
                ["2.049760", "393.580", 1576323008],
                ["2.049980", "206.514", 1576322995]
            ],
            "bids": [
                ["2.043800", "20.691", 1576322350],
                ["2.039080", "755.396", 1576323007],
                ["2.036960", "214.621", 1576323006],
                ["2.036930", "700.792", 1576322987]
            ]
        }
    }
}

EDIT

NOTE: the data that i receive in input is the latest json that i've post, not the array of bids and asks.

I've tried to integrate the solution proposed by @chmike. Unfortunately there is a few preprocessing to be made, cause the data is the latest json that i've post.

So i've changed to code as following in order to extract the json data related to asks and bids.

func order(data []byte) (datastructure.BitfinexOrderBook, error) {
    var err error

    // Creating the maps for the JSON data
    m := map[string]interface{}{}
    var orderbook datastructure.BitfinexOrderBook
    // var asks datastructure.BitfinexOrder
    // var bids datastructure.BitfinexOrder
    // Parsing/Unmarshalling JSON
    err = json.Unmarshal(data, &m)

    if err != nil {
        zap.S().Warn("Error unmarshalling data: " + err.Error())
        return orderbook, err
    }

    // Extract the "result" json
    a := reflect.ValueOf(m["result"])

    if a.Kind() == reflect.Map {
        key := a.MapKeys()[0]
        log.Println("KEY: ", key)
        log.Println()
        strct := a.MapIndex(key)
        log.Println("MAP: ", strct)
        m, _ := strct.Interface().(map[string]interface{})
        log.Println("M: ", m)
        log.Println("Asks: ", m["asks"])
        log.Println("Bids: ", m["bids"])

        // Here i retrieve the asks array
        asks_data, err := json.Marshal(m["asks"])
        log.Println("OK: ", err)
        log.Println("ASKS: ", string(asks_data))
        var asks datastructure.BitfinexOrder
        // here i try to unmarshal the data into the struct
        asks, err = UnmarshalJSON(asks_data)
        log.Println(err)
        log.Println(asks)

    }
    return orderbook, errors.New("UNABLE_PARSE_VALUE")
}

Unfortunately, i receive the following error:

json: cannot unmarshal array into Go value of type json.Number

Answer 1

As suggested by @Flimzy, you need a custom Unmarshaler. Here it is.

Note that the BitfinexOrderBook definition is slightly different from yours. There was an error in it.

// BitfinexOrderBook is a book of orders.
type BitfinexOrderBook struct {
    Asks []BitfinexOrder `json:"asks"`
    Bids []BitfinexOrder `json:"bids"`
}

// BitfinexOrder is a bitfinex order.
type BitfinexOrder struct {
    Price     string
    Volume    string
    Timestamp time.Time
}

// UnmarshalJSON decode a BifinexOrder.
func (b *BitfinexOrder) UnmarshalJSON(data []byte) error {
    var packedData []json.Number
    err := json.Unmarshal(data, &packedData)
    if err != nil {
        return err
    }
    b.Price = packedData[0].String()
    b.Volume = packedData[1].String()
    t, err := packedData[2].Int64()
    if err != nil {
        return err
    }
    b.Timestamp = time.Unix(t, 0)
    return nil
}

Note also that this custom unmarshaler function allows you to convert the price or volume to a float, which is probably what you want.

Answer 2

While you can hack your way by using reflex, or maybe even write your own parser, the most efficient way is to implement a json.Unmarshaler.

There are a few problem remaining, though.

1. You are transforming a json array to the struct, not just interface{} elements in it, so it should be: Asks []BitfinexOrder and Bids []BitfinexOrder.

2. You need to wrap the struct BitfinexOrderBook to get it work with its data. It is trivial and much simpler than using reflex.

3. By default, json.Unmarshal unmarshals a json number into a float64, which is not a good thing when parsing timestamp. You can use json.NewDecoder to get a decoder and then use Decoder.UseNumber to force use a string.

For example,

func (bo *BitfinexOrder) UnmarshalJSON(data []byte) error {
    dec := json.NewDecoder(bytes.NewReader(data))
    dec.UseNumber()

    var x []interface{}
    err := dec.Decode(&x)
    if err != nil {
        return errParse(err.Error())
    }

    if len(x) != 3 {
        return errParse("length is not 3")
    }

    price, ok := x[0].(string)
    if !ok {
        return errParse("price is not string")
    }

    volume, ok := x[1].(string)
    if !ok {
        return errParse("volume is not string")
    }

    number, ok := x[2].(json.Number)
    if !ok {
        return errParse("timestamp is not number")
    }
    tint64, err := strconv.ParseInt(string(number), 10, 64)
    if err != nil {
        return errParse(fmt.Sprintf("parsing timestamp: %s", err))
    }

    *bo = BitfinexOrder{
        Price:     price,
        Volume:    volume,
        Timestamp: time.Unix(tint64, 0),
    }
    return nil
}

and main func (wrapping the struct):

func main() {
    x := struct {
        Result struct{ LINKUSD BitfinexOrderBook }
    }{}
    err := json.Unmarshal(data, &x)
    if err != nil {
        log.Fatalln(err)
    }

    bob := x.Result.LINKUSD
    fmt.Println(bob)
}

Playground link: https://play.golang.org/p/pC124F-3M_S .

Note: the playground link use a helper function to create errors. Some might argue it is best to name the helper function NewErrInvalidBitfinexOrder or rename the error. That is not the scope of this question and I think for the sake of typing, I will keep the short name for now.