Merge pull request 'testbranch fürs Release' (#1) from testbranch into master

Reviewed-on: #1

Jenkinsfile

@@ -0,0 +1,12 @@
+pipeline {
+  agent any
+  tools { go 'gobabygo' }
+  stages {
+    stage('TuI') {
+      steps {
+        sh 'GOOS=linux GOARCH=arm64 go build -o wadrma .'
+      }
+    }
+
+  }
+}

data.go

@@ -1,5 +1,10 @@
 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"`
@@ -7,9 +12,21 @@ type Itemb struct {
 	Kurzbeschreibung string  `json:"kurzbeschreibung"`
 	Groesse          string  `json:"groesse"`
 	Farbe            string  `json:"farbe"`
-	TypId            uint   `json:"typid"`
+	Type             Typ     `json:"type"`
 	Material         string  `json:"material"`
-	AbmessungenId    uint64 `json:"abmessungenid"`
+	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"`
 }

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 /
+

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
 	}
+
+	err := req.ParseMultipartForm(64 << 20)
+	if err != nil {
+		writer.WriteHeader(http.StatusBadRequest)
+		return
+	}
+	var typ 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
 	}
+
+	err := req.ParseMultipartForm(64 << 20)
+	if err != nil {
+		writer.WriteHeader(http.StatusBadRequest)
+		return
+	}
+	var typ 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")
+	}
+
+}

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
+}