diff --git a/Jenkinsfile b/Jenkinsfile new file mode 100644 index 0000000..ef76f3a --- /dev/null +++ b/Jenkinsfile @@ -0,0 +1,12 @@ +pipeline { + agent any + tools { go 'gobabygo' } + stages { + stage('TuI') { + steps { + sh 'GOOS=linux GOARCH=arm64 go build -o wadrma .' + } + } + + } +} \ No newline at end of file diff --git a/data.go b/data.go index ba59435..eb4e13b 100644 --- a/data.go +++ b/data.go @@ -1,15 +1,32 @@ package main +import "database/sql" + +// Pfad für die Ablage der Uploads +var UploadPfad string = "/opt/data/uploads" + // struct für das Einbinden von Items, die gekauft wurden type Itemb struct { - Id uint64 `json:"id"` - Bezeichnung string `json:"bezeichnung"` - Kurzbeschreibung string `json:"kurzbeschreibung"` - Groesse string `json:"groesse"` - Farbe string `json:"farbe"` - TypId uint `json:"typid"` - Material string `json:"material"` - AbmessungenId uint64 `json:"abmessungenid"` + Id uint64 `json:"id"` + Bezeichnung string `json:"bezeichnung"` + Kurzbeschreibung string `json:"kurzbeschreibung"` + Groesse string `json:"groesse"` + Farbe string `json:"farbe"` + Type Typ `json:"type"` + Material string `json:"material"` + Abmessungen Measure `json:"abmessungen"` + Frontview Photos `json:"frontview"` +} + +// struct für die Datenbank-Abfrage, analog zu Itemb +type DbIb struct { + Bezeichnung sql.NullString + Kurzbeschreibung sql.NullString + Groesse sql.NullString + Farbe sql.NullString + Material sql.NullString + Abmessungen DbMea + Frontview DbPho } // struct für die Fotos, die im Filesystem abgelegt werden sollen @@ -18,6 +35,14 @@ type Photos struct { Pfad string `json:"pfad"` ItembId uint64 `json:"itembid"` ItemextId uint64 `json:"itemextid"` + ImageUrl string `json:"imgurl"` +} + +// struct für die Datenbank-Abfrage von Photos +type DbPho struct { + Pfad sql.NullString + ItembId sql.NullInt64 + ItemextId sql.NullInt64 } // struct für die Typen von Kleidung @@ -29,14 +54,28 @@ 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 Datenbank-Abfrage, analog zu Measure +type DbMea struct { + Kurz sql.NullString + Brust sql.NullFloat64 + LaengeT sql.NullFloat64 + Schulterbreite sql.NullFloat64 + TaillenumfangT sql.NullFloat64 + Hueftumfang sql.NullFloat64 + Innennaht sql.NullFloat64 + LaengeB sql.NullFloat64 + TaillenumfangB sql.NullFloat64 } // struct für die Erweiterung des Items für die Benutzung @@ -49,5 +88,27 @@ type ItemExt struct { Bemerkung string `json:"bemerkung"` Bewertung int `json:"bewertung"` Favorit bool `json:"favorit"` - ItemBId uint64 `json:"itembid"` + ItemB Itemb `json:"itemb"` + Frontview Photos `json:"frontview"` +} + +// struct für die Datenbank-Abrage +type DbIe struct { + Zuhause sql.NullBool + Draussen sql.NullBool + Genehmigt sql.NullBool + Bemerkung sql.NullString + Bewertung sql.NullInt64 + Favorit sql.NullBool + ItemB DbIb + Frontview DbPho +} + +// Upload-struct + +type ImgUpload struct { + ObjUrl string `json:"objectURL"` + Name string `json:"name"` + Size int `json:"size"` + Type string `json:"type"` } diff --git a/thumbs.sh b/thumbs.sh new file mode 100644 index 0000000..c9c04a7 --- /dev/null +++ b/thumbs.sh @@ -0,0 +1,8 @@ +#!/bin/bash +cd /opt/data/uploads +for i in *.png; do /usr/bin/convert -thumbnail 80 $i thumb-$i; done; +for i in *.jpg; do /usr/bin/convert -thumbnail 80 $i thumb-$i; done; +for i in *.jpeg; do /usr/bin/convert -thumbnail 80 $i thumb-$i; done; +for i in *.webp; do /usr/bin/convert -thumbnail 80 $i thumb-$i; done; +cd / + diff --git a/wdm b/wdm new file mode 100755 index 0000000..8a8346f Binary files /dev/null and b/wdm differ diff --git a/wdm.go b/wdm.go index abaf464..85e3e7f 100644 --- a/wdm.go +++ b/wdm.go @@ -6,6 +6,7 @@ import ( "io" "net/http" "os" + "os/exec" "strconv" "github.com/gorilla/mux" @@ -35,10 +36,12 @@ 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") + r.HandleFunc("/api/v1/pho/itb/{id:[0-9]+}", getPhotoForItbHandler).Methods("GET", "OPTIONS") + r.HandleFunc("/api/v1/pho/ite/{id:[0-9]+}", getPhotoForIteHandler).Methods("GET", "OPTIONS") r.HandleFunc("/api/v1/pho/{id:[0-9]+}", updatePhotoHandler).Methods("PUT", "OPTIONS") r.HandleFunc("/api/v1/meas", createMeasureHandler).Methods("POST", "OPTIONS") @@ -53,11 +56,13 @@ func main() { 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/upload", uploadFileHandler).Methods("POST", "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/{id:[0-9]+}", updateItemExtHandler).Methods("PUT", "OPTIONS") http.Handle("/", r) r.Use(mux.CORSMethodMiddleware(r)) @@ -71,12 +76,28 @@ func createTypHandler(writer http.ResponseWriter, req *http.Request) { if req.Method == http.MethodOptions { return } - body, err := io.ReadAll(req.Body) + + err := req.ParseMultipartForm(64 << 20) if err != nil { writer.WriteHeader(http.StatusBadRequest) + return } var typ Typ - json.Unmarshal(body, &typ) + if req.Form["bezeichnung"] != nil { + typ.Bezeichnung = req.FormValue("bezeichnung") + 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 typ Typ + json.Unmarshal(body, &typ) + } + log.Println(typ) log.Println("Name= ", typ.Bezeichnung) log.Info("creating new Typ", typ.Bezeichnung) @@ -100,9 +121,14 @@ func deleteTypHandler(writer http.ResponseWriter, req *http.Request) { if req.Method == http.MethodOptions { return } + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } typId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) - log.Info("Deleting Instance with ID", typId) - _, err := DeleteTyp(uint(typId)) + log.Info("Deleting Typ with ID", typId) + _, err = DeleteTyp(uint(typId)) if err != nil { log.Fatal("Error: Delete could not be executed", err) } @@ -157,12 +183,27 @@ func updateTypHandler(writer http.ResponseWriter, req *http.Request) { if req.Method == http.MethodOptions { return } - body, err := io.ReadAll(req.Body) + + err := req.ParseMultipartForm(64 << 20) if err != nil { writer.WriteHeader(http.StatusBadRequest) + return } var typ Typ - json.Unmarshal(body, &typ) + var tid uint64 + if req.Form["bezeichnung"] != nil { + typ.Bezeichnung = req.FormValue("bezeichnung") + tid, _ = strconv.ParseUint(req.FormValue("id"), 10, 0) + typ.Id = uint(tid) + } else { + + body, err := io.ReadAll(req.Body) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + } + var typ Typ + json.Unmarshal(body, &typ) + } log.Println("Name = ", typ.Bezeichnung) log.Info("updating Typ", typ.Bezeichnung) res, err := UpdateTyp(typ) @@ -179,3 +220,804 @@ 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 + } + /*err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var pho Photos + if req.Form["id"] != nil { + pho.Id, _ = strconv.ParseUint(req.FormValue("id"), 10, 0) + 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 { */ + var pho Photos + pho.Id, _ = strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + //} + res, err := GetPhoto(uint64(pho.Id)) + 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 getPhotoForItbHandler(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 := GetPhotoForItb(uint64(phoId)) + if err != nil { + log.Fatal("Error: Photo 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 getPhotoForIteHandler(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 := GetPhotoForIte(uint64(phoId)) + if err != nil { + log.Fatal("Error: Photo 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 + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var pho Photos + if req.Form["pfad"] != nil { + pho.Id, _ = strconv.ParseUint(req.FormValue("id"), 10, 0) + pho.Pfad = req.FormValue("pfad") + pho.ItembId, _ = strconv.ParseUint(req.FormValue("itembid"), 10, 0) + pho.ItemextId, _ = strconv.ParseUint(req.FormValue("itemextid"), 10, 0) + } else { + 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.Id, _ = strconv.ParseUint(req.FormValue("id"), 10, 0) + 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.Type.Id = uint(itbtyp) + itemB.Abmessungen.Id, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0) + itemB.Frontview.Id, _ = strconv.ParseUint(req.FormValue("frontviewid"), 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.Type.Id = uint(itbtyp) + itemB.Abmessungen.Id, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0) + itemB.Frontview.Id, _ = strconv.ParseUint(req.FormValue("frontviewid"), 10, 0) + itemB.Id, _ = strconv.ParseUint(req.FormValue("id"), 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) +} + +// ItemsExt Funktionen +func createItemExtHandler(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 itemExt ItemExt + if req.Form["genehmigt"] != nil { + itemExt.Zuhause, _ = strconv.ParseBool(req.FormValue("zuhause")) + itemExt.Draussen, _ = strconv.ParseBool(req.FormValue("draussen")) + itemExt.Genehmigt, _ = strconv.ParseBool(req.FormValue("genehmigt")) + itemExt.Bemerkung = req.FormValue("bemerkung") + itetyp, _ := strconv.ParseUint(req.FormValue("bewertung"), 10, 0) + itemExt.Bewertung = int(itetyp) + itemExt.Favorit, _ = strconv.ParseBool(req.FormValue("abmessungenid")) + itemExt.Frontview.Id, _ = strconv.ParseUint(req.FormValue("frontviewid"), 10, 0) + itemExt.ItemB.Id, _ = strconv.ParseUint(req.FormValue("itembid"), 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 itemExt ItemExt + json.Unmarshal(body, &itemExt) + } + + log.Println(itemExt) + log.Println("ID= ", itemExt.Id) + log.Info("creating new ItemExt", itemExt.Id) + res, err := CreateItemExt(itemExt) + 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 deleteItemExtHandler(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 + } + itemExtId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + log.Info("Deleting Typ with ID", itemExtId) + _, err = DeleteItemExt(uint64(itemExtId)) + if err != nil { + log.Fatal("Error: Delete could not be executed", err) + } + writer.WriteHeader(http.StatusNoContent) +} + +func showItemExtHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + res, err := ShowItemExt() + 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 getItemExtHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + if req.Method == http.MethodOptions { + return + } + itemExtId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) + res, err := GetItemExt(uint64(itemExtId)) + 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 updateItemExtHandler(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 itemExt ItemExt + if req.Form["genehmigt"] != nil { + itemExt.Zuhause, _ = strconv.ParseBool(req.FormValue("zuhause")) + itemExt.Draussen, _ = strconv.ParseBool(req.FormValue("draussen")) + itemExt.Genehmigt, _ = strconv.ParseBool(req.FormValue("genehmigt")) + itemExt.Bemerkung = req.FormValue("bemerkung") + itetyp, _ := strconv.ParseUint(req.FormValue("bewertung"), 10, 0) + itemExt.Bewertung = int(itetyp) + itemExt.Favorit, _ = strconv.ParseBool(req.FormValue("abmessungenid")) + itemExt.Frontview.Id, _ = strconv.ParseUint(req.FormValue("frontviewid"), 10, 0) + itemExt.ItemB.Id, _ = strconv.ParseUint(req.FormValue("itembid"), 10, 0) + itemExt.Id, _ = strconv.ParseUint(req.FormValue("id"), 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 itemExt ItemExt + json.Unmarshal(body, &itemExt) + } + + log.Println("ID = ", itemExt.Id) + log.Info("updating ItemExt", itemExt.Id) + res, err := UpdateItemExt(itemExt) + 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) +} + +// Upload Funktionen +func uploadFileHandler(writer http.ResponseWriter, req *http.Request) { + writer.Header().Set("Access-Control-Allow-Origin", "*") + writer.Header().Set("Access-Control-Allow-Headers", "*") + if req.Method == http.MethodOptions { + return + } + + err := req.ParseMultipartForm(64 << 20) + if err != nil { + writer.WriteHeader(http.StatusBadRequest) + return + } + var pho Photos + var phoArray []Photos + log.Info("vor dem req.Form") + for formKey, formValue := range req.Form { + log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ") + } + + /*if req.Form["file"] != nil { + for i := 0; i < len(req.Form["file"]); i++ { */ + log.Info("File-Name:", req.FormValue("file.name")) + + file, handler, err := req.FormFile("file") + if err != nil { + panic(err) //dont do this + } + defer file.Close() + os.Chdir(UploadPfad) + // copy example + f, err := os.OpenFile(handler.Filename, os.O_WRONLY|os.O_CREATE, 0666) + if err != nil { + panic(err) //please dont + } + defer f.Close() + io.Copy(f, file) + + pho.Pfad = handler.Filename + pho.ItembId = 0 + pho.ItemextId = 0 + + phoArray = append(phoArray, pho) + /* } + + } */ + if len(phoArray) == 0 { + log.Fatal("Error: Size of Array = 0") + writer.WriteHeader(http.StatusInternalServerError) + return + + } + for i := 0; i < len(phoArray); i++ { + log.Println(phoArray[i]) + log.Println("Name= ", phoArray[i].Pfad) + log.Info("creating new Photo", phoArray[i].Pfad) + res, err := CreatePhoto(phoArray[i]) + if err != nil { + writer.WriteHeader(http.StatusInternalServerError) + } + b, err := json.Marshal(res) + if err != nil { + log.Fatal("Error: ", err) + } + location := fmt.Sprintf("%s", req.URL.String()) + writer.Header().Set("Location:", location) + writer.Header().Set("Content-Type", "application/json") + writer.WriteHeader(http.StatusCreated) + writer.Write(b) + cmd := exec.Command("/thumbs.sh") + if err := cmd.Run(); err != nil { + log.Fatal("Error while creating thumbs: ", err) + } + log.Info("Thumbs created after photo creation") + } + +} diff --git a/wdmapi.log b/wdmapi.log new file mode 100644 index 0000000..e69de29 diff --git a/wdmdb.go b/wdmdb.go index 1104762..fe0dccd 100644 --- a/wdmdb.go +++ b/wdmdb.go @@ -36,9 +36,9 @@ func DeleteTyp(typId uint) (result, err error) { if err != nil { log.Println("Error while connecting DB: ", err) } - log.Println("DB Verbindung hergestellt") + log.Println("DB Verbindung hergestellt (DELETE)") defer conn.Close() - _, err = conn.Exec("DELETE FROM ncinstanz WHERE id = ?", typId) + _, err = conn.Exec("DELETE FROM typ WHERE id = ?", typId) if err != nil { log.Fatal("Error while executing DELETE statement", err) } @@ -50,7 +50,7 @@ func ShowTyp() (typArray []Typ, err error) { if err != nil { log.Println("Error while connecting DB: ", err) } - log.Println("DB Verbindung hergestellt") + log.Println("DB Verbindung hergestellt (SHOW)") defer conn.Close() results, err := conn.Query("SELECT * FROM typ") if err != nil { @@ -58,7 +58,7 @@ func ShowTyp() (typArray []Typ, err error) { } var typ Typ for results.Next() { - err = results.Scan(&typ.Id, typ.Bezeichnung) + err = results.Scan(&typ.Id, &typ.Bezeichnung) if err != nil { log.Fatal("Error: ", err) } @@ -72,7 +72,7 @@ func GetTyp(id uint) (typ Typ, err error) { if err != nil { log.Println("Error while connecting DB: ", err) } - log.Println("DB Verbindung hergestellt") + log.Println("DB Verbindung hergestellt (SHOW)") defer conn.Close() results, err := conn.Query("SELECT * FROM typ WHERE id=?", id) if err != nil { @@ -92,7 +92,7 @@ func UpdateTyp(typ Typ) (resTyp Typ, err error) { if err != nil { log.Println("Error while connecting DB: ", err) } - log.Println("Verbindung hergestellt") + log.Println("Verbindung hergestellt (UPDATE)") log.Println("Name = ", typ.Bezeichnung) defer conn.Close() _, err = conn.Exec("UPDATE typ SET bezeichnung=? WHERE id=?", typ.Bezeichnung, typ.Id) @@ -102,3 +102,608 @@ 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 photos 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 photos 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 GetPhotoForItb(itbid uint64) (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 Itb SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM photos where itembid=?", itbid) + 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 GetPhotoForIte(itbid uint64) (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 Itb SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT * FROM photos where itemextid=?", itbid) + 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 photos 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.TaillenumfangB, 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.TaillenumfangB, &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 measure 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.TaillenumfangB, &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.TaillenumfangB, 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.Type.Id, itemB.Material, itemB.Abmessungen.Id, itemB.Frontview.Id) + 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 a.*, b.pfad FROM itemb a, photos b WHERE a.frontviewid=b.id") + 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.Type.Id, &itemB.Material, &itemB.Abmessungen.Id, &itemB.Frontview.Id, &itemB.Frontview.Pfad) + 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() + var dbItemb DbIb + results, err := conn.Query("SELECT a.id, a.bezeichnung, a.kurzbeschreibung, a.groesse, a.farbe, a.material, b.id, b.brust, b.laenget, b.schulterbreite, b.taillenumfangt, b.hueftumfang, b.laengeb, b.taillenumfangb, b.kurz, c.id, c.bezeichnung, d.id, d.pfad, d.itembid, d.itemextid FROM itemb a, measure b, typ c, photos d WHERE a.id=? AND b.id=a.abmessungenid AND a.typid=c.id AND a.frontviewid=d.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.Material, + &itemB.Abmessungen.Id, &itemB.Abmessungen.Brust, &itemB.Abmessungen.LaengeT, &itemB.Abmessungen.Schulterbreite, &itemB.Abmessungen.TaillenumfangT, &itemB.Abmessungen.Hueftumfang, + &itemB.Abmessungen.LaengeB, &itemB.Abmessungen.TaillenumfangB, &itemB.Abmessungen.Kurz, &itemB.Type.Id, &itemB.Type.Bezeichnung) + */ + err = results.Scan(&itemB.Id, &dbItemb.Bezeichnung, &dbItemb.Kurzbeschreibung, &dbItemb.Groesse, &dbItemb.Farbe, &dbItemb.Material, + &itemB.Abmessungen.Id, &dbItemb.Abmessungen.Brust, &dbItemb.Abmessungen.LaengeT, &dbItemb.Abmessungen.Schulterbreite, &dbItemb.Abmessungen.TaillenumfangT, &dbItemb.Abmessungen.Hueftumfang, + &dbItemb.Abmessungen.LaengeB, &dbItemb.Abmessungen.TaillenumfangB, &dbItemb.Abmessungen.Kurz, &itemB.Type.Id, &itemB.Type.Bezeichnung, &itemB.Frontview.Id, &itemB.Frontview.Pfad, &dbItemb.Frontview.ItembId, &dbItemb.Frontview.ItemextId) + if err != nil { + log.Fatal("Error: ", err) + } + if dbItemb.Bezeichnung.Valid { + itemB.Bezeichnung = dbItemb.Bezeichnung.String + } else { + itemB.Bezeichnung = "" + } + if dbItemb.Kurzbeschreibung.Valid { + itemB.Kurzbeschreibung = dbItemb.Kurzbeschreibung.String + } else { + itemB.Kurzbeschreibung = "" + } + if dbItemb.Groesse.Valid { + itemB.Groesse = dbItemb.Groesse.String + } else { + itemB.Groesse = "" + } + if dbItemb.Farbe.Valid { + itemB.Farbe = dbItemb.Farbe.String + } else { + itemB.Farbe = "" + } + if dbItemb.Material.Valid { + itemB.Material = dbItemb.Material.String + } else { + itemB.Material = "" + } + if dbItemb.Abmessungen.Brust.Valid { + itemB.Abmessungen.Brust = dbItemb.Abmessungen.Brust.Float64 + } else { + itemB.Abmessungen.Brust = 0 + } + if dbItemb.Abmessungen.LaengeT.Valid { + itemB.Abmessungen.LaengeT = dbItemb.Abmessungen.LaengeT.Float64 + } else { + itemB.Abmessungen.LaengeT = 0 + } + if dbItemb.Abmessungen.Schulterbreite.Valid { + itemB.Abmessungen.Schulterbreite = dbItemb.Abmessungen.Schulterbreite.Float64 + } else { + itemB.Abmessungen.Schulterbreite = 0 + } + if dbItemb.Abmessungen.TaillenumfangT.Valid { + itemB.Abmessungen.TaillenumfangT = dbItemb.Abmessungen.TaillenumfangT.Float64 + } else { + itemB.Abmessungen.TaillenumfangT = 0 + } + if dbItemb.Abmessungen.Hueftumfang.Valid { + itemB.Abmessungen.Hueftumfang = dbItemb.Abmessungen.Hueftumfang.Float64 + } else { + itemB.Abmessungen.Hueftumfang = 0 + } + if dbItemb.Abmessungen.LaengeB.Valid { + itemB.Abmessungen.LaengeB = dbItemb.Abmessungen.LaengeB.Float64 + } else { + itemB.Abmessungen.LaengeB = 0 + } + if dbItemb.Abmessungen.TaillenumfangB.Valid { + itemB.Abmessungen.TaillenumfangB = dbItemb.Abmessungen.TaillenumfangB.Float64 + } else { + itemB.Abmessungen.TaillenumfangB = 0 + } + if dbItemb.Abmessungen.Kurz.Valid { + itemB.Abmessungen.Kurz = dbItemb.Abmessungen.Kurz.String + } else { + itemB.Abmessungen.Kurz = "" + } + if dbItemb.Frontview.ItembId.Valid { + itemB.Frontview.ItembId = uint64(dbItemb.Frontview.ItembId.Int64) + } else { + itemB.Frontview.ItembId = 0 + } + if dbItemb.Frontview.ItemextId.Valid { + itemB.Frontview.ItemextId = uint64(dbItemb.Frontview.ItemextId.Int64) + } else { + itemB.Frontview.ItemextId = 0 + } + + } + 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=?, frontviewid=? WHERE id=?", itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.Type.Id, itemB.Material, itemB.Abmessungen.Id, itemB.Frontview.Id, itemB.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + resItemb = itemB + return resItemb, err +} + +// ItemExt Funktionen +func CreateItemExt(itemExt ItemExt) (resItemExt ItemExt, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (ItemExt Create)") + defer conn.Close() + res, err := conn.Exec("INSERT INTO itemext VALUES(?,?,?,?,?,?,?,?,?)", itemExt.Id, itemExt.Zuhause, itemExt.Draussen, itemExt.Genehmigt, itemExt.Bemerkung, itemExt.Bewertung, itemExt.Favorit, itemExt.ItemB.Id, itemExt.Frontview.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + lastId, err := res.LastInsertId() + itemExt.Id = uint64(lastId) + resItemExt = itemExt + return resItemExt, err +} + +func DeleteItemExt(itemExtId 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 (ItemExt DELETE)") + defer conn.Close() + _, err = conn.Exec("DELETE FROM itemext WHERE id = ?", itemExtId) + if err != nil { + log.Fatal("Error while executing DELETE statement", err) + } + return result, err +} + +func ShowItemExt() (itemExtArray []ItemExt, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (ItemExt SHOW)") + defer conn.Close() + results, err := conn.Query("SELECT a.*, b.pfad FROM itemext a, photos b WHERE a.frontviewid=b.id") + if err != nil { + log.Fatal("Error while executing SELECt statement", err) + } + var itemExt ItemExt + for results.Next() { + err = results.Scan(&itemExt.Id, &itemExt.Zuhause, &itemExt.Draussen, &itemExt.Genehmigt, &itemExt.Bemerkung, &itemExt.Bewertung, &itemExt.Favorit, &itemExt.ItemB.Id, &itemExt.Frontview.Id, &itemExt.Frontview.Pfad) + if err != nil { + log.Fatal("Error: ", err) + } + itemExtArray = append(itemExtArray, itemExt) + } + return itemExtArray, err +} + +func GetItemExt(id uint64) (itemExt ItemExt, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("DB Verbindung hergestellt (ItemExt SHOW)") + defer conn.Close() + var dbItemExt DbIe + results, err := conn.Query("SELECT ie.id, ie.zuhause, ie.draussen, ie.genehmigt, ie.bemerkung, ie.bewertung, ie.favorit, a.id, a.bezeichnung, a.kurzbeschreibung, a.groesse, a.farbe, a.material, b.id, b.brust, b.laenget, b.schulterbreite, b.taillenumfangt, b.hueftumfang, b.laengeb, b.taillenumfangb, b.kurz, c.id, c.bezeichnung, d.id, d.pfad, d.itembid, d.itemextid FROM itemext ie, itemb a, measure b, typ c, photos d WHERE ie.id=? AND ie.itembid=a.id AND b.id=a.abmessungenid AND a.typid=c.id AND ie.frontviewid=d.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.Material, + &itemB.Abmessungen.Id, &itemB.Abmessungen.Brust, &itemB.Abmessungen.LaengeT, &itemB.Abmessungen.Schulterbreite, &itemB.Abmessungen.TaillenumfangT, &itemB.Abmessungen.Hueftumfang, + &itemB.Abmessungen.LaengeB, &itemB.Abmessungen.TaillenumfangB, &itemB.Abmessungen.Kurz, &itemB.Type.Id, &itemB.Type.Bezeichnung) + */ + err = results.Scan(&itemExt.Id, &dbItemExt.Zuhause, &dbItemExt.Draussen, &dbItemExt.Genehmigt, &dbItemExt.Bemerkung, &dbItemExt.Bewertung, &dbItemExt.Favorit, + &itemExt.ItemB.Id, &dbItemExt.ItemB.Bezeichnung, &dbItemExt.ItemB.Kurzbeschreibung, &dbItemExt.ItemB.Groesse, &dbItemExt.ItemB.Farbe, &dbItemExt.ItemB.Material, + &itemExt.ItemB.Abmessungen.Id, &dbItemExt.ItemB.Abmessungen.Brust, &dbItemExt.ItemB.Abmessungen.LaengeT, &dbItemExt.ItemB.Abmessungen.Schulterbreite, &dbItemExt.ItemB.Abmessungen.TaillenumfangT, &dbItemExt.ItemB.Abmessungen.Hueftumfang, + &dbItemExt.ItemB.Abmessungen.LaengeB, &dbItemExt.ItemB.Abmessungen.TaillenumfangB, &dbItemExt.ItemB.Abmessungen.Kurz, &itemExt.ItemB.Type.Id, &itemExt.ItemB.Type.Bezeichnung, &itemExt.Frontview.Id, &itemExt.Frontview.Pfad, &dbItemExt.Frontview.ItembId, &dbItemExt.Frontview.ItemextId) + if err != nil { + log.Fatal("Error: ", err) + } + if dbItemExt.Zuhause.Valid { + itemExt.Zuhause = dbItemExt.Zuhause.Bool + } else { + itemExt.Zuhause = false + } + if dbItemExt.Draussen.Valid { + itemExt.Draussen = dbItemExt.Draussen.Bool + } else { + itemExt.Draussen = false + } + if dbItemExt.Genehmigt.Valid { + itemExt.Genehmigt = dbItemExt.Genehmigt.Bool + } else { + itemExt.Genehmigt = false + } + if dbItemExt.Bemerkung.Valid { + itemExt.Bemerkung = dbItemExt.Bemerkung.String + } else { + itemExt.Bemerkung = "" + } + if dbItemExt.Bewertung.Valid { + itemExt.Bewertung = int(dbItemExt.Bewertung.Int64) + } else { + itemExt.Bewertung = 0 + } + if dbItemExt.Favorit.Valid { + itemExt.Favorit = dbItemExt.Favorit.Bool + } else { + itemExt.Favorit = false + } + if dbItemExt.ItemB.Bezeichnung.Valid { + itemExt.ItemB.Bezeichnung = dbItemExt.ItemB.Bezeichnung.String + } else { + itemExt.ItemB.Bezeichnung = "" + } + if dbItemExt.ItemB.Kurzbeschreibung.Valid { + itemExt.ItemB.Kurzbeschreibung = dbItemExt.ItemB.Kurzbeschreibung.String + } else { + itemExt.ItemB.Kurzbeschreibung = "" + } + if dbItemExt.ItemB.Groesse.Valid { + itemExt.ItemB.Groesse = dbItemExt.ItemB.Groesse.String + } else { + itemExt.ItemB.Groesse = "" + } + if dbItemExt.ItemB.Farbe.Valid { + itemExt.ItemB.Farbe = dbItemExt.ItemB.Farbe.String + } else { + itemExt.ItemB.Farbe = "" + } + if dbItemExt.ItemB.Material.Valid { + itemExt.ItemB.Material = dbItemExt.ItemB.Material.String + } else { + itemExt.ItemB.Material = "" + } + if dbItemExt.ItemB.Abmessungen.Brust.Valid { + itemExt.ItemB.Abmessungen.Brust = dbItemExt.ItemB.Abmessungen.Brust.Float64 + } else { + itemExt.ItemB.Abmessungen.Brust = 0 + } + if dbItemExt.ItemB.Abmessungen.LaengeT.Valid { + itemExt.ItemB.Abmessungen.LaengeT = dbItemExt.ItemB.Abmessungen.LaengeT.Float64 + } else { + itemExt.ItemB.Abmessungen.LaengeT = 0 + } + if dbItemExt.ItemB.Abmessungen.Schulterbreite.Valid { + itemExt.ItemB.Abmessungen.Schulterbreite = dbItemExt.ItemB.Abmessungen.Schulterbreite.Float64 + } else { + itemExt.ItemB.Abmessungen.Schulterbreite = 0 + } + if dbItemExt.ItemB.Abmessungen.TaillenumfangT.Valid { + itemExt.ItemB.Abmessungen.TaillenumfangT = dbItemExt.ItemB.Abmessungen.TaillenumfangT.Float64 + } else { + itemExt.ItemB.Abmessungen.TaillenumfangT = 0 + } + if dbItemExt.ItemB.Abmessungen.Hueftumfang.Valid { + itemExt.ItemB.Abmessungen.Hueftumfang = dbItemExt.ItemB.Abmessungen.Hueftumfang.Float64 + } else { + itemExt.ItemB.Abmessungen.Hueftumfang = 0 + } + if dbItemExt.ItemB.Abmessungen.LaengeB.Valid { + itemExt.ItemB.Abmessungen.LaengeB = dbItemExt.ItemB.Abmessungen.LaengeB.Float64 + } else { + itemExt.ItemB.Abmessungen.LaengeB = 0 + } + if dbItemExt.ItemB.Abmessungen.TaillenumfangB.Valid { + itemExt.ItemB.Abmessungen.TaillenumfangB = dbItemExt.ItemB.Abmessungen.TaillenumfangB.Float64 + } else { + itemExt.ItemB.Abmessungen.TaillenumfangB = 0 + } + if dbItemExt.ItemB.Abmessungen.Kurz.Valid { + itemExt.ItemB.Abmessungen.Kurz = dbItemExt.ItemB.Abmessungen.Kurz.String + } else { + itemExt.ItemB.Abmessungen.Kurz = "" + } + if dbItemExt.Frontview.ItembId.Valid { + itemExt.Frontview.ItembId = uint64(dbItemExt.Frontview.ItembId.Int64) + } else { + itemExt.Frontview.ItembId = 0 + } + if dbItemExt.Frontview.ItemextId.Valid { + itemExt.Frontview.ItemextId = uint64(dbItemExt.Frontview.ItemextId.Int64) + } else { + itemExt.Frontview.ItemextId = 0 + } + + } + return itemExt, err +} + +func UpdateItemExt(itemExt ItemExt) (resItemExt ItemExt, err error) { + conn, err := sql.Open(dbType, dbConnection) + if err != nil { + log.Println("Error while connecting DB: ", err) + } + log.Println("Verbindung hergestellt (ItemExt UPDATE)") + log.Println("ID = ", itemExt.Id) + defer conn.Close() + _, err = conn.Exec("UPDATE itemext SET zuhause=?, draussen=?, genehmigt=?, bemerkung=?, bewertung=?, favorit=?, itembid=?, frontviewid=? WHERE id=?", itemExt.Zuhause, itemExt.Draussen, itemExt.Genehmigt, itemExt.Bemerkung, itemExt.Bewertung, itemExt.Favorit, itemExt.ItemB.Id, itemExt.Frontview.Id, itemExt.Id) + if err != nil { + log.Println("Error while executing insert statement", err) + } + resItemExt = itemExt + return resItemExt, err +}