/
util.go
108 lines (93 loc) · 2.66 KB
/
util.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
package handler
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"strconv"
"github.com/allisson/postmand"
validation "github.com/go-ozzo/ozzo-validation/v4"
"go.uber.org/zap"
)
func makeResponse(w http.ResponseWriter, body []byte, statusCode int, contentType string, logger *zap.Logger) {
w.Header().Set("Content-Type", fmt.Sprintf("%s; charset=utf-8", contentType))
w.WriteHeader(statusCode)
_, err := w.Write(body)
if err != nil {
logger.Error("http-failed-to-write-response-body", zap.Error(err))
}
}
func makeJSONResponse(w http.ResponseWriter, statusCode int, body interface{}, logger *zap.Logger) {
d, err := json.Marshal(body)
if err != nil {
logger.Error("http-failed-to-marshal-body", zap.Error(err))
}
c := new(bytes.Buffer)
err = json.Compact(c, d)
if err != nil {
logger.Error("http-failed-to-compact-json", zap.Error(err))
}
makeResponse(w, c.Bytes(), statusCode, "application/json", logger)
}
func makeErrorResponse(w http.ResponseWriter, er *errorResponse, logger *zap.Logger) {
makeJSONResponse(w, er.StatusCode, er, logger)
}
func readBodyJSON(r *http.Request, into interface{}, logger *zap.Logger) *errorResponse {
requestBody, err := io.ReadAll(r.Body)
if err != nil {
logger.Error("read-request-body-error", zap.Error(err))
er := errorResponses["internal_server_error"]
return &er
}
if err := json.Unmarshal(requestBody, into); err != nil {
logger.Error("request-json-unmarshal-error", zap.Error(err))
er := errorResponses["malformed_request_body"]
return &er
}
if val, ok := into.(validation.Validatable); ok {
if err := val.Validate(); err != nil {
if e, ok := err.(validation.InternalError); ok {
logger.Error("read-request-validate-error", zap.Error(e))
er := errorResponses["internal_server_error"]
return &er
}
er := errorResponses["request_validation_failed"]
er.Details = err.Error()
return &er
}
}
return nil
}
func makeListOptions(r *http.Request, filters []string) (postmand.RepositoryListOptions, error) {
listOptions := postmand.RepositoryListOptions{}
if err := r.ParseForm(); err != nil {
return listOptions, err
}
// Parse limit and offset
limit := 50
offset := 0
if r.Form.Get("limit") != "" {
v, err := strconv.Atoi(r.Form.Get("limit"))
if err == nil && v <= limit {
limit = v
}
}
if r.Form.Get("offset") != "" {
v, err := strconv.Atoi(r.Form.Get("offset"))
if err == nil {
offset = v
}
}
listOptions.Limit = limit
listOptions.Offset = offset
// Parse filters
f := make(map[string]interface{})
for _, filter := range filters {
if r.Form.Get(filter) != "" {
f[filter] = r.Form.Get(filter)
}
}
listOptions.Filters = f
return listOptions, nil
}