g.spar
/
rtcusertr
2
0
Fork 0
Code Issues Pull Requests Projects Releases 5 Wiki Activity
Browse Source

Version 0.0.2

master v0.0.2
Georg Spar 2 years ago
parent
44c421983d
commit
c8fb0de2a9
5 changed files with 66 additions and 364 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 360
      database/database.go
  2. 18
      go.mod
  3. 4
      go.sum
  4. 48
      rtcusertr.go
  5. 0
      rtcusertr.log

360
database/database.go
Unescape View File

@ -2,12 +2,10 @@ package database
import ( import (
"database/sql" "database/sql"
"fmt"
"log" "log"
"AUDIAG/rtcusertr/domain" "gitlab.dedyn.io/AUDIAG/rtcusertr/domain"
//"domain.go"
_ "github.com/go-sql-driver/mysql" _ "github.com/go-sql-driver/mysql"
) )
@ -17,27 +15,27 @@ var (
) )
// Tool Funktionen // Tool Funktionen
func CreateTool(tool domain.Tools) (resTool domain.Tools, err error) { func CreateKnoten(knoten domain.KnotenE) (resKnoten domain.KnotenE, err error) {
conn, err := sql.Open(dbType, dbConnection) conn, err := sql.Open(dbType, dbConnection)
if err != nil { if err != nil {
log.Println("Error while connecting DB: ", err) log.Println("Error while connecting DB: ", err)
} }
log.Println("Verbindung hergestellt") log.Println("Verbindung hergestellt")
log.Println("Name = ", tool.Name) log.Println("Name = ", knoten.Fachbereich)
defer conn.Close() defer conn.Close()
res, err := conn.Exec("INSERT INTO tools VALUES(?,?)", tool.Id, tool.Name) res, err := conn.Exec("INSERT INTO knoten VALUES(?,?,?,?)", knoten.Id, knoten.Fachbereich, knoten.Anzahl, knoten.Tag)
if err != nil { if err != nil {
log.Println("Error while executing insert statement", err) log.Println("Error while executing insert statement", err)
} }
lastId, err := res.LastInsertId() lastId, err := res.LastInsertId()
tool.Id = uint(lastId) knoten.Id = uint(lastId)
resTool = tool resKnoten = knoten
return resTool, err return resKnoten, err
} }
func DeleteTool(toolId uint) (result, err error) { func DeleteKnoten(knotenId uint) (result, err error) {
conn, err := sql.Open(dbType, dbConnection) conn, err := sql.Open(dbType, dbConnection)
if err != nil { if err != nil {
log.Println("Error while connecting DB: ", err) log.Println("Error while connecting DB: ", err)
@ -45,14 +43,14 @@ func DeleteTool(toolId uint) (result, err error) {
log.Println("DB Verbindung hergestellt") log.Println("DB Verbindung hergestellt")
defer conn.Close() defer conn.Close()
_, err = conn.Exec("DELETE FROM tools WHERE id = ?", toolId) _, err = conn.Exec("DELETE FROM knoten WHERE id = ?", knotenId)
if err != nil { if err != nil {
log.Fatal("Error while executing DELETE statement", err) log.Fatal("Error while executing DELETE statement", err)
} }
return result, err return result, err
} }
func ShowTool() (toolsArray []domain.Tools, err error) { func ShowKnoten() (knotenArray []domain.KnotenE, err error) {
conn, err := sql.Open(dbType, dbConnection) conn, err := sql.Open(dbType, dbConnection)
if err != nil { if err != nil {
log.Println("Error while connecting DB: ", err) log.Println("Error while connecting DB: ", err)
@ -60,23 +58,23 @@ func ShowTool() (toolsArray []domain.Tools, err error) {
log.Println("DB Verbindung hergestellt") log.Println("DB Verbindung hergestellt")
defer conn.Close() defer conn.Close()
results, err := conn.Query("SELECT * FROM tools") results, err := conn.Query("SELECT * FROM knoten")
if err != nil { if err != nil {
log.Fatal("Error while executing SELECt statement", err) log.Fatal("Error while executing SELECt statement", err)
} }
var tool domain.Tools var knoten domain.KnotenE
for results.Next() { for results.Next() {
err = results.Scan(&tool.Id, &tool.Name) err = results.Scan(&knoten.Id, &knoten.Fachbereich, &knoten.Anzahl, &knoten.Tag)
if err != nil { if err != nil {
log.Fatal("Error: ", err) log.Fatal("Error: ", err)
} }
toolsArray = append(toolsArray, tool) knotenArray = append(knotenArray, knoten)
} }
return toolsArray, err return knotenArray, err
} }
func GetTool(id uint) (tool domain.Tools, err error) { func GetKnoten(id uint) (knoten domain.KnotenE, err error) {
conn, err := sql.Open(dbType, dbConnection) conn, err := sql.Open(dbType, dbConnection)
if err != nil { if err != nil {
log.Println("Error while connecting DB: ", err) log.Println("Error while connecting DB: ", err)
@ -84,345 +82,35 @@ func GetTool(id uint) (tool domain.Tools, err error) {
log.Println("DB Verbindung hergestellt") log.Println("DB Verbindung hergestellt")
defer conn.Close() defer conn.Close()
results, err := conn.Query("SELECT * FROM tools WHERE id=?", id) results, err := conn.Query("SELECT * FROM knoten WHERE id=?", id)
if err != nil { if err != nil {
log.Fatal("Error while executing SELECt statement", err) log.Fatal("Error while executing SELECt statement", err)
} }
for results.Next() { for results.Next() {
err = results.Scan(&tool.Id, &tool.Name) err = results.Scan(&knoten.Id, &knoten.Fachbereich, &knoten.Anzahl, &knoten.Tag)
if err != nil { if err != nil {
log.Fatal("Error: ", err) log.Fatal("Error: ", err)
} }
} }
return tool, err return knoten, err
} }
func UpdateTool(tool domain.Tools) (resTool domain.Tools, err error) { func UpdateKnoten(knoten domain.KnotenE) (resKnoten domain.KnotenE, err error) {
conn, err := sql.Open(dbType, dbConnection) conn, err := sql.Open(dbType, dbConnection)
if err != nil { if err != nil {
log.Println("Error while connecting DB: ", err) log.Println("Error while connecting DB: ", err)
} }
log.Println("Verbindung hergestellt") log.Println("Verbindung hergestellt")
log.Println("Name = ", tool.Name) log.Println("Name = ", knoten.Fachbereich)
defer conn.Close() defer conn.Close()
_, err = conn.Exec("UPDATE tools SET name=? WHERE id=?", tool.Name, tool.Id) _, err = conn.Exec("UPDATE knoten SET fachbereich=?, anzahl=?, tag=? WHERE id=?", knoten.Fachbereich, knoten.Anzahl, knoten.Tag, knoten.Id)
if err != nil { if err != nil {
log.Println("Error while executing insert statement", err) log.Println("Error while executing insert statement", err)
} }
resTool = tool resKnoten = knoten
return resTool, err return resKnoten, err
}
// ZTyp Funktionen
func CreateZTyp(ztyp domain.ZTyp) (resZTyp domain.ZTyp, 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 = ", ztyp.Name)
defer conn.Close()
res, err := conn.Exec("INSERT INTO ztyp VALUES(?,?,?)", ztyp.Id, ztyp.Name, ztyp.Laufzeit)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
ztyp.Id = uint(lastId)
resZTyp = ztyp
return resZTyp, err
}
func DeleteZTyp(ztypId 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")
defer conn.Close()
_, err = conn.Exec("DELETE FROM ztyp WHERE id = ?", ztypId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowZTyp() (ztypArray []domain.ZTyp, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM ztyp")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var ztyp domain.ZTyp
for results.Next() {
err = results.Scan(&ztyp.Id, &ztyp.Name, &ztyp.Laufzeit)
if err != nil {
log.Fatal("Error: ", err)
}
ztypArray = append(ztypArray, ztyp)
}
return ztypArray, err
}
func GetZTyp(id uint) (ztyp domain.ZTyp, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM ztyp WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
defer results.Close()
for results.Next() {
err = results.Scan(&ztyp.Id, &ztyp.Name, &ztyp.Laufzeit)
if err != nil {
if err == sql.ErrNoRows {
log.Println("No result found with this ID ", err)
return ztyp, fmt.Errorf("GetZTyp %d: no such ID", id)
}
log.Fatal("Error: ", err)
}
}
err = results.Err()
return ztyp, err
}
func UpdateZTyp(ztyp domain.ZTyp) (resZTyp domain.ZTyp, 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 = ", ztyp.Name)
defer conn.Close()
_, err = conn.Exec("UPDATE ztyp SET name=?, laufzeit=? WHERE id=?", ztyp.Name, ztyp.Laufzeit, ztyp.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resZTyp = ztyp
return resZTyp, err
}
// Ablageort Funktionen
func CreateAblOrt(ablort domain.AblageOrt) (resAblOrt domain.AblageOrt, 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 = ", ablort.Name)
defer conn.Close()
res, err := conn.Exec("INSERT INTO ablageort VALUES(?,?,?,?)", ablort.Id, ablort.Name, ablort.Url, ablort.Pfad)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
ablort.Id = uint(lastId)
resAblOrt = ablort
return resAblOrt, err
}
func DeleteAblOrt(ablortId 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")
defer conn.Close()
_, err = conn.Exec("DELETE FROM ablageort WHERE id = ?", ablortId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowAblOrt() (ablortArray []domain.AblageOrt, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM ablageort")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var ablort domain.AblageOrt
for results.Next() {
err = results.Scan(&ablort.Id, &ablort.Name, &ablort.Url, &ablort.Pfad)
if err != nil {
log.Fatal("Error: ", err)
}
ablortArray = append(ablortArray, ablort)
}
return ablortArray, err
}
func GetAblOrt(id uint) (ablort domain.AblageOrt, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM ablageort WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
for results.Next() {
err = results.Scan(&ablort.Id, &ablort.Name, &ablort.Url, &ablort.Pfad)
if err != nil {
log.Fatal("Error: ", err)
}
}
return ablort, err
}
func UpdateAblOrt(ablort domain.AblageOrt) (resAblOrt domain.AblageOrt, 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 = ", ablort.Name)
defer conn.Close()
_, err = conn.Exec("UPDATE ablageort SET name=?, url=?, pfad=? WHERE id=?", ablort.Name, ablort.Url, ablort.Pfad, ablort.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resAblOrt = ablort
return resAblOrt, err
}
// Zertifikat Funktionen
func CreateZert(zert domain.Zertifikat) (resZert domain.Zertifikat, 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 = ", zert.Name)
log.Println("Erstellungsdatum = ", zert.ErstellDat)
log.Println("Typ = ", zert.Typ)
defer conn.Close()
res, err := conn.Exec("INSERT INTO zertifikat VALUES(?,?,?,?,?,?,?,?,?)", zert.Id, zert.Name, zert.Typ, zert.ErstellDat, zert.GueltigBis, zert.AblageOrt, zert.ErstelltMit, zert.Email, zert.Bemerkung)
if err != nil {
log.Println("Error while executing insert statement", err)
}
lastId, err := res.LastInsertId()
zert.Id = uint64(lastId)
resZert = zert
return resZert, err
}
func DeleteZert(zertId 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")
defer conn.Close()
_, err = conn.Exec("DELETE FROM zertifikat WHERE id = ?", zertId)
if err != nil {
log.Fatal("Error while executing DELETE statement", err)
}
return result, err
}
func ShowZert() (zertArray []domain.Zertifikat, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM zertifikat")
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
var zert domain.Zertifikat
for results.Next() {
err = results.Scan(&zert.Id, &zert.Name, &zert.Typ, &zert.ErstellDat, &zert.GueltigBis, &zert.AblageOrt, &zert.ErstelltMit, &zert.Email, &zert.Bemerkung)
if err != nil {
log.Fatal("Error: ", err)
}
zertArray = append(zertArray, zert)
}
return zertArray, err
}
func GetZert(id uint64) (zert domain.Zertifikat, err error) {
conn, err := sql.Open(dbType, dbConnection)
if err != nil {
log.Println("Error while connecting DB: ", err)
}
log.Println("DB Verbindung hergestellt")
defer conn.Close()
results, err := conn.Query("SELECT * FROM zertifikat WHERE id=?", id)
if err != nil {
log.Fatal("Error while executing SELECt statement", err)
}
for results.Next() {
err = results.Scan(&zert.Id, &zert.Name, &zert.Typ, &zert.ErstellDat, &zert.GueltigBis, &zert.AblageOrt, &zert.ErstelltMit, &zert.Email, &zert.Bemerkung)
if err != nil {
log.Fatal("Error: ", err)
}
}
return zert, err
}
func UpdateZert(zert domain.Zertifikat) (resZert domain.Zertifikat, 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 = ", zert.Name)
defer conn.Close()
_, err = conn.Exec("UPDATE zertifikat SET name=?, typ=?, erstellungsdatum=?, gueltigbis=?, ablageort=?, erstelltmit=?, email=?, bemerkung=? WHERE id=?", zert.Name, zert.Typ, zert.ErstellDat, zert.GueltigBis, zert.AblageOrt, zert.ErstelltMit, zert.Email, zert.Bemerkung, zert.Id)
if err != nil {
log.Println("Error while executing insert statement", err)
}
resZert = zert
return resZert, err
} }

18
go.mod
Unescape View File

@ -1,11 +1,19 @@
module rtcusertr.go module gitlab.dedyn.io/AUDIAG/rtcusertr/rtcusertr.go
go 1.18 go 1.18
require github.com/sirupsen/logrus v1.9.0 require (
github.com/gorilla/mux v1.8.0
github.com/sirupsen/logrus v1.9.0
gitlab.dedyn.io/AUDIAG/rtcusertr/database v0.0.0-00010101000000-000000000000
gitlab.dedyn.io/AUDIAG/rtcusertr/domain v0.0.0-00010101000000-000000000000
)
require golang.org/x/sys v0.0.0-20220817070843-5a390386f1f2 // indirect require (
github.com/go-sql-driver/mysql v1.6.0 // indirect
golang.org/x/sys v0.0.0-20220817070843-5a390386f1f2 // indirect
)
replace AUDIAG/rtcusertr/database => ./database replace gitlab.dedyn.io/AUDIAG/rtcusertr/database => ./database
replace AUDIAG/rtcusertr/domain => ./domain replace gitlab.dedyn.io/AUDIAG/rtcusertr/domain => ./domain

4
go.sum
Unescape View File

@ -1,6 +1,10 @@
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=

48
rtcusertr.go
Unescape View File

@ -1,15 +1,17 @@
package main package main
import ( import (
"AUDIAG/rtcusertr/database"
"AUDIAG/rtcusertr/domain"
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log"
"net/http" "net/http"
"os" "os"
"strconv" "strconv"
"gitlab.dedyn.io/AUDIAG/rtcusertr/database"
"gitlab.dedyn.io/AUDIAG/rtcusertr/domain"
"github.com/gorilla/mux" "github.com/gorilla/mux"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
) )
@ -64,7 +66,7 @@ func createKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
json.Unmarshal(body, &knoten) json.Unmarshal(body, &knoten)
logrus.Println("Name= ", knoten.Fachbereich) logrus.Println("Name= ", knoten.Fachbereich)
logrus.Info("creating new Knoten-Eintrag", knoten.Fachbereich) logrus.Info("creating new Knoten-Eintrag", knoten.Fachbereich)
res, err := database.CreateTool(knoten) res, err := database.CreateKnoten(knoten)
if err != nil { if err != nil {
writer.WriteHeader(http.StatusInternalServerError) writer.WriteHeader(http.StatusInternalServerError)
} }
@ -81,34 +83,34 @@ func createKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
writer.Write(b) writer.Write(b)
} }
func deleteToolsHandler(writer http.ResponseWriter, req *http.Request) { func deleteKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*") writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions { if req.Method == http.MethodOptions {
return return
} }
toolsId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) knotenId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
log.Info("Deleting tool with ID", toolsId) logrus.Info("Deleting tool with ID", knotenId)
_, err := database.DeleteTool(uint(toolsId)) _, err := database.DeleteKnoten(uint(knotenId))
if err != nil { if err != nil {
log.Fatal("Error: Delete could not be executed", err) logrus.Fatal("Error: Delete could not be executed", err)
} }
writer.WriteHeader(http.StatusNoContent) writer.WriteHeader(http.StatusNoContent)
} }
func showToolsHandler(writer http.ResponseWriter, req *http.Request) { func showKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*") writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions { if req.Method == http.MethodOptions {
return return
} }
res, err := database.ShowTool() res, err := database.ShowKnoten()
if err != nil { if err != nil {
log.Fatal("Error: Tool can't be shown ", err) logrus.Fatal("Error: Knoteneintrag can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError) writer.WriteHeader(http.StatusInternalServerError)
} }
b, err := json.Marshal(res) b, err := json.Marshal(res)
if err != nil { if err != nil {
log.Fatal("Error: ", err) logrus.Fatal("Error: ", err)
} }
location := req.URL.String() location := req.URL.String()
@ -118,21 +120,21 @@ func showToolsHandler(writer http.ResponseWriter, req *http.Request) {
writer.Write(b) writer.Write(b)
} }
func getToolsHandler(writer http.ResponseWriter, req *http.Request) { func getKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*") writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions { if req.Method == http.MethodOptions {
return return
} }
toolId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0) knotenId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
res, err := database.GetTool(uint(toolId)) res, err := database.GetKnoten(uint(knotenId))
if err != nil { if err != nil {
log.Fatal("Error: Tool can't be shown ", err) logrus.Fatal("Error: Knoteneintrag can't be shown ", err)
writer.WriteHeader(http.StatusInternalServerError) writer.WriteHeader(http.StatusInternalServerError)
} }
b, err := json.Marshal(res) b, err := json.Marshal(res)
if err != nil { if err != nil {
log.Fatal("Error: ", err) logrus.Fatal("Error: ", err)
} }
location := req.URL.String() location := req.URL.String()
@ -142,7 +144,7 @@ func getToolsHandler(writer http.ResponseWriter, req *http.Request) {
writer.Write(b) writer.Write(b)
} }
func updateToolsHandler(writer http.ResponseWriter, req *http.Request) { func updateKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
writer.Header().Set("Access-Control-Allow-Origin", "*") writer.Header().Set("Access-Control-Allow-Origin", "*")
if req.Method == http.MethodOptions { if req.Method == http.MethodOptions {
return return
@ -151,11 +153,11 @@ func updateToolsHandler(writer http.ResponseWriter, req *http.Request) {
if err != nil { if err != nil {
writer.WriteHeader(http.StatusBadRequest) writer.WriteHeader(http.StatusBadRequest)
} }
var tool domain.Tools var knoten domain.KnotenE
json.Unmarshal(body, &tool) json.Unmarshal(body, &knoten)
log.Println("Name = ", tool.Name) logrus.Println("Name = ", knoten.Fachbereich)
log.Info("updating Tool", tool.Name) logrus.Info("updating Knoteneintrag", knoten.Fachbereich)
res, err := database.UpdateTool(tool) res, err := database.UpdateKnoten(knoten)
if err != nil { if err != nil {
writer.WriteHeader(http.StatusInternalServerError) writer.WriteHeader(http.StatusInternalServerError)
} }

0
rtcusertr.log
Unescape View File

Write Preview
Loading…
Cancel
Save