/
response.go
134 lines (104 loc) · 2.58 KB
/
response.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
126
127
128
129
130
131
132
133
134
package common
import (
"encoding/json"
"errors"
"fmt"
"net/http"
"github.com/citizenwallet/indexer/pkg/indexer"
)
type ResponseType string
const (
ResponseTypeObject ResponseType = "object"
ResponseTypeArray ResponseType = "array"
ResponseTypeSecure ResponseType = "secure"
)
type AddressResponse struct {
Address string `json:"address"`
}
type Pagination struct {
Limit int `json:"limit"`
Offset int `json:"offset"`
Total int `json:"total"`
}
// Response is the default response object
// swagger:response defaultResponse
type Response struct {
// The response type
// in: body
ResponseType ResponseType `json:"response_type"`
Object any `json:"object,omitempty"`
Array any `json:"array,omitempty"`
Meta any `json:"meta,omitempty"`
}
func Body(w http.ResponseWriter, body any, meta any) error {
b, err := json.Marshal(&Response{
ResponseType: ResponseTypeObject,
Object: body,
Meta: meta,
})
if err != nil {
return err
}
w.Header().Add("Content-Type", "application/json")
w.Write(b)
return nil
}
func BodyMultiple(w http.ResponseWriter, body any, meta any) error {
b, err := json.Marshal(&Response{
ResponseType: ResponseTypeArray,
Array: body,
Meta: meta,
})
if err != nil {
return err
}
w.Header().Add("Content-Type", "application/json")
w.Write(b)
return nil
}
func StreamedBody(w http.ResponseWriter, body string) error {
flusher, ok := w.(http.Flusher)
if !ok {
return errors.New("stearming not supported")
}
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Connection", "keep-alive")
w.Header().Set("Access-Control-Allow-Origin", "*")
fmt.Fprintf(w, "%s", body)
flusher.Flush()
return nil
}
func JSONRPCBody(w http.ResponseWriter, id int, body any, meta any) error {
b, err := json.Marshal(&indexer.JsonRPCResponse{
Version: "2.0",
ID: id,
Result: body,
})
if err != nil {
return err
}
w.Header().Add("Content-Type", "application/json")
w.Write(b)
return nil
}
func JSONRPCMultiBody(w http.ResponseWriter, ids []int, bodies []any, meta any) error {
if len(ids) != len(bodies) {
return errors.New("ids and bodies must have the same length")
}
responses := make([]indexer.JsonRPCResponse, len(ids))
for i, id := range ids {
responses[i] = indexer.JsonRPCResponse{
Version: "2.0",
ID: id,
Result: bodies[i],
}
}
b, err := json.Marshal(&responses)
if err != nil {
return err
}
w.Header().Add("Content-Type", "application/json")
w.Write(b)
return nil
}