Restituisce gli errori postgres nella risposta api

Question

Ho due semplici metodi API nel mio codice. Il metodo con endpoind /api/user/createcrea l'utente. Il campo usernameè unico. Quando provo a creare un utente con lo stesso nome utente che già esiste nel database, ho un errore nella console:

(/home/andrej/go/src/go_contacts/models/users.go:19) 
[2020-12-23 22:03:10]  pq: duplicate key value violates unique constraint "users_username_key"

Voglio mostrare questo errore in risposta all'utente, o in qualche modo identificare il tipo di errore nel mio codice, per mostrare diversi messaggi di errore per l'utente. So solo che se ho un errore usermi restituisce id = 0. Ma non sembra un buon messaggio per l'utente.

main.go

package main

import (
    "fmt"
    "go_contacts/controllers"
    "net/http"
    "os"

    "github.com/gorilla/mux"
    "github.com/joho/godotenv"
)

func main() {
    godotenv.Load(".env")


    router := mux.NewRouter()
    router.HandleFunc("/", controllers.ReturnHello).Methods("GET")
    router.HandleFunc("/api/user/create", controllers.CreateUser).Methods("POST")

    port := os.Getenv("PORT")
    if port == "" {
        port = "8000"
    }

    err := http.ListenAndServe(":"+port, router)
    if err != nil {
        fmt.Print(err)
    }
}

models.go con struttura utente:

package models

import (
    u "go_contacts/utils"

    "github.com/jinzhu/gorm"
)

// User base model
type User struct {
    gorm.Model
    Username string `json:"username" gorm:"unique"`
    Password string `json:"password"`
    Email    string `json:"email"`
}

// Create new user
func (user *User) Create() map[string]interface{} {
    GetDB().Create(user)

    if user.ID <= 0 {
        return u.Message(false, "Failed to create user, connection error.")
    }

    response := u.Message(true, "Account has been created")
    response["user"] = user
    return response
}

Answer 1

Per quanto riguarda pq v1.5.2 e gorm v1.9.12

Innanzitutto, è necessario identificare se la chiamata al metodo di creazione restituisce o meno un errore. Così

err := GetDB().Create(user).Error
if err != nil {
    // code to handle error
}

Quindi il pacchetto pq ha un tipo speciale che mappa l'errore del server postgres. Contiene campi che possono aiutarti a identificare la gravità dell'errore, il suo codice, la tabella relativa all'errore, ecc.

L'elenco completo degli identificatori dei campi psql può essere trovato qui in

Campi dei messaggi di errore e avviso

https://www.postgresql.org/docs/current/protocol-error-fields.html

Per risolvere il tuo problema come opzione possiamo utilizzare field

Code

Che è una rappresentazione di tipo stringa del codice di errore. Ma in primo luogo, dobbiamo lanciare un errore e controllare che il cast del tipo abbia avuto successo. Così

err := GetDB().Create(user).Error
if err != nil {
    pqErr, ok := err.(pq.Error)
    if !ok {
        log.Fatal(err)
    }

    // code to handle specific error code
}

L'elenco dei codici di errore può essere trovato sia nella documentazione ufficiale di postgresql https://www.postgresql.org/docs/9.3/errcodes-appendix.html

E le mappature specifiche go pq effettive all'errore in github.com/lib/pq/error.go come per la libreria pq

E finalmente possiamo gestire l'errore come duplicato dal codice

err := GetDB().Create(user).Error
if err != nil {
    pqErr, ok := err.(pq.Error)
    if !ok {
        log.Fatal(err)
    }

    // note that type casting here is redundant and used for showing specific 
    // string type from pq library
    if pqErr.Code == pq.ErrorCode("23505") { // 23505 is unique_violation error code for psql
        // now you can create error and write it to a message to return it for 
        // a client
    }
}

Answer 2

Secondo i commenti, gorm fornisce l'accesso agli errori del database dalla funzione Crea record come segue:

result := GetDB().Create(user)
if result.Error != nil {
   // Do something with the error
}

Tieni presente che è probabile che il controllo della stringa di errore renda specifico il database dell'applicazione (ma questo potrebbe non essere un problema per te). Le risposte a questa domanda possono fornire ulteriore assistenza.