tavo/conex-builder
1
0
Fork 0
mirror of https://github.com/tavo-wasd-gh/conex-builder.git synced 2025-06-06 11:43:29 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

pretty messages

Browse source
This commit is contained in:
tavo-wasd 2024-09-01 23:42:51 -06:00
parent eec6e358db
commit 8d615ae418
4 changed files with 83 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
server/db.go
View file

@ -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

17
server/init.go
View file

@ -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)
}
}
}

38
server/main.go
View file

@ -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
}

33
server/paypal.go
View file

@ -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