-
Notifications
You must be signed in to change notification settings - Fork 2
/
responder.go
125 lines (100 loc) · 3.05 KB
/
responder.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/*this will send back the payload to the user*/
package yuri
import (
"compress/gzip"
"encoding/json"
"github.com/go-pg/pg/v10"
"io"
"net/http"
"time"
)
type ResponseData struct {
Items interface{} `json:"items"`
TotalItems int `json:"total_items"`
//Pages int `json:"pages"`
}
type gzipResponseWriter struct {
io.Writer
http.ResponseWriter
}
func (w gzipResponseWriter) Write(b []byte) (int, error) {
return w.Writer.Write(b)
}
// JsonGzipBytesResponder / JsonGzipBytesResponder Gzip the response
/// Deprecated:use nginx to Gzip the data
/// The you use this method their is an overhead creating the buffer hence instead
/// of processing 60k request/s your api will process about 4k request/second
/// thus its better to use nginx to gzip
func JsonGzipBytesResponder(w http.ResponseWriter, r *http.Request, b []byte, err *ErrResponse) {
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
gzr := gzipResponseWriter{Writer: gz, ResponseWriter: w}
t := time.Now()
gzr.Write(b)
ExecutionTime(t, "gzip for ytes took about")
}
// JsonGzipResponder / JsonGzipResponder Gzip the response
/// Deprecated:use nginx to Gzip the data
/// The you use this method their is an overhead creating the buffer hence instead
/// of processing 60k request/s your api will process about 4k request/second
/// thus its better to use nginx to gzip
func JsonGzipResponder(w http.ResponseWriter, r *http.Request, item interface{}, err *ErrResponse) {
// create header
if err != nil {
http.Error(w, err.StatusText, err.HTTPStatusCode)
return
}
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
// Gzip data
gz := gzip.NewWriter(w)
json.NewEncoder(gz).Encode(item)
gz.Close()
}
func JsonResponder(w http.ResponseWriter, r *http.Request, item interface{}, err *ErrResponse) {
if err != nil {
http.Error(w, err.StatusText, err.HTTPStatusCode)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(item)
}
func Error404Or500(err error, w http.ResponseWriter, r *http.Request, text string) {
if err != nil && err == pg.ErrNoRows {
if text != "" {
JsonResponder(w, r, nil, &ErrResponse{
HTTPStatusCode: 404,
Message: text,
StatusText: text,
})
return
}
JsonResponder(w, r, nil, ErrNotFound)
return
}
if err != nil {
JsonResponder(w, r, nil, ErrInternalServerError)
return
}
}
func ValidationError(w http.ResponseWriter, r *http.Request, err []Field) {
var errorResponse ErrorsResponse
errorResponse.Errors = err
data, _ := ToJson(errorResponse)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusBadRequest)
w.Write(data)
/*JsonResponder(w,r,data,&ErrResponse{
HTTPStatusCode: http.StatusBadRequest,
Message: "Invalid Request Body" ,
StatusText: data,
})
*/
}
type ErrorsResponse struct {
Errors interface{} `json:"errors"`
}