Mercurial > gemma

comparison controllers/user.go @ 237:3771788d3dae

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Reduce boilerplate code when writing JSON parsing/generating endpoints.
author Sascha L. Teichmann <sascha.teichmann@intevation.de>
date Thu, 26 Jul 2018 17:07:03 +0200
parents 7d1f0ffdfa41
children 9012e4045da4
comparison
equal deleted inserted replaced
236:664fe6536141 237:3771788d3dae
2 2
3 import ( 3 import (
4 "database/sql" 4 "database/sql"
5 "encoding/json" 5 "encoding/json"
6 "errors" 6 "errors"
7 "log"
8 "net/http" 7 "net/http"
9 "regexp" 8 "regexp"
10 "strings" 9 "strings"
11 10
12 "gemma.intevation.de/gemma/auth"
13 "github.com/gorilla/mux" 11 "github.com/gorilla/mux"
14 "github.com/jackc/pgx"
15 ) 12 )
16 13
17 type ( 14 type (
18 Email string 15 Email string
19 Country string 16 Country string
118 } 115 }
119 } 116 }
120 return errNoValidRole 117 return errNoValidRole
121 } 118 }
122 119
123 func updateUser(rw http.ResponseWriter, req *http.Request) { 120 func updateUser(
121 rw http.ResponseWriter, req *http.Request,
122 input interface{},
123 db *sql.DB,
124 ) (jr JSONResult, err error) {
124 125
125 user := mux.Vars(req)["user"] 126 user := mux.Vars(req)["user"]
126 if user == "" { 127 if user == "" {
127 http.Error(rw, "error: user empty", http.StatusBadRequest) 128 err = JSONError{http.StatusBadRequest, "error: user empty"}
128 return 129 return
129 } 130 }
130 131
131 var newUser User 132 newUser := input.(*User)
132 133
133 defer req.Body.Close() 134 if newUser.Extent == nil {
134 if err := json.NewDecoder(req.Body).Decode(&newUser); err != nil { 135 _, err = db.Exec(
135 http.Error(rw, "error: "+err.Error(), http.StatusBadRequest) 136 updateUserSQL,
137 user,
138 string(newUser.Role),
139 newUser.User,
140 newUser.Password,
141 string(newUser.Country),
142 string(newUser.Email),
143 )
144 } else {
145 _, err = db.Exec(
146 updateUserExtentSQL,
147 user,
148 string(newUser.Role),
149 newUser.User,
150 newUser.Password,
151 string(newUser.Country),
152 newUser.Extent.X1, newUser.Extent.Y1,
153 newUser.Extent.X2, newUser.Extent.Y2,
154 string(newUser.Email),
155 )
156 }
157
158 if err != nil {
136 return 159 return
137 } 160 }
138 161
139 token, _ := auth.GetToken(req) 162 jr = JSONResult{
140 err := auth.ConnPool.Do(token, func(db *sql.DB) (err error) { 163 Code: http.StatusCreated,
141 if newUser.Extent == nil { 164 Result: struct {
142 _, err = db.Exec( 165 Result string `json:"result"`
143 updateUserSQL, 166 }{
144 user, 167 Result: "success",
145 string(newUser.Role), 168 },
146 newUser.User, 169 }
147 newUser.Password, 170 return
148 string(newUser.Country), 171 }
149 string(newUser.Email), 172
150 ) 173 func createUser(
151 } else { 174 rw http.ResponseWriter, req *http.Request,
152 _, err = db.Exec( 175 input interface{},
153 updateUserExtentSQL, 176 db *sql.DB,
154 user, 177 ) (jr JSONResult, err error) {
155 string(newUser.Role), 178
156 newUser.User, 179 user := input.(*User)
157 newUser.Password, 180
158 string(newUser.Country), 181 if user.Extent == nil {
159 newUser.Extent.X1, newUser.Extent.Y1, 182 _, err = db.Exec(
160 newUser.Extent.X2, newUser.Extent.Y2, 183 createUserSQL,
161 string(newUser.Email), 184 string(user.Role),
162 ) 185 user.User,
163 } 186 user.Password,
187 string(user.Country),
188 string(user.Email),
189 )
190 } else {
191 _, err = db.Exec(
192 createUserExtentSQL,
193 string(user.Role),
194 user.User,
195 user.Password,
196 string(user.Country),
197 user.Extent.X1, user.Extent.Y1,
198 user.Extent.X2, user.Extent.Y2,
199 string(user.Email),
200 )
201 }
202
203 if err != nil {
164 return 204 return
165 }) 205 }
166 206
167 var res struct { 207 jr = JSONResult{
168 Result string `json:"result"` 208 Code: http.StatusCreated,
169 Code string `json:"code,omitempty"` 209 Result: struct {
170 Message string `json:"message,omitempty"` 210 Result string `json:"result"`
171 } 211 }{
172 212 Result: "success",
173 if err != nil { 213 },
174 if pgErr, ok := err.(pgx.PgError); ok { 214 }
175 res.Result = "failure" 215 return
176 res.Code = pgErr.Code 216 }
177 res.Message = pgErr.Message
178 } else {
179 log.Printf("err: %v\n", err)
180 http.Error(rw,
181 "error: "+err.Error(),
182 http.StatusInternalServerError)
183 return
184 }
185 } else {
186 res.Result = "success"
187 }
188
189 rw.Header().Set("Content-Type", "application/json")
190 if err := json.NewEncoder(rw).Encode(&res); err != nil {
191 log.Printf("error: %v\n", err)
192 }
193 }
194
195 func createUser(rw http.ResponseWriter, req *http.Request) {
196
197 var user User
198
199 defer req.Body.Close()
200 if err := json.NewDecoder(req.Body).Decode(&user); err != nil {
201 http.Error(rw, "error: "+err.Error(), http.StatusBadRequest)
202 return
203 }
204
205 token, _ := auth.GetToken(req)
206 err := auth.ConnPool.Do(token, func(db *sql.DB) (err error) {
207 if user.Extent == nil {
208 _, err = db.Exec(
209 createUserSQL,
210 string(user.Role),
211 user.User,
212 user.Password,
213 string(user.Country),
214 string(user.Email),
215 )
216 } else {
217 _, err = db.Exec(
218 createUserExtentSQL,
219 string(user.Role),
220 user.User,
221 user.Password,
222 string(user.Country),
223 user.Extent.X1, user.Extent.Y1,
224 user.Extent.X2, user.Extent.Y2,
225 string(user.Email),
226 )
227 }
228 return
229 })
230
231 var res struct {
232 Result string `json:"result"`
233 Code string `json:"code,omitempty"`
234 Message string `json:"message,omitempty"`
235 }
236
237 if err != nil {
238 if pgErr, ok := err.(pgx.PgError); ok {
239 res.Result = "failure"
240 res.Code = pgErr.Code
241 res.Message = pgErr.Message
242 } else {
243 log.Printf("err: %v\n", err)
244 http.Error(rw,
245 "error: "+err.Error(),
246 http.StatusInternalServerError)
247 return
248 }
249 } else {
250 res.Result = "success"
251 }
252
253 rw.Header().Set("Content-Type", "application/json")
254 if err := json.NewEncoder(rw).Encode(&res); err != nil {
255 log.Printf("error: %v\n", err)
256 }
257 }