diff --git a/.env.example b/.env.example index e69de29..004d991 100644 --- a/.env.example +++ b/.env.example @@ -0,0 +1,4 @@ +DB_USER="" +DB_PASS="" +DB_HOST="" +DB_NAME="" \ No newline at end of file diff --git a/.gitignore b/.gitignore index 2eea525..24e8192 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ -.env \ No newline at end of file +.env +/vendor \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..bd6312b --- /dev/null +++ b/Dockerfile @@ -0,0 +1,6 @@ +FROM golang:1.21 +WORKDIR /app +COPY . . +RUN go mod tidy && go build -o main . +EXPOSE 3000 +CMD ["./main"] \ No newline at end of file diff --git a/api_serveurless_go b/api_serveurless_go new file mode 100644 index 0000000..a6d1e37 Binary files /dev/null and b/api_serveurless_go differ diff --git a/bd/bd.go b/bd/bd.go index 7090e86..c2fcceb 100644 --- a/bd/bd.go +++ b/bd/bd.go @@ -1,38 +1,37 @@ -package bd - -import ( - "database/sql" - "log" - "os" - - "github.com/go-sql-driver/mysql" - "github.com/joho/godotenv" -) - -var db *sql.DB - -func GetDB() *sql.DB { - - if db == nil { - errenv := godotenv.Load() - if errenv != nil { - log.Fatal("Error loading .env file") - } - // Capture connection properties. - cfg := mysql.NewConfig() - cfg.User = os.Getenv("DB_USER") - cfg.Passwd = os.Getenv("DB_PASS") - cfg.Net = "tcp" - cfg.Addr = os.Getenv("DB_HOST") - cfg.DBName = os.Getenv("DB_NAME") - - // Get a database handle. - var err error - db, err = sql.Open("mysql", cfg.FormatDSN()) - if err != nil { - log.Fatal(err) - } - - } - return db -} +package bd + +import ( + "database/sql" + "log" + "os" + "github.com/go-sql-driver/mysql" + "github.com/joho/godotenv" +) + +var db *sql.DB + +func GetDB() *sql.DB { + + if db == nil { + errenv := godotenv.Load() + if errenv != nil { + log.Println("No .env file found; using environment variables") + } + // Capture connection properties. + cfg := mysql.NewConfig() + cfg.User = os.Getenv("DB_USER") + cfg.Passwd = os.Getenv("DB_PASS") + cfg.Net = "tcp" + cfg.Addr = os.Getenv("DB_HOST") + cfg.DBName = os.Getenv("DB_NAME") + + // Get a database handle. + var err error + db, err = sql.Open("mysql", cfg.FormatDSN()) + if err != nil { + log.Fatal(err) + } + + } + return db +} diff --git a/create_table.sql b/create_table.sql new file mode 100644 index 0000000..82d367e --- /dev/null +++ b/create_table.sql @@ -0,0 +1,49 @@ +DROP TABLE IF EXISTS projet; + +DROP TABLE IF EXISTS technologie; + +DROP TABLE IF EXISTS projet_technologie; + +create table + projet ( + id int primary key auto_increment, + name varchar(255) not null, + shortdescriptionfr text not null, + longdescriptionfr text not null, + shortdescriptionen text not null, + longdescriptionen text not null, + linkGithub varchar(255), + linkWeb varchar(255), + datec date not null + ); + +create table + technologie ( + id int primary key auto_increment, + name varchar(255) not null + ); + +create table + projet_technologie ( + projet_id int, + technologie_id int, + primary key (projet_id, technologie_id), + foreign key (projet_id) references projet (id) on delete cascade, + foreign key (technologie_id) references technologie (id) on delete cascade + ); + +insert into projet (name, shortdescriptionfr, longdescriptionfr, shortdescriptionen, longdescriptionen, linkGithub, linkWeb, datec) values +('Mon Portefolio', 'Un site web pour présenter mes projets et compétences.', 'Ce site web a été développé pour présenter mes projets personnels et professionnels, ainsi que mes compétences en développement web. Il utilise Go pour le backend et React pour le frontend.', 'A website to showcase my projects and skills.', 'This website was developed to showcase my personal and professional projects, as well as my web development skills. It uses Go for the backend and React for the frontend.', 'https://github.com/sylvain/portfolio', 'https://sylvain-portfolio.com', '2023-01-15'); +insert into technologie (name) values +('Go'), +('React'), +('JavaScript'), +('HTML'), +('CSS'); + +insert into projet_technologie (projet_id, technologie_id) values +(1, 1), +(1, 2), +(1, 3), +(1, 4), +(1, 5); diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 0000000..ba4a623 --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,30 @@ +services: + app: + build: + context: . + dockerfile: Dockerfile + ports: + - "3000:3000" + env_file: + - .env + depends_on: + - db + command: ["sh", "-c", "sleep 6 && ./main"] + restart: unless-stopped + + db: + image: mysql:8.0 + environment: + MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD} + MYSQL_DATABASE: ${MYSQL_DATABASE} + MYSQL_USER: ${MYSQL_USER} + MYSQL_PASSWORD: ${MYSQL_PASSWORD} + volumes: + - db_data:/var/lib/mysql + - ./create_table.sql:/docker-entrypoint-initdb.d/create_table.sql:ro + ports: + - "3306:3306" + restart: unless-stopped + +volumes: + db_data: \ No newline at end of file diff --git a/go.mod b/go.mod index ff34078..4553c24 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module api_serveurless_go -go 1.25.1 +go 1.21.0 require ( github.com/go-sql-driver/mysql v1.9.3 diff --git a/main.go b/main.go index 1287542..741728e 100644 --- a/main.go +++ b/main.go @@ -1,14 +1,14 @@ -package main - -import ( - "api_serveurless_go/routes" - "net/http" -) - -func main() { - // Configuration des routes - routes.SetupRoutes() - - // Démarrage du serveur - http.ListenAndServe(":3000", nil) -} +package main + +import ( + "api_serveurless_go/routes" + "net/http" +) + +func main() { + // Configuration des routes + routes.SetupRoutes() + + // Démarrage du serveur + http.ListenAndServe(":3000", nil) +} diff --git a/requette/projet.go b/requette/projet.go index 1b81cfe..6cce1cc 100644 --- a/requette/projet.go +++ b/requette/projet.go @@ -1,62 +1,132 @@ -package requette - -import ( - "api_serveurless_go/bd" - "database/sql" - "log" -) - -type Projet struct { - Id int `json:"id"` - Name string `json:"name"` - ShortDescription string `json:"shortdescription"` -} - -func GetAllProjets() []Projet { - db := bd.GetDB() - stmt, err := db.Prepare("SELECT * FROM projet") - if err != nil { - log.Fatal(err) - } - row, err := stmt.Query() - defer stmt.Close() - if err != nil { - log.Fatal(err) - } - - return hydrateProjets(row) - -} - -func GetProjetByID(id int) Projet { - db := bd.GetDB() - stmt, err := db.Prepare("SELECT * FROM projet WHERE id = ?") - if err != nil { - log.Fatal(err) - } - row := stmt.QueryRow(id) - defer stmt.Close() - return hydrateProjet(row) -} - -func hydrateProjet(row *sql.Row) Projet { - var projet Projet - err := row.Scan(&projet.Id, &projet.Name, &projet.ShortDescription) - if err != nil { - log.Fatal(err) - } - return projet -} - -func hydrateProjets(rows *sql.Rows) []Projet { - var projets []Projet - for rows.Next() { - var projet Projet - err := rows.Scan(&projet.Id, &projet.Name, &projet.ShortDescription) - if err != nil { - log.Fatal(err) - } - projets = append(projets, projet) - } - return projets -} +package requette + +import ( + "api_serveurless_go/bd" + "api_serveurless_go/types" + "database/sql" + "log" + "strings" +) + +func GetAllProjets(nb int,page int) types.Projets { + db := bd.GetDB() + offset := (page - 1) * nb + stmt, err := db.Prepare("SELECT projet.id, projet.name, projet.shortdescriptionfr, GROUP_CONCAT(technologie.name SEPARATOR ',') as technologies FROM projet LEFT JOIN projet_technologie on projet.id = projet_technologie.projet_id LEFT JOIN technologie on projet_technologie.technologie_id = technologie.id GROUP BY projet.id, projet.name, projet.shortdescriptionfr LIMIT ? OFFSET ?") + if err != nil { + log.Fatal(err) + } + row, err := stmt.Query(nb, offset) + defer stmt.Close() + if err != nil { + log.Fatal(err) + } + + stmt2, err := db.Prepare("SELECT count(*) FROM projet") + if err != nil { + log.Fatal(err) + } + row2, err := stmt2.Query() + defer stmt2.Close() + if err != nil { + log.Fatal(err) + } + var count int + for row2.Next() { + err := row2.Scan(&count) + if err != nil { + log.Fatal(err) + } + } + + var projets types.Projets + projets.Projets = hydrateProjets(row) + projets.Count = count + + return projets + +} + +func GetProjetByID(id int) types.ProjetFull { + db := bd.GetDB() + stmt, err := db.Prepare("SELECT id, name, shortdescriptionfr, longdescriptionfr, shortdescriptionen, longdescriptionen, linkGithub, linkWeb FROM projet WHERE id = ?") + if err != nil { + log.Fatal(err) + } + row := stmt.QueryRow(id) + defer stmt.Close() + return hydrateProjet(row) +} + +func hydrateProjet(row *sql.Row) types.ProjetFull { + var projet types.ProjetFull + err := row.Scan(&projet.Id, &projet.Name, &projet.ShortDescriptionFr, &projet.LongDescriptionFr, &projet.ShortDescriptionEn, &projet.LongDescriptionEn, &projet.LinkGithub, &projet.LinkWeb) + if err != nil { + log.Fatal(err) + } + return projet +} + +func hydrateProjets(rows *sql.Rows) []types.ProjetShort { + var projets []types.ProjetShort + for rows.Next() { + var projet types.ProjetShort + var techs sql.NullString + err := rows.Scan(&projet.Id, &projet.Name, &projet.ShortDescriptionFr, &techs) + if err != nil { + log.Fatal(err) + } + if techs.Valid && techs.String != "" { + projet.Technologies = strings.Split(techs.String, ",") + } else { + projet.Technologies = []string{} + } + projets = append(projets, projet) + } + return projets +} + +func CreateProjet(projet types.Projetcreate) *types.Projetcreate { + db := bd.GetDB() + stmt, err := db.Prepare("INSERT INTO projet (name, shortdescriptionfr, longdescriptionfr, shortdescriptionen, longdescriptionen, linkGithub, linkWeb, datec) VALUES (?, ?, '', '', '', '', '', CURDATE())") + if err != nil { + log.Fatal(err) + } + _, err = stmt.Exec(projet.Name, projet.ShortDescription) + if err != nil { + log.Fatal(err) + return nil + } + defer stmt.Close() + return &projet +} + +func UpdateProjet(projet types.ProjetFull) *types.ProjetFull { + db := bd.GetDB() + stmt, err := db.Prepare("UPDATE projet SET name = ?, shortdescriptionfr = ?, longdescriptionfr = ?, shortdescriptionen = ?, longdescriptionen = ?, linkGithub = ?, linkWeb = ? WHERE id = ?") + if err != nil { + log.Fatal(err) + } + _, err = stmt.Exec(projet.Name, projet.ShortDescriptionFr, projet.LongDescriptionFr, projet.ShortDescriptionEn, projet.LongDescriptionEn, projet.LinkGithub, projet.LinkWeb, projet.Id) + if err != nil { + log.Fatal(err) + return nil + } + defer stmt.Close() + return &projet +} + +func DeleteProjet(id int) bool { + db := bd.GetDB() + stmt, err := db.Prepare("DELETE FROM projet WHERE id = ?") + if err != nil { + log.Fatal(err) + return false + } + _, err = stmt.Exec(id) + if err != nil { + log.Fatal(err) + return false + } + defer stmt.Close() + return true +} diff --git a/requette/technologie.go b/requette/technologie.go new file mode 100644 index 0000000..fb049e2 --- /dev/null +++ b/requette/technologie.go @@ -0,0 +1,107 @@ +package requette + +import ( + "api_serveurless_go/bd" + "api_serveurless_go/types" + "database/sql" + "log" +) + +func GetAllTechnologies() types.Technologies { + db := bd.GetDB() + + stmt, err := db.Prepare("SELECT * FROM technologie") + if err != nil { + log.Fatal(err) + } + row, err := stmt.Query() + defer stmt.Close() + if err != nil { + log.Fatal(err) + } + + stmt2, err := db.Prepare("SELECT count(*) FROM technologie") + if err != nil { + log.Fatal(err) + } + row2, err := stmt2.Query() + defer stmt2.Close() + if err != nil { + log.Fatal(err) + } + var count int + for row2.Next() { + err := row2.Scan(&count) + if err != nil { + log.Fatal(err) + } + } + + var technologies types.Technologies + technologies.Technologies = hydrateTechnologies(row) + technologies.Count = count + + return technologies + +} + + +func hydrateTechnologies(rows *sql.Rows) []types.TechnologieShort { + var technologies []types.TechnologieShort + for rows.Next() { + var technologie types.TechnologieShort + err := rows.Scan(&technologie.Id, &technologie.Name) + if err != nil { + log.Fatal(err) + } + + technologies = append(technologies, technologie) + } + return technologies +} + +func CreateTechnologie(projet types.TechnologieCreate) *types.TechnologieCreate { + db := bd.GetDB() + stmt, err := db.Prepare("INSERT INTO technologie (name) VALUES (?)") + if err != nil { + log.Fatal(err) + } + _, err = stmt.Exec(projet.Name) + if err != nil { + log.Fatal(err) + return nil + } + defer stmt.Close() + return &projet +} + +func UpdateTechnologie(technologie types.TechnologieFull) *types.TechnologieFull { + db := bd.GetDB() + stmt, err := db.Prepare("UPDATE technologie SET name = ? WHERE id = ?") + if err != nil { + log.Fatal(err) + } + _, err = stmt.Exec(technologie.Name, technologie.Id) + if err != nil { + log.Fatal(err) + return nil + } + defer stmt.Close() + return &technologie +} + +func DeleteTechnologie(id int) bool { + db := bd.GetDB() + stmt, err := db.Prepare("DELETE FROM technologie WHERE id = ?") + if err != nil { + log.Fatal(err) + return false + } + _, err = stmt.Exec(id) + if err != nil { + log.Fatal(err) + return false + } + defer stmt.Close() + return true +} diff --git a/routes/projet.go b/routes/projet.go index 9dc8b2f..1d7c335 100644 --- a/routes/projet.go +++ b/routes/projet.go @@ -1,62 +1,122 @@ -package routes - -import ( - "api_serveurless_go/requette" - "encoding/json" - "fmt" - "net/http" - "strconv" - "strings" -) - -// SetupRoutes configure toutes les routes de l'application -func SetupRoutes() { - http.HandleFunc("/", homeHandler) - http.HandleFunc("/api/projets", projetsHandler) - http.HandleFunc("/api/projet/", projetHandler) -} - -// homeHandler gère la route racine -func homeHandler(w http.ResponseWriter, r *http.Request) { - fmt.Fprintf(w, "Welcome to my website!") -} - -// projetsHandler gère la liste des projets -func projetsHandler(w http.ResponseWriter, r *http.Request) { - switch r.Method { - case "GET": - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - json.NewEncoder(w).Encode(requette.GetAllProjets()) - case "POST": - fmt.Fprintf(w, "Créer un nouveau projet") - default: - http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed) - } -} - -// projetHandler gère les actions sur un projet spécifique -func projetHandler(w http.ResponseWriter, r *http.Request) { - id := strings.TrimPrefix(r.URL.Path, "/api/projet/") - if id == "" { - http.Error(w, "ID manquant", http.StatusBadRequest) - return - } - idInt, err := strconv.Atoi(id) - if err != nil { - http.Error(w, "ID invalide", http.StatusBadRequest) - return - } - switch r.Method { - case "GET": - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusOK) - json.NewEncoder(w).Encode(requette.GetProjetByID(idInt)) - case "PUT": - fmt.Fprintf(w, "Modifier le projet %d", idInt) - case "DELETE": - fmt.Fprintf(w, "Supprimer le projet %d", idInt) - default: - http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed) - } -} +package routes + +import ( + "api_serveurless_go/requette" + "api_serveurless_go/types" + "encoding/json" + "fmt" + "net/http" + "os" + "strconv" + "strings" +) + + + + + +// projetsHandler gère la liste des projets +func projetsHandler(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", os.Getenv("FRONTEND_URL")) + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "Content-Type") + switch r.Method { + case "GET": + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + pageStr := r.URL.Query().Get("page") + nbStr := r.URL.Query().Get("nb") + + // defaults + page := 1 + nb := 10 + + if pageStr != "" { + p, err := strconv.Atoi(pageStr) + if err != nil { + http.Error(w, "Paramètre 'page' invalide", http.StatusBadRequest) + return + } + page = p + } + + if nbStr != "" { + n, err := strconv.Atoi(nbStr) + if err != nil { + http.Error(w, "Paramètre 'nb' invalide", http.StatusBadRequest) + return + } + nb = n + } + + json.NewEncoder(w).Encode(requette.GetAllProjets(nb, page)) + case "POST": + + var projet types.Projetcreate + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + err := decoder.Decode(&projet) + if err != nil { + http.Error(w, "Erreur de décodage JSON: "+err.Error(), http.StatusBadRequest) + return + } + fmt.Println(projet.Name, projet.ShortDescription) + if requette.CreateProjet(projet) == nil { + http.Error(w, "Erreur lors de la création du projet", http.StatusInternalServerError) + } else { + w.WriteHeader(http.StatusCreated) + } + case "OPTIONS": + w.WriteHeader(http.StatusOK) + return + + default: + http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed) + } +} + +// projetHandler gère les actions sur un projet spécifique +func projetHandler(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", os.Getenv("FRONTEND_URL")) + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "Content-Type") + id := strings.TrimPrefix(r.URL.Path, "/api/projet/") + if id == "" { + http.Error(w, "ID manquant", http.StatusBadRequest) + return + } + idInt, err := strconv.Atoi(id) + if err != nil { + http.Error(w, "ID invalide", http.StatusBadRequest) + return + } + switch r.Method { + case "GET": + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(requette.GetProjetByID(idInt)) + case "PUT": + var projet types.ProjetFull + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + err := decoder.Decode(&projet) + if err != nil { + http.Error(w, "Erreur de décodage JSON: "+err.Error(), http.StatusBadRequest) + return + } + fmt.Println(projet.Name, projet.ShortDescriptionFr) + if requette.UpdateProjet(projet) == nil { + http.Error(w, "Erreur lors de la mise à jour du projet", http.StatusInternalServerError) + } else { + w.WriteHeader(http.StatusOK) + } + case "DELETE": + if requette.DeleteProjet(idInt) { + w.WriteHeader(http.StatusNoContent) + } else { + http.Error(w, "Erreur lors de la suppression du projet", http.StatusInternalServerError) + } + default: + http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed) + } +} diff --git a/routes/route.go b/routes/route.go new file mode 100644 index 0000000..e82740c --- /dev/null +++ b/routes/route.go @@ -0,0 +1,11 @@ +package routes + +import ( + "net/http" +) + +func SetupRoutes() { + http.HandleFunc("/api/projets", projetsHandler) + http.HandleFunc("/api/projet/", projetHandler) + http.HandleFunc("/api/technologies", technologiesHandler) +} \ No newline at end of file diff --git a/routes/technologie.go b/routes/technologie.go new file mode 100644 index 0000000..db2ec9f --- /dev/null +++ b/routes/technologie.go @@ -0,0 +1,48 @@ +package routes + +import ( + "api_serveurless_go/requette" + "api_serveurless_go/types" + "encoding/json" + "net/http" + "os" +) + + + +// technologiesHandler gère la liste des technologies +func technologiesHandler(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Access-Control-Allow-Origin", os.Getenv("FRONTEND_URL")) // <-- Remplace avec le port de ton front-end + w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS") + w.Header().Set("Access-Control-Allow-Headers", "Content-Type") + switch r.Method { + case "GET": + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(requette.GetAllTechnologies()) + case "POST": + + var technologie types.TechnologieCreate + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + err := decoder.Decode(&technologie) + if err != nil { + http.Error(w, "Erreur de décodage JSON: "+err.Error(), http.StatusBadRequest) + return + } + if requette.CreateTechnologie(technologie) == nil { + http.Error(w, "Erreur lors de la création de la technologie", http.StatusInternalServerError) + } else { + w.WriteHeader(http.StatusCreated) + } + case "OPTIONS": + w.WriteHeader(http.StatusOK) + return + + default: + http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed) + } +} + + + diff --git a/types/projet.go b/types/projet.go new file mode 100644 index 0000000..7fae015 --- /dev/null +++ b/types/projet.go @@ -0,0 +1,31 @@ +package types + +type ProjetShort struct { + Id int `json:"id"` + Name string `json:"name"` + ShortDescriptionFr string `json:"shortdescriptionfr"` + Technologies []string `json:"technologies"` + +} + +type Projetcreate struct { + Name string `json:"name"` + ShortDescription string `json:"shortdescriptionfr"` +} + +type ProjetFull struct { + Id int `json:"id"` + Name string `json:"name"` + ShortDescriptionFr string `json:"shortdescriptionfr"` + LongDescriptionFr string `json:"longdescriptionfr"` + ShortDescriptionEn string `json:"shortdescriptionen"` + LongDescriptionEn string `json:"longdescriptionen"` + LinkGithub string `json:"linkGithub"` + LinkWeb string `json:"linkWeb"` + Technologies []string `json:"technologies"` +} + +type Projets struct { + Projets []ProjetShort `json:"projets"` + Count int `json:"count"` +} diff --git a/types/technologie.go b/types/technologie.go new file mode 100644 index 0000000..668b7e3 --- /dev/null +++ b/types/technologie.go @@ -0,0 +1,21 @@ +package types + +type TechnologieShort struct { + Id int `json:"id"` + Name string `json:"name"` + +} + +type TechnologieCreate struct { + Name string `json:"name"` +} + +type TechnologieFull struct { + Id int `json:"id"` + Name string `json:"name"` +} + +type Technologies struct { + Technologies []TechnologieShort `json:"technologies"` + Count int `json:"count"` +}