You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
153 lines
4.3 KiB
153 lines
4.3 KiB
package common
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
|
|
"gopkg.in/go-playground/validator.v9"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type ErrorResponse struct {
|
|
Success bool `json:"success,omitempty"`
|
|
|
|
// Err is the error message if Success is false
|
|
Err string `json:"error,omitempty"`
|
|
|
|
// Code is set if Success is false
|
|
Code int `json:"code,omitempty"`
|
|
}
|
|
|
|
// ErrorWithCode makes an ErrorResponse with the
|
|
// provided err's Error() content, and status code.
|
|
// It panics if err is nil.
|
|
func ErrorWithCode(err error, code int) *ErrorResponse {
|
|
return &ErrorResponse{
|
|
Err: err.Error(),
|
|
Code: code,
|
|
}
|
|
}
|
|
|
|
// Ensure that ErrorResponse implements error
|
|
var _ error = (*ErrorResponse)(nil)
|
|
|
|
func (er *ErrorResponse) Error() string {
|
|
return er.Err
|
|
}
|
|
|
|
// Ensure that ErrorResponse implements httpCoder
|
|
var _ httpCoder = (*ErrorResponse)(nil)
|
|
|
|
func (er *ErrorResponse) HTTPCode() int {
|
|
return er.Code
|
|
}
|
|
|
|
var errNilBody = errors.Errorf("expecting a non-nil body")
|
|
|
|
// FparseJSON unmarshals into save, the body of the provided reader.
|
|
// Since it uses json.Unmarshal, save must be of a pointer type
|
|
// or compatible with json.Unmarshal.
|
|
func FparseJSON(r io.Reader, save interface{}) error {
|
|
if r == nil {
|
|
return errors.Wrap(errNilBody, "Reader")
|
|
}
|
|
|
|
dec := json.NewDecoder(r)
|
|
if err := dec.Decode(save); err != nil {
|
|
return errors.Wrap(err, "Decode/Unmarshal")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ParseRequestJSON unmarshals into save, the body of the
|
|
// request. It closes the body of the request after parsing.
|
|
// Since it uses json.Unmarshal, save must be of a pointer type
|
|
// or compatible with json.Unmarshal.
|
|
func ParseRequestJSON(r *http.Request, save interface{}) error {
|
|
if r == nil || r.Body == nil {
|
|
return errNilBody
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
return FparseJSON(r.Body, save)
|
|
}
|
|
|
|
// ParseRequestAndValidateJSON unmarshals into save, the body of the
|
|
// request and invokes a validator on the saved content. To ensure
|
|
// validation, make sure to set tags "validate" on your struct as
|
|
// per https://godoc.org/gopkg.in/go-playground/validator.v9.
|
|
// It closes the body of the request after parsing.
|
|
// Since it uses json.Unmarshal, save must be of a pointer type
|
|
// or compatible with json.Unmarshal.
|
|
func ParseRequestAndValidateJSON(r *http.Request, save interface{}) error {
|
|
if r == nil || r.Body == nil {
|
|
return errNilBody
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
return FparseAndValidateJSON(r.Body, save)
|
|
}
|
|
|
|
// FparseAndValidateJSON like FparseJSON unmarshals into save,
|
|
// the body of the provided reader. However, it invokes the validator
|
|
// to check the set validators on your struct fields as per
|
|
// per https://godoc.org/gopkg.in/go-playground/validator.v9.
|
|
// Since it uses json.Unmarshal, save must be of a pointer type
|
|
// or compatible with json.Unmarshal.
|
|
func FparseAndValidateJSON(r io.Reader, save interface{}) error {
|
|
if err := FparseJSON(r, save); err != nil {
|
|
return err
|
|
}
|
|
return validate(save)
|
|
}
|
|
|
|
var theValidator = validator.New()
|
|
|
|
func validate(obj interface{}) error {
|
|
return errors.Wrap(theValidator.Struct(obj), "Validate")
|
|
}
|
|
|
|
// WriteSuccess JSON marshals the content provided, to an HTTP
|
|
// response, setting the provided status code and setting header
|
|
// "Content-Type" to "application/json".
|
|
func WriteSuccess(w http.ResponseWriter, data interface{}) {
|
|
WriteCode(w, data, 200)
|
|
}
|
|
|
|
// WriteCode JSON marshals content, to an HTTP response,
|
|
// setting the provided status code, and setting header
|
|
// "Content-Type" to "application/json". If JSON marshalling fails
|
|
// with an error, WriteCode instead writes out the error invoking
|
|
// WriteError.
|
|
func WriteCode(w http.ResponseWriter, out interface{}, code int) {
|
|
blob, err := json.MarshalIndent(out, "", " ")
|
|
if err != nil {
|
|
WriteError(w, err)
|
|
} else {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(code)
|
|
w.Write(blob)
|
|
}
|
|
}
|
|
|
|
type httpCoder interface {
|
|
HTTPCode() int
|
|
}
|
|
|
|
// WriteError is a convenience function to write out an
|
|
// error to an http.ResponseWriter, to send out an error
|
|
// that's structured as JSON i.e the form
|
|
// {"error": sss, "code": ddd}
|
|
// If err implements the interface HTTPCode() int,
|
|
// it will use that status code otherwise, it will
|
|
// set code to be http.StatusBadRequest
|
|
func WriteError(w http.ResponseWriter, err error) {
|
|
code := http.StatusBadRequest
|
|
if httpC, ok := err.(httpCoder); ok {
|
|
code = httpC.HTTPCode()
|
|
}
|
|
|
|
WriteCode(w, ErrorWithCode(err, code), code)
|
|
}
|