diff --git a/backend/.env.example b/backend/.env.example new file mode 100644 index 0000000..004d991 --- /dev/null +++ b/backend/.env.example @@ -0,0 +1,4 @@ +DB_USER="" +DB_PASS="" +DB_HOST="" +DB_NAME="" \ No newline at end of file diff --git a/backend/.gitignore b/backend/.gitignore new file mode 100644 index 0000000..24e8192 --- /dev/null +++ b/backend/.gitignore @@ -0,0 +1,2 @@ +.env +/vendor \ No newline at end of file diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..bd6312b --- /dev/null +++ b/backend/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/backend/api_serveurless_go b/backend/api_serveurless_go new file mode 100644 index 0000000..a6d1e37 Binary files /dev/null and b/backend/api_serveurless_go differ diff --git a/backend/bd/bd.go b/backend/bd/bd.go new file mode 100644 index 0000000..c2fcceb --- /dev/null +++ b/backend/bd/bd.go @@ -0,0 +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.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/backend/create_table.sql b/backend/create_table.sql new file mode 100644 index 0000000..82d367e --- /dev/null +++ b/backend/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/backend/docker-compose.yaml b/backend/docker-compose.yaml new file mode 100644 index 0000000..ba4a623 --- /dev/null +++ b/backend/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/backend/go.mod b/backend/go.mod new file mode 100644 index 0000000..4553c24 --- /dev/null +++ b/backend/go.mod @@ -0,0 +1,10 @@ +module api_serveurless_go + +go 1.21.0 + +require ( + github.com/go-sql-driver/mysql v1.9.3 + github.com/joho/godotenv v1.5.1 +) + +require filippo.io/edwards25519 v1.1.0 // indirect diff --git a/backend/go.sum b/backend/go.sum new file mode 100644 index 0000000..b380070 --- /dev/null +++ b/backend/go.sum @@ -0,0 +1,6 @@ +filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= +filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= +github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo= +github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU= +github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= +github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= diff --git a/backend/main.go b/backend/main.go new file mode 100644 index 0000000..741728e --- /dev/null +++ b/backend/main.go @@ -0,0 +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) +} diff --git a/backend/requette/projet.go b/backend/requette/projet.go new file mode 100644 index 0000000..6cce1cc --- /dev/null +++ b/backend/requette/projet.go @@ -0,0 +1,132 @@ +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/backend/requette/technologie.go b/backend/requette/technologie.go new file mode 100644 index 0000000..fb049e2 --- /dev/null +++ b/backend/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/backend/routes/projet.go b/backend/routes/projet.go new file mode 100644 index 0000000..1d7c335 --- /dev/null +++ b/backend/routes/projet.go @@ -0,0 +1,122 @@ +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/backend/routes/route.go b/backend/routes/route.go new file mode 100644 index 0000000..e82740c --- /dev/null +++ b/backend/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/backend/routes/technologie.go b/backend/routes/technologie.go new file mode 100644 index 0000000..db2ec9f --- /dev/null +++ b/backend/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/backend/types/projet.go b/backend/types/projet.go new file mode 100644 index 0000000..7fae015 --- /dev/null +++ b/backend/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/backend/types/technologie.go b/backend/types/technologie.go new file mode 100644 index 0000000..668b7e3 --- /dev/null +++ b/backend/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"` +}