erster Wurf Itemext

data.go

@@ -88,10 +88,22 @@ 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 {

wdm.go

@@ -57,12 +57,11 @@ func main() {
 
 	r.HandleFunc("/api/v1/upload", uploadFileHandler).Methods("POST", "OPTIONS")
 
-	/*
+	r.HandleFunc("/api/v1/ite", createItemExtHandler).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/{id:[0-9]+}", deleteItemExtHandler).Methods("DELETE", "OPTIONS")
+	r.HandleFunc("/api/v1/ite", showItemExtHandler).Methods("GET", "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]+}", 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))
@@ -736,6 +735,175 @@ func updateItemBHandler(writer http.ResponseWriter, req *http.Request) {
 	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
+	}
+	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 showItemExtHandler(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 getItemExtHandler(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 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 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)
+}
+
 // Upload Funktionen
 func uploadFileHandler(writer http.ResponseWriter, req *http.Request) {
 	writer.Header().Set("Access-Control-Allow-Origin", "*")

wdmdb.go

@@ -481,3 +481,207 @@ func UpdateItemB(itemB Itemb) (resItemb Itemb, err error) {
 	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
+}