140 lines
3.0 KiB
Go
140 lines
3.0 KiB
Go
// Copyright 2016 Tim Shannon. All rights reserved.
|
|
// Use of this source code is governed by the MIT license
|
|
// that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
)
|
|
|
|
const (
|
|
acceptHTML = "text/html"
|
|
)
|
|
|
|
// Err404 is a standard 404 error response
|
|
var Err404 = errors.New("Resource not found")
|
|
|
|
func errHandled(err error, w http.ResponseWriter) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
|
|
var status, errMsg string
|
|
|
|
errMsg = err.Error()
|
|
|
|
switch err.(type) {
|
|
|
|
case *Fail:
|
|
status = statusFail
|
|
case *http.ProtocolError, *json.SyntaxError, *json.UnmarshalTypeError:
|
|
//Hardcoded external errors which can bubble up to the end users
|
|
// without exposing internal server information, make them failures
|
|
err = FailFromErr(err)
|
|
status = statusFail
|
|
|
|
errMsg = fmt.Sprintf("We had trouble parsing your input, please check your input and try again: %s", err)
|
|
default:
|
|
status = statusError
|
|
errMsg = "An internal server error has occurred"
|
|
}
|
|
|
|
if status == statusFail {
|
|
respondJsendCode(w, &JSend{
|
|
Status: status,
|
|
Message: errMsg,
|
|
Data: err.(*Fail).Data,
|
|
}, err.(*Fail).HTTPStatus)
|
|
} else {
|
|
respondJsend(w, &JSend{
|
|
Status: status,
|
|
Message: errMsg,
|
|
})
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// four04 is a standard 404 response if request header accepts text/html
|
|
// they'll get a 404 page, otherwise a json response
|
|
func four04(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Cache-Control", "no-cache")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
response := &JSend{
|
|
Status: statusFail,
|
|
Message: "Resource not found",
|
|
Data: r.URL.String(),
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
result, err := json.Marshal(response)
|
|
if err != nil {
|
|
log.Printf("Error marshalling 404 response: %s", err)
|
|
return
|
|
}
|
|
|
|
_, err = w.Write(result)
|
|
if err != nil {
|
|
log.Printf("Error in four04: %s", err)
|
|
}
|
|
}
|
|
|
|
// Fail is an error whose contents can be exposed to the client and is usually the result
|
|
// of incorrect client input
|
|
type Fail struct {
|
|
Message string `json:"message,omitempty"`
|
|
Data interface{} `json:"data,omitempty"`
|
|
HTTPStatus int `json:"-"` //gets set in the error response
|
|
}
|
|
|
|
func (f *Fail) Error() string {
|
|
return f.Message
|
|
}
|
|
|
|
// NewFail creates a new failure, data is optional
|
|
func NewFail(message string, data ...interface{}) error {
|
|
return &Fail{
|
|
Message: message,
|
|
Data: data,
|
|
HTTPStatus: 0,
|
|
}
|
|
}
|
|
|
|
// FailFromErr returns a new failure based on the passed in error, data is optional
|
|
// if passed in error is nil, then nil is returned
|
|
func FailFromErr(err error, data ...interface{}) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
return NewFail(err.Error(), data...)
|
|
}
|
|
|
|
// IsEqual tests whether an error is equal to another error / failure
|
|
func (f *Fail) IsEqual(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
|
|
return err.Error() == f.Error()
|
|
}
|
|
|
|
// IsFail tests whether the passed in error is a failure
|
|
func IsFail(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
switch err.(type) {
|
|
case *Fail:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|