Calling bind multiple times

[thdxr]

I'm trying to call bind multiple times to bind to two different models during the same request. It only works the first time I call it, it ends up not binding anything the second time. I suspect this is because a buffer is being read and not being reset. Is there a fix or workaround for this?

[javierprovecho]

I'll take a look into this, I can't guarantee any estimated time just than v0.6.

[msoedov]

Hi guys, I found dirty hack solution how to fix this. But looks like extra memory allocation for bytes.NewBuffer(body) can leads to a performance decrease. Any thoughts?

func bodyReader(req *http.Request) (*bytes.Buffer, error) {
    if req.Body == nil {
        return nil, errors.New("Error")
    }
    body, err := ioutil.ReadAll(req.Body)
    if err != nil {
        return nil, err
    }
    buff := bytes.NewBuffer(body)
    req.Body = ioutil.NopCloser(buff)
    return bytes.NewBuffer(body), nil
}

func (_ jsonBinding) Bind(req *http.Request, obj interface{}) error {
    buff, _ := bodyReader(req)
    decoder := json.NewDecoder(buff)
    if err := decoder.Decode(obj); err == nil {
        return Validate(obj)
    } else {
        return err
    }
}

Test:

//  issue #216
func TestBindingMultipleTimes(t *testing.T) {

    body := bytes.NewBuffer([]byte("{\"foo\":\"bar\"}"))

    r := New()
    var modelA struct {
        A string `json:"foo"`
    }

    var modelB struct {
        B string `json:"foo"`
    }
    r.POST("/binding/multiple/bind", func(c *Context) {
        if !c.Bind(&modelA) {
            c.JSON(500, H{"error": "failed to bind first model"})
            return
        }
        if !c.Bind(&modelB) {
            c.JSON(500, H{"error": "failed to bind second model"})
            return
        }

        if modelA.A != modelB.B {
            debugPrint("%s!=%s", modelA, modelB)
            c.JSON(500, H{"error": "failed fields aren't equals"})
            return

        }
        c.JSON(200, H{"parsed": modelB.B})

    })

    req, _ := http.NewRequest("POST", "/binding/multiple/bind", body)
    req.Header.Set("Content-Type", "application/json")
    w := httptest.NewRecorder()

    r.ServeHTTP(w, req)

    if w.Code != 200 {
        t.Errorf("Response code should be Ok, was: %d", w.Code)
    }

    if w.Body.String() != "{\"parsed\":\"bar\"}\n" {
        t.Errorf("Response should be {\"parsed\":\"bar\"}, was: %s", w.Body.String())
    }

}

[manucorporat]

how about this approach?

    r.Use(func(c *Context) {
        var model Model
        if c.Bind(&model) {
            c.Set("data_model", model)
            // use model
        }else{
            c.AbortWithStatus(400)
        }
    })

    r.POST("/binding/multiple/bind", func(c *Context) {
        model := c.MustGet("data_model").(Model)
    })

[msoedov]

It won't work for case when model fields are significantly different i.e

    body := bytes.NewBuffer([]byte(`{"foo":"bar", "time": 2323793, "name": "GIN"}`))

    r := New()
    var modelA struct {
        A    string `json:"foo"`
        Name string `json:"name"`
    }

    var modelB struct {
        B         string `json:"foo"`
        Timestamp int    `json:"time"`
    }

Is it a real case? What do you think?

[nazwa]

I agree that binding multiple times should be possible one way or another, even with explicit and manual buffer refresh, since this will be a very infrequent use case. In the meantime, as a workaround, you could just create a 'parent' model that inherits both A and B

var modelAB struct {
    modelA
    modelB
}

Which, if i remember correctly, should bind nicely all variables. Only issue is that then you end up with all data in one but this shouldn't be too much of a problem in most cases.

[thinkong]

Has there been any progress on this?
Is there a work around?

I am also in need of a way to bind a request and then also read it again. I could copy it to a bytes.Buffer, but then can no longer bind the request...

[adriendomoison]

+1 this would be awesome to patch that !

@manucorporat using the set capability is definitely not the approach we would like to implement since it makes routes highly dependent of middlewares, while middlewares should be only "plugins", @msoedov solution is today the only viable alternative.

Thank you ! ❤️