g.spar
/
wardrobemaster
1
0
Fork 0
Code Issues Pull Requests Projects Releases 3 Wiki Activity
Browse Source

v0.1.0: photo, itb, mea integriert, kurz zu mea

pull/1/head
Georg Spar 1 year ago
parent
067d72a4cc
commit
81c15b69c9
3 changed files with 766 additions and 15 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      data.go
  2. 490
      wdm.go
  3. 274
      wdmdb.go

17
data.go
Unescape View File

@ -29,14 +29,15 @@ type Typ struct {
// struct für die Groessenangaben der Kleidungsstücke
type Measure struct {
Id uint64 `json:"id"`
Brust float32 `json:"brust"`
LaengeT float32 `json:"laenget"`
Schulterbreite float32 `json:"schulterbreite"`
TaillenumfangT float32 `json:"taillenumfangt"`
Hueftumfang float32 `json:"hueftumfang"`
Innennaht float32 `json:"innennaht"`
LaengeB float32 `json:"laengeb"`
TaillenumfangB float32 `json:"taillenumfangb"`
Kurz string `json:"kurz"`
Brust float64 `json:"brust"`
LaengeT float64 `json:"laenget"`
Schulterbreite float64 `json:"schulterbreite"`
TaillenumfangT float64 `json:"taillenumfangt"`
Hueftumfang float64 `json:"hueftumfang"`
Innennaht float64 `json:"innennaht"`
LaengeB float64 `json:"laengeb"`
TaillenumfangB float64 `json:"taillenumfangb"`
}
// struct für die Erweiterung des Items für die Benutzung

490
wdm.go
Unescape View File

@ -35,7 +35,7 @@ func main() {
r.HandleFunc("/api/v1/typ/{id:[0-9]+}", getTypHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/typ/{id:[0-9]+}", updateTypHandler).Methods("PUT", "OPTIONS")
/* r.HandleFunc("/api/v1/pho", createPhotoHandler).Methods("POST", "OPTIONS")
r.HandleFunc("/api/v1/pho", createPhotoHandler).Methods("POST", "OPTIONS")
r.HandleFunc("/api/v1/pho/{id:[0-9]+}", deletePhotoHandler).Methods("DELETE", "OPTIONS")
r.HandleFunc("/api/v1/pho", showPhotoHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/pho/{id:[0-9]+}", getPhotoHandler).Methods("GET", "OPTIONS")
@ -52,12 +52,12 @@ func main() {
r.HandleFunc("/api/v1/itb", showItemBHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/itb/{id:[0-9]+}", getItemBHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/itb/{id:[0-9]+}", updateItemBHandler).Methods("PUT", "OPTIONS")
r.HandleFunc("/api/v1/ite", createItemExtHandler).Methods("POST", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", deleteItemExtHandler).Methods("DELETE", "OPTIONS")
r.HandleFunc("/api/v1/ite", showItemExtHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", getItemExtHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", updateItemExtHandler).Methods("PUT", "OPTIONS") */
/*
r.HandleFunc("/api/v1/ite", createItemExtHandler).Methods("POST", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", deleteItemExtHandler).Methods("DELETE", "OPTIONS")
r.HandleFunc("/api/v1/ite", showItemExtHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", getItemExtHandler).Methods("GET", "OPTIONS")
r.HandleFunc("/api/v1/ite/{id:[0-9]+}", updateItemExtHandler).Methods("PUT", "OPTIONS") */
http.Handle("/", r)
r.Use(mux.CORSMethodMiddleware(r))
@ -200,3 +200,479 @@ func updateTypHandler(writer http.ResponseWriter, req *http.Request) {
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
// Photo Funktionen
func createPhotoHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
var pho Photos
if req.Form["pfad"] != nil {
pho.ItembId, _ = strconv.ParseUint(req.FormValue("itembid"), 10, 0)
pho.ItemextId, _ = strconv.ParseUint(req.FormValue("itemextid"), 10, 0)
pho.Pfad = req.FormValue("pfad")
for formKey, formValue := range req.Form {
log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ")
}
} else {
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var pho Photos
json.Unmarshal(body, &pho)
}
log.Println(pho)
log.Println("Name= ", pho.Pfad)
log.Info("creating new Photo", pho.Pfad)
res, err := CreatePhoto(pho)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusCreated)
writer.Write(b)
}
func deletePhotoHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
phoId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
log.Info("Deleting Photo with ID", phoId)
_, err = DeletePhoto(uint64(phoId))
if err != nil {
log.Fatal("Error: Delete could not be executed", err)
}
writer.WriteHeader(http.StatusNoContent)
}
func showPhotoHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
res, err := ShowPhoto()
if err != nil {
log.Fatal("Error: Photos can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func getPhotoHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
phoId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
res, err := GetPhoto(uint64(phoId))
if err != nil {
log.Fatal("Error: Typ can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func updatePhotoHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var pho Photos
json.Unmarshal(body, &pho)
log.Println("Name = ", pho.Pfad)
log.Info("updating Photo", pho.Pfad)
res, err := UpdatePhoto(pho)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
// Measure Funktionen
func createMeasureHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
var mea Measure
if req.Form["kurz"] != nil {
mea.Kurz = req.FormValue("kurz")
mea.Brust, _ = strconv.ParseFloat(req.FormValue("brust"), 64)
mea.LaengeT, _ = strconv.ParseFloat(req.FormValue("laenget"), 64)
mea.Schulterbreite, _ = strconv.ParseFloat(req.FormValue("schulterbreite"), 64)
mea.TaillenumfangT, _ = strconv.ParseFloat(req.FormValue("taillenumfangt"), 64)
mea.Hueftumfang, _ = strconv.ParseFloat(req.FormValue("hueftumfang"), 64)
mea.Innennaht, _ = strconv.ParseFloat(req.FormValue("innennaht"), 64)
mea.LaengeB, _ = strconv.ParseFloat(req.FormValue("laengeb"), 64)
mea.TaillenumfangB, _ = strconv.ParseFloat(req.FormValue("taillenumfangb"), 64)
for formKey, formValue := range req.Form {
log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ")
}
} else {
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var mea Measure
json.Unmarshal(body, &mea)
}
log.Println(mea)
log.Println("Name= ", mea.Kurz)
log.Info("creating new Measure", mea.Kurz)
res, err := CreateMeasure(mea)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusCreated)
writer.Write(b)
}
func deleteMeasureHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
meaId, _ := strconv.ParseUint(req.FormValue("id"), 10, 0)
log.Info("Deleting Measure with ID", meaId)
_, err = DeleteMeasure(uint64(meaId))
if err != nil {
log.Fatal("Error: Delete could not be executed", err)
}
writer.WriteHeader(http.StatusNoContent)
}
func showMeasureHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
res, err := ShowMeasure()
if err != nil {
log.Fatal("Error: Measure can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func getMeasureHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
meaId, _ := strconv.ParseUint(req.FormValue("id"), 10, 0)
res, err := GetMeasure(uint64(meaId))
if err != nil {
log.Fatal("Error: Measure can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func updateMeasureHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
var mea Measure
if req.Form["kurz"] != nil {
mea.Kurz = req.FormValue("kurz")
mea.Brust, _ = strconv.ParseFloat(req.FormValue("brust"), 64)
mea.LaengeT, _ = strconv.ParseFloat(req.FormValue("laenget"), 64)
mea.Schulterbreite, _ = strconv.ParseFloat(req.FormValue("schulterbreite"), 64)
mea.TaillenumfangT, _ = strconv.ParseFloat(req.FormValue("taillenumfangt"), 64)
mea.Hueftumfang, _ = strconv.ParseFloat(req.FormValue("hueftumfang"), 64)
mea.Innennaht, _ = strconv.ParseFloat(req.FormValue("innennaht"), 64)
mea.LaengeB, _ = strconv.ParseFloat(req.FormValue("laengeb"), 64)
mea.TaillenumfangB, _ = strconv.ParseFloat(req.FormValue("taillenumfangb"), 64)
for formKey, formValue := range req.Form {
log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ")
}
} else {
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var mea Measure
json.Unmarshal(body, &mea)
}
log.Println("Name = ", mea.Kurz)
log.Info("updating Measure", mea.Kurz)
res, err := UpdateMeasure(mea)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
// ItemsB Funktionen
func createItemBHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
var itemB Itemb
if req.Form["bezeichnung"] != nil {
itemB.Bezeichnung = req.FormValue("bezeichnung")
itemB.Kurzbeschreibung = req.FormValue("kurzbeschreibung")
itemB.Material = req.FormValue("material")
itemB.Groesse = req.FormValue("groesse")
itemB.Farbe = req.FormValue("farbe")
itbtyp, _ := strconv.ParseUint(req.FormValue("typid"), 10, 0)
itemB.TypId = uint(itbtyp)
itemB.AbmessungenId, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0)
for formKey, formValue := range req.Form {
log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ")
}
} else {
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var itemB Itemb
json.Unmarshal(body, &itemB)
}
log.Println(itemB)
log.Println("Name= ", itemB.Bezeichnung)
log.Info("creating new Typ", itemB.Bezeichnung)
res, err := CreateItemB(itemB)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusCreated)
writer.Write(b)
}
func deleteItemBHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
itemBId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
log.Info("Deleting Typ with ID", itemBId)
_, err = DeleteItemB(uint64(itemBId))
if err != nil {
log.Fatal("Error: Delete could not be executed", err)
}
writer.WriteHeader(http.StatusNoContent)
}
func showItemBHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
res, err := ShowItemB()
if err != nil {
log.Fatal("Error: Typ can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func getItemBHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
itemBId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
res, err := GetItemB(uint64(itemBId))
if err != nil {
log.Fatal("Error: Typ can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := req.URL.String()
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}
func updateItemBHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions {
return
}
err := req.ParseMultipartForm(64 << 20)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
return
}
var itemB Itemb
if req.Form["bezeichnung"] != nil {
itemB.Bezeichnung = req.FormValue("bezeichnung")
itemB.Kurzbeschreibung = req.FormValue("kurzbeschreibung")
itemB.Material = req.FormValue("material")
itemB.Groesse = req.FormValue("groesse")
itemB.Farbe = req.FormValue("farbe")
itbtyp, _ := strconv.ParseUint(req.FormValue("typid"), 10, 0)
itemB.TypId = uint(itbtyp)
itemB.AbmessungenId, _ = strconv.ParseUint(req.FormValue("abmessungenid"), 10, 0)
for formKey, formValue := range req.Form {
log.WithFields(log.Fields{formKey: formValue}).Info("parsing from Form: ")
}
} else {
body, err := io.ReadAll(req.Body)
if err != nil {
writer.WriteHeader(http.StatusBadRequest)
}
var itemB Itemb
json.Unmarshal(body, &itemB)
}
log.Println("Name = ", itemB.Bezeichnung)
log.Info("updating Typ", itemB.Bezeichnung)
res, err := UpdateItemB(itemB)
if err != nil {
writer.WriteHeader(http.StatusInternalServerError)
}
b, err := json.Marshal(res)
if err != nil {
log.Fatal("Error: ", err)
}
location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
writer.Header().Set("Location:", location)
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
writer.Write(b)
}

274
wdmdb.go
Unescape View File

@ -102,3 +102,277 @@ func UpdateTyp(typ Typ) (resTyp Typ, err error) {
resTyp = typ
return resTyp, err
}
// Photo Funktionen
func CreatePhoto(pho Photos) (resPhoto Photos, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (Photo CREATE)")
log.Println("Name = ", pho.Pfad)
defer conn.Close()
res, err := conn.Exec("INSERT INTO photo VALUES(?,?,?,?)", pho.Id, pho.Pfad, pho.ItembId, pho.ItemextId)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
pho.Id = uint64(lastId)
resPhoto = pho
return resPhoto, err
}
func DeletePhoto(phoId uint64) (result, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Photo DELETE)")
defer conn.Close()
_, err = conn.Exec("DELETE FROM photo WHERE id = ?", phoId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowPhoto() (phoArray []Photos, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Photo SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM photos")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var pho Photos
for results.Next() {
err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId)
if err != nil {
log.Fatal("Error: ", err)
}
phoArray = append(phoArray, pho)
}
return phoArray, err
}
func GetPhoto(id uint64) (pho Photos, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Photo SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM typ WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
for results.Next() {
err = results.Scan(&pho.Id, &pho.Pfad, &pho.ItembId, &pho.ItemextId)
if err != nil {
log.Fatal("Error: ", err)
}
}
return pho, err
}
func UpdatePhoto(pho Photos) (resPho Photos, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (Photo UPDATE)")
log.Println("Name = ", pho.Pfad)
defer conn.Close()
_, err = conn.Exec("UPDATE photos SET pfad=?, itembid=?, itemextid=? WHERE id=?", pho.Pfad, pho.ItembId, pho.ItemextId, pho.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resPho = pho
return resPho, err
}
// Measure Funktionen
func CreateMeasure(mea Measure) (resMea Measure, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (Measure INSERT)")
log.Println("Name = ", mea.Kurz)
defer conn.Close()
res, err := conn.Exec("INSERT INTO measure VALUES(?,?,?,?,?,?,?,?,?,?)", mea.Id, mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
mea.Id = uint64(lastId)
resMea = mea
return resMea, err
}
func DeleteMeasure(meaId uint64) (result, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Measure DELETE)")
defer conn.Close()
_, err = conn.Exec("DELETE FROM measure WHERE id = ?", meaId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowMeasure() (meaArray []Measure, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Measure SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM measure")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var mea Measure
for results.Next() {
err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz)
if err != nil {
log.Fatal("Error: ", err)
}
meaArray = append(meaArray, mea)
}
return meaArray, err
}
func GetMeasure(id uint64) (mea Measure, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (Measure SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM mea WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
for results.Next() {
err = results.Scan(&mea.Id, &mea.Brust, &mea.LaengeT, &mea.Schulterbreite, &mea.TaillenumfangT, &mea.Hueftumfang, &mea.Innennaht, &mea.LaengeB, &mea.TaillenumfangT, &mea.Kurz)
if err != nil {
log.Fatal("Error: ", err)
}
}
return mea, err
}
func UpdateMeasure(mea Measure) (resMea Measure, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (Measure UPDATE)")
log.Println("Name = ", mea.Kurz)
defer conn.Close()
_, err = conn.Exec("UPDATE measure SET brust=?, laenget=?, schulterbreite=?, taillenumfangt=? hueftumfang=?, innennaht=?, laengeb=?, taillenumfangb=?, kurz=? WHERE id=?",
mea.Brust, mea.LaengeT, mea.Schulterbreite, mea.TaillenumfangT, mea.Hueftumfang, mea.Innennaht, mea.LaengeB, mea.TaillenumfangT, mea.Kurz, mea.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resMea = mea
return resMea, err
}
// ItemB Funktionen
func CreateItemB(itemB Itemb) (resItemb Itemb, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (ItemB Create)")
log.Println("Name = ", itemB.Bezeichnung)
defer conn.Close()
res, err := conn.Exec("INSERT INTO itemb VALUES(?,?,?,?,?,?,?,?)", itemB.Id, itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.TypId, itemB.Material, itemB.AbmessungenId)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
itemB.Id = uint64(lastId)
resItemb = itemB
return resItemb, err
}
func DeleteItemB(itemBId uint64) (result, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (ItemB DELETE)")
defer conn.Close()
_, err = conn.Exec("DELETE FROM itemb WHERE id = ?", itemBId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowItemB() (itemBArray []Itemb, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (ItemB SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM itemb")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var itemB Itemb
for results.Next() {
err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.TypId, &itemB.Material, &itemB.AbmessungenId)
if err != nil {
log.Fatal("Error: ", err)
}
itemBArray = append(itemBArray, itemB)
}
return itemBArray, err
}
func GetItemB(id uint64) (itemB Itemb, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt (ItemB SHOW)")
defer conn.Close()
results, err := conn.Query("SELECT * FROM itemb WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
for results.Next() {
err = results.Scan(&itemB.Id, &itemB.Bezeichnung, &itemB.Kurzbeschreibung, &itemB.Groesse, &itemB.Farbe, &itemB.TypId, &itemB.Material, &itemB.AbmessungenId)
if err != nil {
log.Fatal("Error: ", err)
}
}
return itemB, err
}
func UpdateItemB(itemB Itemb) (resItemb Itemb, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("Verbindung hergestellt (ItemB UPDATE)")
log.Println("Name = ", itemB.Bezeichnung)
defer conn.Close()
_, err = conn.Exec("UPDATE itemb SET bezeichnung=?, kurzbeschreibung=?, groesse=?, farbe=?, typid=?, material=?, abmessungenid=? WHERE id=?", itemB.Bezeichnung, itemB.Kurzbeschreibung, itemB.Groesse, itemB.Farbe, itemB.TypId, itemB.Material, itemB.AbmessungenId, itemB.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resItemb = itemB
return resItemb, err
}

Write Preview
Loading…
Cancel
Save