Mercurial > gemma

comparison pkg/controllers/importqueue.go @ 4244:4394daeea96a json-handler-middleware

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Moved JSONHandler into middleware package.
author Sascha L. Teichmann <sascha.teichmann@intevation.de>
date Thu, 22 Aug 2019 11:26:48 +0200
parents d776110b4db0
children 47922c1a088d
comparison
equal deleted inserted replaced
4243:d776110b4db0 4244:4394daeea96a
28 28
29 "gemma.intevation.de/gemma/pkg/auth" 29 "gemma.intevation.de/gemma/pkg/auth"
30 "gemma.intevation.de/gemma/pkg/common" 30 "gemma.intevation.de/gemma/pkg/common"
31 "gemma.intevation.de/gemma/pkg/imports" 31 "gemma.intevation.de/gemma/pkg/imports"
32 "gemma.intevation.de/gemma/pkg/models" 32 "gemma.intevation.de/gemma/pkg/models"
33
34 mw "gemma.intevation.de/gemma/pkg/middleware"
33 ) 35 )
34 36
35 const ( 37 const (
36 selectImportsCountSQL = ` 38 selectImportsCountSQL = `
37 SELECT count(*) 39 SELECT count(*)
226 return nil 228 return nil
227 } 229 }
228 return &models.ImportTime{Time: when.UTC()} 230 return &models.ImportTime{Time: when.UTC()}
229 } 231 }
230 232
231 func listImports(req *http.Request) (jr JSONResult, err error) { 233 func listImports(req *http.Request) (jr mw.JSONResult, err error) {
232 234
233 var list, before, after *filledStmt 235 var list, before, after *filledStmt
234 236
235 if list, before, after, err = buildFilters(req); err != nil { 237 if list, before, after, err = buildFilters(req); err != nil {
236 return 238 return
237 } 239 }
238 240
239 ctx := req.Context() 241 ctx := req.Context()
240 242
241 conn := JSONConn(req) 243 conn := mw.JSONConn(req)
242 244
243 // Fast path for counting 245 // Fast path for counting
244 246
245 switch count := strings.ToLower(req.FormValue("count")); count { 247 switch count := strings.ToLower(req.FormValue("count")); count {
246 case "1", "t", "true": 248 case "1", "t", "true":
250 case err == sql.ErrNoRows: 252 case err == sql.ErrNoRows:
251 count, err = 0, nil 253 count, err = 0, nil
252 case err != nil: 254 case err != nil:
253 return 255 return
254 } 256 }
255 jr = JSONResult{Result: count} 257 jr = mw.JSONResult{Result: count}
256 return 258 return
257 } 259 }
258 260
259 // Generate the list 261 // Generate the list
260 262
303 305
304 if after != nil { 306 if after != nil {
305 next = neighbored(ctx, conn, after) 307 next = neighbored(ctx, conn, after)
306 } 308 }
307 309
308 jr = JSONResult{ 310 jr = mw.JSONResult{
309 Result: struct { 311 Result: struct {
310 Prev *models.ImportTime `json:"prev,omitempty"` 312 Prev *models.ImportTime `json:"prev,omitempty"`
311 Next *models.ImportTime `json:"next,omitempty"` 313 Next *models.ImportTime `json:"next,omitempty"`
312 Imports []*models.Import `json:"imports"` 314 Imports []*models.Import `json:"imports"`
313 }{ 315 }{
317 }, 319 },
318 } 320 }
319 return 321 return
320 } 322 }
321 323
322 func importLogs(req *http.Request) (jr JSONResult, err error) { 324 func importLogs(req *http.Request) (jr mw.JSONResult, err error) {
323 325
324 ctx := req.Context() 326 ctx := req.Context()
325 327
326 id, _ := strconv.ParseInt(mux.Vars(req)["id"], 10, 64) 328 id, _ := strconv.ParseInt(mux.Vars(req)["id"], 10, 64)
327 329
328 conn := JSONConn(req) 330 conn := mw.JSONConn(req)
329 331
330 // Check if he have such a import job first. 332 // Check if he have such a import job first.
331 var summary sql.NullString 333 var summary sql.NullString
332 var enqueued time.Time 334 var enqueued time.Time
333 err = conn.QueryRowContext(ctx, selectImportSummarySQL, id).Scan( 335 err = conn.QueryRowContext(ctx, selectImportSummarySQL, id).Scan(
334 &summary, 336 &summary,
335 &enqueued, 337 &enqueued,
336 ) 338 )
337 switch { 339 switch {
338 case err == sql.ErrNoRows: 340 case err == sql.ErrNoRows:
339 err = JSONError{ 341 err = mw.JSONError{
340 Code: http.StatusNotFound, 342 Code: http.StatusNotFound,
341 Message: fmt.Sprintf("Cannot find import #%d.", id), 343 Message: fmt.Sprintf("Cannot find import #%d.", id),
342 } 344 }
343 return 345 return
344 case err != nil: 346 case err != nil:
376 378
377 if err = rows.Err(); err != nil { 379 if err = rows.Err(); err != nil {
378 return 380 return
379 } 381 }
380 382
381 jr = JSONResult{ 383 jr = mw.JSONResult{
382 Result: struct { 384 Result: struct {
383 Enqueued models.ImportTime `json:"enqueued"` 385 Enqueued models.ImportTime `json:"enqueued"`
384 Summary interface{} `json:"summary,omitempty"` 386 Summary interface{} `json:"summary,omitempty"`
385 Entries []*models.ImportLogEntry `json:"entries"` 387 Entries []*models.ImportLogEntry `json:"entries"`
386 }{ 388 }{
390 }, 392 },
391 } 393 }
392 return 394 return
393 } 395 }
394 396
395 func deleteImport(req *http.Request) (jr JSONResult, err error) { 397 func deleteImport(req *http.Request) (jr mw.JSONResult, err error) {
396 398
397 ctx := req.Context() 399 ctx := req.Context()
398 id, _ := strconv.ParseInt(mux.Vars(req)["id"], 10, 64) 400 id, _ := strconv.ParseInt(mux.Vars(req)["id"], 10, 64)
399 401
400 var tx *sql.Tx 402 var tx *sql.Tx
401 tx, err = JSONConn(req).BeginTx(ctx, nil) 403 tx, err = mw.JSONConn(req).BeginTx(ctx, nil)
402 if err != nil { 404 if err != nil {
403 return 405 return
404 } 406 }
405 defer tx.Rollback() 407 defer tx.Rollback()
406 408
407 // Check if he have such a import job first. 409 // Check if he have such a import job first.
408 var dummy bool 410 var dummy bool
409 err = tx.QueryRowContext(ctx, selectHasNoRunningImportSQL, id).Scan(&dummy) 411 err = tx.QueryRowContext(ctx, selectHasNoRunningImportSQL, id).Scan(&dummy)
410 switch { 412 switch {
411 case err == sql.ErrNoRows: 413 case err == sql.ErrNoRows:
412 err = JSONError{ 414 err = mw.JSONError{
413 Code: http.StatusNotFound, 415 Code: http.StatusNotFound,
414 Message: fmt.Sprintf("Cannot find import #%d.", id), 416 Message: fmt.Sprintf("Cannot find import #%d.", id),
415 } 417 }
416 return 418 return
417 case err != nil: 419 case err != nil:
428 430
429 if err = tx.Commit(); err != nil { 431 if err = tx.Commit(); err != nil {
430 return 432 return
431 } 433 }
432 434
433 jr = JSONResult{Code: http.StatusNoContent} 435 jr = mw.JSONResult{Code: http.StatusNoContent}
434 436
435 return 437 return
436 } 438 }
437 439
438 const ( 440 const (
454 456
455 logDecisionSQL = ` 457 logDecisionSQL = `
456 INSERT INTO import.import_logs (import_id, msg) VALUES ($1, $2)` 458 INSERT INTO import.import_logs (import_id, msg) VALUES ($1, $2)`
457 ) 459 )
458 460
459 func reviewImports(req *http.Request) (JSONResult, error) { 461 func reviewImports(req *http.Request) (mw.JSONResult, error) {
460 462
461 rs := *JSONInput(req).(*[]models.Review) 463 rs := *mw.JSONInput(req).(*[]models.Review)
462 464
463 type reviewResult struct { 465 type reviewResult struct {
464 ID int64 `json:"id"` 466 ID int64 `json:"id"`
465 Message string `json:"message,omitempty"` 467 Message string `json:"message,omitempty"`
466 Error string `json:"error,omitempty"` 468 Error string `json:"error,omitempty"`
467 } 469 }
468 470
469 results := make([]reviewResult, len(rs)) 471 results := make([]reviewResult, len(rs))
470 472
471 conn := JSONConn(req) 473 conn := mw.JSONConn(req)
472 474
473 for i := range rs { 475 for i := range rs {
474 rev := &rs[i] 476 rev := &rs[i]
475 msg, err := decideImport(req, conn, rev.ID, string(rev.State)) 477 msg, err := decideImport(req, conn, rev.ID, string(rev.State))
476 var errString string 478 var errString string
482 Message: msg, 484 Message: msg,
483 Error: errString, 485 Error: errString,
484 } 486 }
485 } 487 }
486 488
487 return JSONResult{Result: results}, nil 489 return mw.JSONResult{Result: results}, nil
488 } 490 }
489 491
490 func reviewImport(req *http.Request) (jr JSONResult, err error) { 492 func reviewImport(req *http.Request) (jr mw.JSONResult, err error) {
491 493
492 vars := mux.Vars(req) 494 vars := mux.Vars(req)
493 id, _ := strconv.ParseInt(vars["id"], 10, 64) 495 id, _ := strconv.ParseInt(vars["id"], 10, 64)
494 state := vars["state"] 496 state := vars["state"]
495 497
496 var msg string 498 var msg string
497 if msg, err = decideImport(req, JSONConn(req), id, state); err != nil { 499 if msg, err = decideImport(req, mw.JSONConn(req), id, state); err != nil {
498 return 500 return
499 } 501 }
500 502
501 result := struct { 503 result := struct {
502 Message string `json:"message"` 504 Message string `json:"message"`
503 }{ 505 }{
504 Message: msg, 506 Message: msg,
505 } 507 }
506 508
507 jr = JSONResult{Result: &result} 509 jr = mw.JSONResult{Result: &result}
508 return 510 return
509 } 511 }
510 512
511 func decideImport( 513 func decideImport(
512 req *http.Request, 514 req *http.Request,
525 var kind string 527 var kind string
526 528
527 err = tx.QueryRowContext(ctx, isPendingSQL, id).Scan(&pending, &kind) 529 err = tx.QueryRowContext(ctx, isPendingSQL, id).Scan(&pending, &kind)
528 switch { 530 switch {
529 case err == sql.ErrNoRows: 531 case err == sql.ErrNoRows:
530 err = JSONError{ 532 err = mw.JSONError{
531 Code: http.StatusNotFound, 533 Code: http.StatusNotFound,
532 Message: fmt.Sprintf("cannot find import #%d", id), 534 Message: fmt.Sprintf("cannot find import #%d", id),
533 } 535 }
534 return 536 return
535 case err != nil: 537 case err != nil:
536 return 538 return
537 case !pending: 539 case !pending:
538 err = JSONError{ 540 err = mw.JSONError{
539 Code: http.StatusConflict, 541 Code: http.StatusConflict,
540 Message: fmt.Sprintf("import #%d is not pending", id), 542 Message: fmt.Sprintf("import #%d is not pending", id),
541 } 543 }
542 return 544 return
543 } 545 }