From 81c15b69c9337af6b800abe7880dbeb4de5d46b0 Mon Sep 17 00:00:00 2001 From: Georg Spar Date: Mon, 12 Jun 2023 20:36:58 +0200 Subject: [PATCH] v0.1.0: photo, itb, mea integriert, kurz zu mea --- data.go | 17 +- wdm.go | 490 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- wdmdb.go | 274 +++++++++++++++++++++++++++++++ 3 files changed, 766 insertions(+), 15 deletions(-) diff --git a/data.go b/data.go index ba59435..c37574c 100644 --- a/data.go +++ b/data.go @@ -29,14 +29,15 @@ type Typ struct { // struct für die Groessenangaben der Kleidungsstücke type Measure struct { Id uint64 `json:"id"` - Brust float32 `json:"brust"` - LaengeT float32 `json:"laenget"` - Schulterbreite float32 `json:"schulterbreite"` - TaillenumfangT float32 `json:"taillenumfangt"` - Hueftumfang float32 `json:"hueftumfang"` - Innennaht float32 `json:"innennaht"` - LaengeB float32 `json:"laengeb"` - TaillenumfangB float32 `json:"taillenumfangb"` + Kurz string `json:"kurz"` + Brust float64 `json:"brust"` + LaengeT float64 `json:"laenget"` + Schulterbreite float64 `json:"schulterbreite"` + TaillenumfangT float64 `json:"taillenumfangt"` + Hueftumfang float64 `json:"hueftumfang"` + Innennaht float64 `json:"innennaht"` + LaengeB float64 `json:"laengeb"` + TaillenumfangB float64 `json:"taillenumfangb"` } // struct für die Erweiterung des Items für die Benutzung diff --git a/wdm.go b/wdm.go index 979f346..c806ecf 100644 --- a/wdm.go +++ b/wdm.go @@ -35,7 +35,7 @@ func main() { r.HandleFunc("/api/v1/typ/{id:[0-9]+}", getTypHandler).Methods("GET", "OPTIONS") r.HandleFunc("/api/v1/typ/{id:[0-9]+}", updateTypHandler).Methods("PUT", "OPTIONS") - /* r.HandleFunc("/api/v1/pho", createPhotoHandler).Methods("POST", "OPTIONS") + r.HandleFunc("/api/v1/pho", createPhotoHandler).Methods("POST", "OPTIONS") r.HandleFunc("/api/v1/pho/{id:[0-9]+}", deletePhotoHandler).Methods("DELETE", "OPTIONS") r.HandleFunc("/api/v1/pho", showPhotoHandler).Methods("GET", "OPTIONS") r.HandleFunc("/api/v1/pho/{id:[0-9]+}", getPhotoHandler).Methods("GET", "OPTIONS") @@ -52,12 +52,12 @@ func main() { r.HandleFunc("/api/v1/itb", showItemBHandler).Methods("GET", "OPTIONS") r.HandleFunc("/api/v1/itb/{id:[0-9]+}", getItemBHandler).Methods("GET", "OPTIONS") r.HandleFunc("/api/v1/itb/{id:[0-9]+}", updateItemBHandler).Methods("PUT", "OPTIONS") - - r.HandleFunc("/api/v1/ite", createItemExtHandler).Methods("POST", "OPTIONS") - r.HandleFunc("/api/v1/ite/{id:[0-9]+}", deleteItemExtHandler).Methods("DELETE", "OPTIONS") - r.HandleFunc("/api/v1/ite", showItemExtHandler).Methods("GET", "OPTIONS") - r.HandleFunc("/api/v1/ite/{id:[0-9]+}", getItemExtHandler).Methods("GET", "OPTIONS") - r.HandleFunc("/api/v1/ite/{id:[0-9]+}", updateItemExtHandler).Methods("PUT", "OPTIONS") */ + /* + r.HandleFunc("/api/v1/ite", createItemExtHandler).Methods("POST", "OPTIONS") + r.HandleFunc("/api/v1/ite/{id:[0-9]+}", deleteItemExtHandler).Methods("DELETE", "OPTIONS") + r.HandleFunc("/api/v1/ite", showItemExtHandler).Methods("GET", "OPTIONS") + r.HandleFunc("/api/v1/ite/{id:[0-9]+}", getItemExtHandler).Methods("GET", "OPTIONS") + r.HandleFunc("/api/v1/ite/{id:[0-9]+}", updateItemExtHandler).Methods("PUT", "OPTIONS") */ http.Handle("/", r) r.Use(mux.CORSMethodMiddleware(r)) @@ -200,3 +200,479 @@ func updateTypHandler(writer http.ResponseWriter, req *http.Request) { writer.WriteHeader(http.StatusOK) writer.Write(b) } + +// Photo Funktionen +func createPhotoHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var pho Photos + if req.Form["pfad"] != nil { + pho.ItembId, _ = strconv.ParseUint(req.FormValue("itembid"), 10, 0) + pho.ItemextId, _ = strconv.ParseUint(req.FormValue("itemextid"), 10, 0) + pho.Pfad = req.FormValue("pfad") + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + } else { + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var pho Photos + json.Unmarshal(body, &pho) + } + + log.Println(pho) + log.Println("Name= ", pho.Pfad) + log.Info("creating new Photo", pho.Pfad) + res, err := CreatePhoto(pho) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusCreated) + writer.Write(b) +} + +func deletePhotoHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + phoId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + log.Info("Deleting Photo with ID", phoId) + _, err = DeletePhoto(uint64(phoId)) + if err != nil { + log.Fatal("Error: Delete could not be executed", err) + } + writer.WriteHeader(http.StatusNoContent) +} + +func showPhotoHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + res, err := ShowPhoto() + if err != nil { + log.Fatal("Error: Photos can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func getPhotoHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + phoId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + res, err := GetPhoto(uint64(phoId)) + if err != nil { + log.Fatal("Error: Typ can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func updatePhotoHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var pho Photos + json.Unmarshal(body, &pho) + log.Println("Name = ", pho.Pfad) + log.Info("updating Photo", pho.Pfad) + res, err := UpdatePhoto(pho) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +// Measure Funktionen +func createMeasureHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var mea Measure + if req.Form["kurz"] != nil { + mea.Kurz = req.FormValue("kurz") + mea.Brust, _ = strconv.ParseFloat(req.FormValue("brust"), 64) + mea.LaengeT, _ = strconv.ParseFloat(req.FormValue("laenget"), 64) + mea.Schulterbreite, _ = strconv.ParseFloat(req.FormValue("schulterbreite"), 64) + mea.TaillenumfangT, _ = strconv.ParseFloat(req.FormValue("taillenumfangt"), 64) + mea.Hueftumfang, _ = strconv.ParseFloat(req.FormValue("hueftumfang"), 64) + mea.Innennaht, _ = strconv.ParseFloat(req.FormValue("innennaht"), 64) + mea.LaengeB, _ = strconv.ParseFloat(req.FormValue("laengeb"), 64) + mea.TaillenumfangB, _ = strconv.ParseFloat(req.FormValue("taillenumfangb"), 64) + + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + } else { + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var mea Measure + json.Unmarshal(body, &mea) + } + + log.Println(mea) + log.Println("Name= ", mea.Kurz) + log.Info("creating new Measure", mea.Kurz) + res, err := CreateMeasure(mea) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusCreated) + writer.Write(b) +} + +func deleteMeasureHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + meaId, _ := strconv.ParseUint(req.FormValue("id"), 10, 0) + log.Info("Deleting Measure with ID", meaId) + _, err = DeleteMeasure(uint64(meaId)) + if err != nil { + log.Fatal("Error: Delete could not be executed", err) + } + writer.WriteHeader(http.StatusNoContent) +} + +func showMeasureHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + res, err := ShowMeasure() + if err != nil { + log.Fatal("Error: Measure can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func getMeasureHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + meaId, _ := strconv.ParseUint(req.FormValue("id"), 10, 0) + res, err := GetMeasure(uint64(meaId)) + if err != nil { + log.Fatal("Error: Measure can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func updateMeasureHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var mea Measure + if req.Form["kurz"] != nil { + mea.Kurz = req.FormValue("kurz") + mea.Brust, _ = strconv.ParseFloat(req.FormValue("brust"), 64) + mea.LaengeT, _ = strconv.ParseFloat(req.FormValue("laenget"), 64) + mea.Schulterbreite, _ = strconv.ParseFloat(req.FormValue("schulterbreite"), 64) + mea.TaillenumfangT, _ = strconv.ParseFloat(req.FormValue("taillenumfangt"), 64) + mea.Hueftumfang, _ = strconv.ParseFloat(req.FormValue("hueftumfang"), 64) + mea.Innennaht, _ = strconv.ParseFloat(req.FormValue("innennaht"), 64) + mea.LaengeB, _ = strconv.ParseFloat(req.FormValue("laengeb"), 64) + mea.TaillenumfangB, _ = strconv.ParseFloat(req.FormValue("taillenumfangb"), 64) + + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + } else { + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var mea Measure + json.Unmarshal(body, &mea) + } + + log.Println("Name = ", mea.Kurz) + log.Info("updating Measure", mea.Kurz) + res, err := UpdateMeasure(mea) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +// ItemsB Funktionen +func createItemBHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var itemB Itemb + if req.Form["bezeichnung"] != nil { + itemB.Bezeichnung = req.FormValue("bezeichnung") + itemB.Kurzbeschreibung = req.FormValue("kurzbeschreibung") + itemB.Material = req.FormValue("material") + itemB.Groesse = req.FormValue("groesse") + itemB.Farbe = req.FormValue("farbe") + itbtyp, _ := strconv.ParseUint(req.FormValue("typid"), 10, 0) + itemB.TypId = uint(itbtyp) + itemB.AbmessungenId, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0) + + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + } else { + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var itemB Itemb + json.Unmarshal(body, &itemB) + } + + log.Println(itemB) + log.Println("Name= ", itemB.Bezeichnung) + log.Info("creating new Typ", itemB.Bezeichnung) + res, err := CreateItemB(itemB) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusCreated) + writer.Write(b) +} + +func deleteItemBHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + itemBId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + log.Info("Deleting Typ with ID", itemBId) + _, err = DeleteItemB(uint64(itemBId)) + if err != nil { + log.Fatal("Error: Delete could not be executed", err) + } + writer.WriteHeader(http.StatusNoContent) +} + +func showItemBHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + res, err := ShowItemB() + if err != nil { + log.Fatal("Error: Typ can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func getItemBHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + itemBId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + res, err := GetItemB(uint64(itemBId)) + if err != nil { + log.Fatal("Error: Typ can't be shown ", err) + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := req.URL.String() + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} + +func updateItemBHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var itemB Itemb + if req.Form["bezeichnung"] != nil { + itemB.Bezeichnung = req.FormValue("bezeichnung") + itemB.Kurzbeschreibung = req.FormValue("kurzbeschreibung") + itemB.Material = req.FormValue("material") + itemB.Groesse = req.FormValue("groesse") + itemB.Farbe = req.FormValue("farbe") + itbtyp, _ := strconv.ParseUint(req.FormValue("typid"), 10, 0) + itemB.TypId = uint(itbtyp) + itemB.AbmessungenId, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0) + + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + } else { + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var itemB Itemb + json.Unmarshal(body, &itemB) + } + + log.Println("Name = ", itemB.Bezeichnung) + log.Info("updating Typ", itemB.Bezeichnung) + res, err := UpdateItemB(itemB) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusOK) + writer.Write(b) +} diff --git a/wdmdb.go b/wdmdb.go index 419740e..f188d08 100644 --- a/wdmdb.go +++ b/wdmdb.go @@ -102,3 +102,277 @@ func UpdateTyp(typ Typ) (resTyp Typ, err error) { resTyp = typ return resTyp, err } + +// Photo Funktionen +func CreatePhoto(pho Photos) (resPhoto Photos, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (Photo CREATE)") + log.Println("Name = ", pho.Pfad) + defer conn.Close() + res, err := conn.Exec("INSERT INTO photo VALUES(?,?,?,?)", pho.Id, pho.Pfad, pho.ItembId, pho.ItemextId) + if err != nil { + log.Println("Error while executing insert statement", err) + } + lastId, err := res.LastInsertId() + pho.Id = uint64(lastId) + resPhoto = pho + return resPhoto, err +} + +func DeletePhoto(phoId uint64) (result, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Photo DELETE)") + defer conn.Close() + _, err = conn.Exec("DELETE FROM photo WHERE id = ?", phoId) + if err != nil { + log.Fatal("Error while executing DELETE statement", err) + } + return result, err +} + +func ShowPhoto() (phoArray []Photos, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Photo SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM photos") + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + var pho Photos + for results.Next() { + err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId) + if err != nil { + log.Fatal("Error: ", err) + } + phoArray = append(phoArray, pho) + } + return phoArray, err +} + +func GetPhoto(id uint64) (pho Photos, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Photo SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM typ WHERE id=?", id) + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + for results.Next() { + err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId) + if err != nil { + log.Fatal("Error: ", err) + } + } + return pho, err +} + +func UpdatePhoto(pho Photos) (resPho Photos, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (Photo UPDATE)") + log.Println("Name = ", pho.Pfad) + defer conn.Close() + _, err = conn.Exec("UPDATE photos SET pfad=?, itembid=?, itemextid=? WHERE id=?", pho.Pfad, pho.ItembId, pho.ItemextId, pho.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + resPho = pho + return resPho, err +} + +// Measure Funktionen +func CreateMeasure(mea Measure) (resMea Measure, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (Measure INSERT)") + log.Println("Name = ", mea.Kurz) + defer conn.Close() + res, err := conn.Exec("INSERT INTO measure VALUES(?,?,?,?,?,?,?,?,?,?)", mea.Id, mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz) + if err != nil { + log.Println("Error while executing insert statement", err) + } + lastId, err := res.LastInsertId() + mea.Id = uint64(lastId) + resMea = mea + return resMea, err +} + +func DeleteMeasure(meaId uint64) (result, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Measure DELETE)") + defer conn.Close() + _, err = conn.Exec("DELETE FROM measure WHERE id = ?", meaId) + if err != nil { + log.Fatal("Error while executing DELETE statement", err) + } + return result, err +} + +func ShowMeasure() (meaArray []Measure, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Measure SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM measure") + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + var mea Measure + for results.Next() { + err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz) + if err != nil { + log.Fatal("Error: ", err) + } + meaArray = append(meaArray, mea) + } + return meaArray, err +} + +func GetMeasure(id uint64) (mea Measure, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (Measure SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM mea WHERE id=?", id) + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + for results.Next() { + err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz) + if err != nil { + log.Fatal("Error: ", err) + } + } + return mea, err +} + +func UpdateMeasure(mea Measure) (resMea Measure, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (Measure UPDATE)") + log.Println("Name = ", mea.Kurz) + defer conn.Close() + _, err = conn.Exec("UPDATE measure SET brust=?, laenget=?, schulterbreite=?, taillenumfangt=? hueftumfang=?, innennaht=?, laengeb=?, taillenumfangb=?, kurz=? WHERE id=?", + mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz, mea.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + resMea = mea + return resMea, err +} + +// ItemB Funktionen +func CreateItemB(itemB Itemb) (resItemb Itemb, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (ItemB Create)") + log.Println("Name = ", itemB.Bezeichnung) + defer conn.Close() + res, err := conn.Exec("INSERT INTO itemb VALUES(?,?,?,?,?,?,?,?)", itemB.Id, itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.TypId, itemB.Material, itemB.AbmessungenId) + if err != nil { + log.Println("Error while executing insert statement", err) + } + lastId, err := res.LastInsertId() + itemB.Id = uint64(lastId) + resItemb = itemB + return resItemb, err +} + +func DeleteItemB(itemBId uint64) (result, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (ItemB DELETE)") + defer conn.Close() + _, err = conn.Exec("DELETE FROM itemb WHERE id = ?", itemBId) + if err != nil { + log.Fatal("Error while executing DELETE statement", err) + } + return result, err +} + +func ShowItemB() (itemBArray []Itemb, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (ItemB SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM itemb") + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + var itemB Itemb + for results.Next() { + err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.TypId, &itemB.Material, &itemB.AbmessungenId) + if err != nil { + log.Fatal("Error: ", err) + } + itemBArray = append(itemBArray, itemB) + } + return itemBArray, err +} + +func GetItemB(id uint64) (itemB Itemb, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (ItemB SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM itemb WHERE id=?", id) + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + for results.Next() { + err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.TypId, &itemB.Material, &itemB.AbmessungenId) + if err != nil { + log.Fatal("Error: ", err) + } + } + return itemB, err +} + +func UpdateItemB(itemB Itemb) (resItemb Itemb, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (ItemB UPDATE)") + log.Println("Name = ", itemB.Bezeichnung) + defer conn.Close() + _, err = conn.Exec("UPDATE itemb SET bezeichnung=?, kurzbeschreibung=?, groesse=?, farbe=?, typid=?, material=?, abmessungenid=? WHERE id=?", itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.TypId, itemB.Material, itemB.AbmessungenId, itemB.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + resItemb = itemB + return resItemb, err +}