package main

import (
	"database/sql"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

var (
	dbConnection = "wdmdbuser:wdmdbpass@tcp(localhost:3306)/wdmdb"
	dbType       = "mysql"
)

// Tool Funktionen
func CreateTyp(typ Typ) (resTyp Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("Verbindung hergestellt")
	log.Println("Name = ", typ.Bezeichnung)
	defer conn.Close()
	res, err := conn.Exec("INSERT INTO typ VALUES(?,?)", typ.Id, typ.Bezeichnung)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	lastId, err := res.LastInsertId()
	typ.Id = uint(lastId)
	resTyp = typ
	return resTyp, err
}

func DeleteTyp(typId uint) (result, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (DELETE)")
	defer conn.Close()
	_, err = conn.Exec("DELETE FROM typ WHERE id = ?", typId)
	if err != nil {
		log.Fatal("Error while executing DELETE statement", err)
	}
	return result, err
}

func ShowTyp() (typArray []Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (SHOW)")
	defer conn.Close()
	results, err := conn.Query("SELECT * FROM typ")
	if err != nil {
		log.Fatal("Error while executing SELECt statement", err)
	}
	var typ Typ
	for results.Next() {
		err = results.Scan(&typ.Id, &typ.Bezeichnung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
		typArray = append(typArray, typ)
	}
	return typArray, err
}

func GetTyp(id uint) (typ Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	log.Println("DB Verbindung hergestellt (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(&typ.Id, &typ.Bezeichnung)
		if err != nil {
			log.Fatal("Error: ", err)
		}
	}
	return typ, err
}

func UpdateTyp(typ Typ) (resTyp Typ, err error) {
	conn, err := sql.Open(dbType, dbConnection)
	if err != nil {
		log.Println("Error while connecting DB: ", err)
	}
	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)
	if err != nil {
		log.Println("Error while executing insert statement", err)
	}
	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
}