Edward's Tech Site

import { useEffect, useState } from "react";
 
const url = "http://localhost:7788/languages";
 
export const PageWelcome = () => {
    const [languages, setLanguages] = useState<string[]>([]);
 
    useEffect(() => {
        (async () => {
            const response = await fetch(url);
            const _languages: string[] = await response.json();
            setLanguages(_languages);
        })();
    }, []);
 
    return (
        <>
            <p>There are there {languages.length} languages.</p>
        </>
    );
};

package main
 
import (
    "fmt"
    "net/http"
)
 
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World!")
    })
    fmt.Println("Listening on :8080")
    http.ListenAndServe(":8080", nil)
}

server {
        server_name showcase-go-api.tanguay.eu;
        location / {
                proxy_pass http://localhost:7788;
        }
}

{
"name": "showcase-go-api",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
    "start": "go run main.go",
    "setup": "pm2 start --name showcase-go-api npm -- start && pm2 save",
    "deploy": "git pull --no-rebase && pm2 restart showcase-go-api --update-env --time && pm2 save"
},
"keywords": [],
"author": "",
"license": "ISC"
}

TEST = 12345

test := os.Getenv("TEST")
fmt.Printf("Test is: [%v]\n", test)

go get github.com/joho/godotenv
go: go.mod file not found in current directory or any parent directory.
'go get' is no longer supported outside a module.
To build and install a command, use 'go install' with a version,
like 'go install example.com/cmd@latest'
For more information, see https://golang.org/doc/go-get-install-deprecation
or run 'go help get' or 'go help install'.

func getHowtos() {
 
    // Open the database
    db, err := sql.Open("sqlite3", "./data/main.sqlite")
    if err != nil {
        fmt.Println("Error opening database:", err)
        return
    }
    defer db.Close()
 
    // Query the database
    rows, err := db.Query("SELECT id, category, title FROM howtos")
    if err != nil {
        fmt.Println("Error querying database:", err)
        return
    }
    defer rows.Close()
 
    // Iterate over the rows
    for rows.Next() {
        var id int
        var category string
        var title string
        err = rows.Scan(&id, &category, &title)
        if err != nil {
            fmt.Println("Error scanning row:", err)
            return
        }
        fmt.Printf("id: %d, category: %s, title: %s\n", id, category, title)
    }
 
    // Check for errors from iterating over rows
    err = rows.Err()
    if err != nil {
        fmt.Println("Error iterating over rows:", err)
        return
    }
}

MONGO_DATABASE = template-api-read-write-mongo
MONGO_COLLECTION = todos

go get go.mongodb.org/mongo-driver/mongo
go get go.mongodb.org/mongo-driver/mongo/options

func getTodosWithMongo() {
    err := godotenv.Load()
    if err != nil {
        fmt.Println("Error loading .env file")
        return
    }
    mongo_conn := os.Getenv("MONGO_CONNECTION")
    mongo_database := os.Getenv("MONGO_DATABASE")
    mongo_collection := os.Getenv("MONGO_COLLECTION")
 
    clientOptions := options.Client().ApplyURI(mongo_conn)
 
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }
 
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Println("Connected to MongoDB!")
 
    collection := client.Database(mongo_database).Collection(mongo_collection)
 
    filter := bson.D{}
 
    var results []bson.M
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        log.Fatal(err)
    }
    if err = cursor.All(ctx, &results); err != nil {
        log.Fatal(err)
    }
 
    for _, result := range results {
        fmt.Printf("Found document: %v\n", result)
    }
 
    err = client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
}

type Skill struct {
    IDCode string
    Name  string
}
 
func getSkillsFromMongo() []Skill {
    err := godotenv.Load()
    if err != nil {
        fmt.Println("Error loading .env file")
    }
    mongo_conn := os.Getenv("MONGO_CONNECTION")
    mongo_database := os.Getenv("MONGO_DATABASE")
    mongo_collection := os.Getenv("MONGO_COLLECTION")
 
    clientOptions := options.Client().ApplyURI(mongo_conn)
 
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }
 
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Println("Connected to MongoDB!")
 
    collection := client.Database(mongo_database).Collection(mongo_collection)
 
    filter := bson.D{}
 
    var results []bson.M
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        log.Fatal(err)
    }
    if err = cursor.All(ctx, &results); err != nil {
        log.Fatal(err)
    }
 
    err = client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
 
    var skills []Skill
    for _, result := range results {
        var idCode, name string
        if result["idCode"] != nil {
            idCode = result["idCode"].(string)
        }
        if result["name"] != nil {
            name = result["name"].(string)
        }
        skill := Skill{
            IDCode: idCode,
            Name:  name,
        }
        skills = append(skills, skill)
    }
 
    return skills
 
}
 
http.HandleFunc("/skills", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(getSkillsFromMongo())
})