-
Notifications
You must be signed in to change notification settings - Fork 1
/
handler.go
133 lines (108 loc) · 2.81 KB
/
handler.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
package main
import (
"encoding/json"
"errors"
"net/http"
"strings"
log "github.com/sirupsen/logrus"
)
// TokenNewHandler generate a new token
type TokenNewHandler struct {
JWTService *JWTService
}
func (h TokenNewHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
var data map[string]interface{}
if r.Body == nil {
http.Error(w, "Request body is empty", http.StatusUnprocessableEntity)
return
}
decoder := json.NewDecoder(r.Body)
if err := decoder.Decode(&data); err != nil {
log.Error(err)
http.Error(w, "Internal error", http.StatusInternalServerError)
return
}
ts, err := h.JWTService.NewTokenString(data)
if err != nil {
log.Error(err)
http.Error(w, "Internal error", http.StatusInternalServerError)
return
}
SetJSONResponse(w, ts)
}
// TokenCheckHandler validate token
type TokenCheckHandler struct {
JWTService *JWTService
}
func (h TokenCheckHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
tokenString, err := readTokenString(r)
if err != nil {
http.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if tokenString == "" {
http.Error(w, "Empty token string", http.StatusUnauthorized)
return
}
u, err := h.JWTService.ValidateToken(tokenString)
if err != nil {
log.Error(err)
http.Error(w, "Internal error", http.StatusUnauthorized)
return
}
SetJSONResponse(w, map[string]interface{}{
"valid": u != nil,
})
}
// TokenDecodeHandler validate token
type TokenDecodeHandler struct {
JWTService *JWTService
}
func (h TokenDecodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
tokenString, err := readTokenString(r)
if err != nil {
http.Error(w, err.Error(), http.StatusUnauthorized)
return
}
if tokenString == "" {
http.Error(w, "Empty token string", http.StatusUnauthorized)
return
}
u, err := h.JWTService.ValidateToken(tokenString)
if u == nil || err != nil {
if err != nil {
log.Error(err)
}
http.Error(w, "Invalid token", http.StatusUnauthorized)
return
}
SetJSONResponse(w, u)
}
func readTokenString(r *http.Request) (string, error) {
authHeader := r.Header.Get("Authorization")
if authHeader == "" {
return "", nil
}
authHeaderParts := strings.Split(authHeader, ` `)
if len(authHeaderParts) != 2 || strings.ToLower(authHeaderParts[0]) != `bearer` {
err := errors.New("Bad Authorization format header")
log.Error(err)
return "", err
}
return authHeaderParts[1], nil
}
// SetJSONResponse writes the data as JSON as response of the http request
func SetJSONResponse(w http.ResponseWriter, data interface{}) (err error) {
var b []byte
if b, err = json.Marshal(data); err != nil {
log.Error(err)
http.Error(w, "Internal error", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
if _, err = w.Write(b); err != nil {
log.Error(err)
return
}
return
}