pretty messages

server/db.go

@@ -9,6 +9,17 @@ import (
 	_ "github.com/lib/pq"
 )
 
+const (
+	errDBRegisterSite       = "Error: db.go (sites): Register site"
+	errDBUpdateDue          = "Error: db.go (sites): Update due date"
+	errDBRegisterPayment    = "Error: db.go (payments): Register payment"
+	errDBTXBeginUpdateSite  = "Error: db.go: Begin transaction"
+	errDBTXCommitUpdateSite = "Error: db.go: Commit transaction"
+	errDBGetPrevRaw         = "Error: db.go (sites): Query old raw json"
+	errDBUpdateRaw          = "Error: db.go (sites): Update raw json"
+	errDBChangesRaw         = "Error: db.go (changes): Register raw json change"
+)
+
 func RegisterSitePayment(capture Capture, directory string, editorData json.RawMessage) error {
 	var (
 		// Payment
@@ -51,7 +62,7 @@ func RegisterSitePayment(capture Capture, directory string, editorData json.RawM
 			directory, wstatus, due,
 			name, surname, email, phone, country,
 			editorData).Scan(&pkey); err != nil {
-			return fmt.Errorf("Error: Could not register site to database: %v", err)
+			return fmt.Errorf("%s: %v", errDBRegisterSite, err)
 		}
 	} else {
 		if err := db.QueryRow(
@@ -59,7 +70,7 @@ func RegisterSitePayment(capture Capture, directory string, editorData json.RawM
 			WHERE id = $1
 			RETURNING id`,
 			pkey).Scan(&pkey); err != nil {
-			return fmt.Errorf("Error: Could not update due date: %v", err)
+			return fmt.Errorf("%s: %v", errDBUpdateDue, err)
 		}
 	}
 
@@ -67,7 +78,7 @@ func RegisterSitePayment(capture Capture, directory string, editorData json.RawM
 		`INSERT INTO payments (capture, site, amount, currency, date, status)
 		VALUES ($1, $2, $3, $4, $5, $6)`,
 		id, pkey, amount, currency, date, pstatus); err != nil {
-		return fmt.Errorf("Error: Could not register payment to database: %v", err)
+		return fmt.Errorf("%s: %v", errDBRegisterPayment, err)
 	}
 
 	return nil
@@ -76,7 +87,7 @@ func RegisterSitePayment(capture Capture, directory string, editorData json.RawM
 func UpdateSite(by string, pkey int, editorData json.RawMessage) error {
 	tx, err := db.Begin()
 	if err != nil {
-		return fmt.Errorf("Error: Could not start transaction: %v", err)
+		return fmt.Errorf("%s: %v", errDBTXBeginUpdateSite, err)
 	}
 
 	defer func() {
@@ -89,24 +100,24 @@ func UpdateSite(by string, pkey int, editorData json.RawMessage) error {
 	if err := tx.QueryRow(
 		`SELECT raw FROM sites WHERE id = $1`,
 		pkey).Scan(&prev); err != nil {
-		return fmt.Errorf("Error: Could not retrieve old value: %v", err)
+		return fmt.Errorf("%s: %v", errDBGetPrevRaw, err)
 	}
 
 	if _, err = tx.Exec(
 		`UPDATE sites SET raw = $1 WHERE id = $2`,
 		editorData, pkey); err != nil {
-		return fmt.Errorf("Error: Could not update raw column: %v", err)
+		return fmt.Errorf("%s: %v", errDBUpdateRaw, err)
 	}
 
 	if _, err = tx.Exec(
 		`INSERT INTO changes (by, site, payment, col, prev, next, date)
 		VALUES ($1, $2, NULL, 'raw', $3, $4, CURRENT_DATE);`,
 		by, pkey, prev, editorData); err != nil {
-		return fmt.Errorf("Error: Could not register change to database: %v", err)
+		return fmt.Errorf("%s: %v", errDBChangesRaw, err)
 	}
 
 	if err := tx.Commit(); err != nil {
-		return fmt.Errorf("Error: Could not commit transaction: %v", err)
+		return fmt.Errorf("%s: %v", errDBTXCommitUpdateSite, err)
 	}
 
 	return nil

server/init.go

@@ -9,6 +9,14 @@ import (
 	_ "github.com/lib/pq"
 )
 
+const (
+	msgClosingDBConn = "Msg: init.go: Closing database connection"
+	msgDBConn        = "Msg: init.go: Established database connection"
+	errDBConn        = "Fatal: init.go: Connect to database"
+	errDBPing        = "Fatal: init.go: Ping database"
+	errClosingDBConn = "Fatal: init.go: Closing database connection"
+)
+
 var db *sql.DB
 
 func initialize() {
@@ -30,20 +38,21 @@ func initialize() {
 		" password="+os.Getenv("DB_PASS")+
 		" dbname="+os.Getenv("DB_NAME"))
 	if err != nil {
-		log.Fatalf("Error 001: Can't connect to database: %v", err)
+		log.Fatalf("%s: %v", errDBConn, err)
 	}
 
 	if err := db.Ping(); err != nil {
-		log.Fatalf("Error 001: Can't connect to database: %v", err)
+		log.Fatalf("%s: %v", errDBPing, err)
 	}
 
-	log.Println("Established database connection")
+	log.Println(msgDBConn)
 }
 
 func shutdown() {
 	if db != nil {
+		log.Println(msgClosingDBConn)
 		if err := db.Close(); err != nil {
-			log.Fatalf("Error: Can't close database connection: %v", err)
+			log.Fatalf("%s: %v", errClosingDBConn, err)
 		}
 	}
 }

server/main.go

@@ -11,6 +11,19 @@ import (
 	"syscall"
 )
 
+const (
+	msgServerStart    = "Msg: main.go: Starting server"
+	msgServerShutdown = "Msg: main.go: Server shutdown gracefully"
+	errServerStart    = "Fatal: main.go: Start server"
+	errReadBody       = "Error: main.go: Read request body"
+	errParseBody      = "Error: main.go: Parse request body"
+	errGetOrderID     = "Error: main.go: Get orderID from client URL"
+	errCaptureOrder   = "Error: main.go: Capture order"
+	errRegisterSite   = "Error: main.go: Register site in database"
+	errEncodeResponse = "Error: main.go: Encode response"
+	errCreateOrder    = "Error: main.go: Obtain orderID"
+)
+
 func main() {
 	initialize()
 
@@ -23,16 +36,16 @@ func main() {
 	port := os.Getenv("PORT")
 
 	go func() {
-		log.Println("Starting server on " + port + "...")
+		log.Println(msgServerStart + ": " + port + "...")
 		if err := http.ListenAndServe(":"+port, nil); err != nil {
-			log.Fatalf("Error: 002: Can't start server: %v\n", err)
+			fatal(err, errServerStart)
 		}
 	}()
 
 	<-stop
 
 	shutdown()
-	log.Println("Server shutdown gracefully.")
+	log.Println(msgServerShutdown)
 }
 
 func fail(w http.ResponseWriter, err error, notice string) {
@@ -40,10 +53,15 @@ func fail(w http.ResponseWriter, err error, notice string) {
 	http.Error(w, notice, http.StatusInternalServerError)
 }
 
+func fatal(err error, notice string) {
+	shutdown()
+	log.Fatalf("%s: %v", notice, err)
+}
+
 func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
 	orderID, err := CreateOrder()
 	if err != nil {
-		fail(w, err, "Failed to obtain orderID")
+		fail(w, err, errCreateOrder)
 		return
 	}
 
@@ -60,7 +78,7 @@ func CreateOrderHandler(w http.ResponseWriter, r *http.Request) {
 func CaptureOrderHandler(w http.ResponseWriter, r *http.Request) {
 	info, err := io.ReadAll(r.Body)
 	if err != nil {
-		fail(w, err, "Failed to read request body")
+		fail(w, err, errReadBody)
 		return
 	}
 	var cart struct {
@@ -69,7 +87,7 @@ func CaptureOrderHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	err = json.Unmarshal(info, &cart)
 	if err != nil {
-		fail(w, err, "Failed to parse request body")
+		fail(w, err, errParseBody)
 		return
 	}
 	directory := cart.Directory
@@ -79,24 +97,24 @@ func CaptureOrderHandler(w http.ResponseWriter, r *http.Request) {
 	parts := strings.Split(path, "/")
 	orderID := parts[0]
 	if orderID == "" {
-		fail(w, err, "Failed to get orderID from client URL")
+		fail(w, err, errGetOrderID)
 		return
 	}
 
 	capture, receipt, err := CaptureOrder(orderID)
 	if err != nil {
-		fail(w, err, "Failed to capture order")
+		fail(w, err, errCaptureOrder)
 		return
 	}
 
 	if err := RegisterSitePayment(capture, directory, editorData); err != nil {
-		fail(w, err, "Failed to register '"+directory+"'in database")
+		fail(w, err, errRegisterSite+": "+directory)
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/json")
 	if err := json.NewEncoder(w).Encode(receipt); err != nil {
-		fail(w, err, "Failed to encode response")
+		fail(w, err, errEncodeResponse)
 		return
 	}
 

server/paypal.go

@@ -11,6 +11,19 @@ import (
 	"time"
 )
 
+const (
+	errTokenReq                  = "Error: paypal.go: Send token request"
+	errTokenResp                 = "Error: paypal.go: Decode token response"
+	errToken                     = "Error: paypal.go: Get access token"
+	errCreateOrderReq            = "Error: paypal.go: Send CreateOrder request"
+	errCreateOrderResp           = "Error: paypal.go: Decode CreateOrder response"
+	errCaptureOrderToken         = "Error: paypal.go: Get access token for CaptureOrder"
+	errCaptureOrderReq           = "Error: paypal.go: Send CaptureOrder request"
+	errCaptureOrderResp          = "Error: paypal.go: Decode CaptureOrder response"
+	errCaptureOrderDecodeCapture = "Error: paypal.go: Decode CaptureOrder capture"
+	errCaptureOrderDecodeReceipt = "Error: paypal.go: Decode CaptureOrder receipt"
+)
+
 type Capture struct {
 	ID            string `json:"id"`
 	Status        string `json:"status"`
@@ -65,7 +78,7 @@ func Token() (string, error) {
 
 	raw, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("Error sending request: %v", err)
+		return "", fmt.Errorf("%s: %v", errTokenReq, err)
 	}
 	defer raw.Body.Close()
 
@@ -74,7 +87,7 @@ func Token() (string, error) {
 	}
 
 	if err := json.NewDecoder(raw.Body).Decode(&response); err != nil {
-		return "", fmt.Errorf("Error decoding response: %v", err)
+		return "", fmt.Errorf("%s: %v", errTokenResp, err)
 	}
 
 	return response.AccessToken, nil
@@ -83,7 +96,7 @@ func Token() (string, error) {
 func CreateOrder() (string, error) {
 	token, err := Token()
 	if err != nil {
-		return "", fmt.Errorf("Failed to get acess token: %v", err)
+		return "", fmt.Errorf("%s: %v", errToken, err)
 	}
 
 	type Amount struct {
@@ -137,7 +150,7 @@ func CreateOrder() (string, error) {
 
 	raw, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("Failed to send request: %v", err)
+		return "", fmt.Errorf("%s: %v", errCreateOrderReq, err)
 	}
 	defer raw.Body.Close()
 
@@ -146,7 +159,7 @@ func CreateOrder() (string, error) {
 	}
 
 	if err := json.NewDecoder(raw.Body).Decode(&response); err != nil {
-		return "", fmt.Errorf("Failed to decode response: %v", err)
+		return "", fmt.Errorf("%s: %v", errCreateOrderResp, err)
 	}
 
 	return response.ID, nil
@@ -155,7 +168,7 @@ func CreateOrder() (string, error) {
 func CaptureOrder(orderID string) (Capture, Receipt, error) {
 	token, err := Token()
 	if err != nil {
-		return Capture{}, Receipt{}, fmt.Errorf("Failed to get acess token: %v", err)
+		return Capture{}, Receipt{}, fmt.Errorf("%s: %v", errCaptureOrderToken, err)
 	}
 
 	req, err := http.NewRequest("POST",
@@ -166,7 +179,7 @@ func CaptureOrder(orderID string) (Capture, Receipt, error) {
 
 	raw, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return Capture{}, Receipt{}, fmt.Errorf("Failed to send request: %v", err)
+		return Capture{}, Receipt{}, fmt.Errorf("%s: %v", errCaptureOrderReq, err)
 	}
 	defer raw.Body.Close()
 
@@ -175,15 +188,15 @@ func CaptureOrder(orderID string) (Capture, Receipt, error) {
 
 	body, err := io.ReadAll(raw.Body)
 	if err != nil {
-		return Capture{}, Receipt{}, fmt.Errorf("Failed to read response body: %v", err)
+		return Capture{}, Receipt{}, fmt.Errorf("%s: %v", errCaptureOrderResp, err)
 	}
 
 	if err := json.NewDecoder(bytes.NewReader(body)).Decode(&capture); err != nil {
-		return Capture{}, Receipt{}, fmt.Errorf("Failed to decode into capture: %v", err)
+		return Capture{}, Receipt{}, fmt.Errorf("%s: %v", errCaptureOrderDecodeCapture, err)
 	}
 
 	if err := json.NewDecoder(bytes.NewReader(body)).Decode(&receipt); err != nil {
-		return Capture{}, Receipt{}, fmt.Errorf("Failed to decode into capture: %v", err)
+		return Capture{}, Receipt{}, fmt.Errorf("%s: %v", errCaptureOrderDecodeReceipt, err)
 	}
 
 	return capture, receipt, nil