ZennDev1337/SpieleLaden-NoSQL
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

first commit

Browse source
This commit is contained in:
Zenny 2024-04-05 20:30:39 +02:00
parent 6f61c68c9b
commit e18e5a8227
9 changed files with 101 additions and 482 deletions
Download patch file Download diff file Expand all files Collapse all files

4
readme.md
View file

@ -2,6 +2,10 @@
Ein Schulprojekt für NoSql-Databases
```bash
podman run -d -p 27017:27017 --name mongodb -e MONGO_INITDB_ROOT_USERNAME=root -e MONGO_INITDB_ROOT_PASSWORD=root12345 mongo
```
## Voraussetzungen
Stellen Sie sicher, dass die folgenden Tools auf Ihrem System installiert sind:

17
src/main.go
View file

@ -16,18 +16,23 @@ func main() {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
var err error
var con_uri = os.Getenv("MONGO_URL")
if con_uri == "" {
con_uri = "mongodb://root:root12345@localhost:27017"
var conUri = os.Getenv("MONGO_URL")
if conUri == "" {
conUri = "mongodb://root:root12345@localhost:27017"
}
util.Client, err = mongo.Connect(ctx, options.Client().ApplyURI(con_uri))
util.Client, err = mongo.Connect(ctx, options.Client().ApplyURI(conUri))
if err != nil {
panic(err)
}
defer util.Client.Disconnect(ctx)
defer func(Client *mongo.Client, ctx context.Context) {
err := Client.Disconnect(ctx)
if err != nil {
}
}(util.Client, ctx)
r := GetRouter()
fmt.Println("Server is running on port 3000")
err = http.ListenAndServe(":3333", r)
err = http.ListenAndServe(":3000", r)
if err != nil {
log.Fatal(err)
}

24
src/router.go
View file

@ -7,29 +7,25 @@ import (
func GetRouter() *mux.Router {
r := mux.NewRouter()
// curl -X GET localhost:3000/spiele
r.HandleFunc("/spiele", router.GetSpiele).Methods("GET")
// curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID"}' -H "Content-Type: application/json" localhost:3000/spiele
r.HandleFunc("/spiele", router.DeleteSpiel).Methods("DELETE")
// curl -X GET localhost:3000/laeden
r.HandleFunc("/laeden", router.GetLaeden).Methods("GET")
// curl -X DELETE -d '{"laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/laeden
r.HandleFunc("/laeden", router.DeleteLaden).Methods("DELETE")
// curl -X POST localhost:3000/init
r.HandleFunc("/init", router.InitDatabase).Methods("GET")
// curl -X GET localhost:3000/spiele-mit-laeden
r.HandleFunc("/spiele-mit-laeden", router.GetSpieleMitLaeden).Methods("GET")
// curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID", "laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/spiele-mit-laeden
r.HandleFunc("/spiele-mit-laeden", router.DeleteLadenFromSpiel).Methods("DELETE")
// curl -X POST -d '{"spiel_id": "YOUR_SPIEL_ID", "neuer_laden_id": "YOUR_NEUER_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/spiele-mit-laeden
r.HandleFunc("/spiele-mit-laeden", router.AddNewLadenToSpiel).Methods("POST")
// curl -X POST -d '{"titel": "Neues Spiel", "erscheinungsdatum": "2024-04-05T00:00:00Z", "publisher": "Neuer Publisher", "genre": "Neues Genre", "plattform": "Neue Plattform", "bewertung": 9}' -H "Content-Type: application/json" localhost:3000/spiele
r.HandleFunc("/spiele", router.AddNewSpiel).Methods("POST")
// curl -X POST -d '{"name": "Neuer Laden", "adresse": "Neue Adresse", "telefonnummer": "123-456"}' -H "Content-Type: application/json" localhost:3000/laeden
r.HandleFunc("/laeden", router.AddNewLaden).Methods("POST")
//r.HandleFunc("/persons", router.CreatePerson).Methods("POST")
//r.HandleFunc("/persons/{id}", router.GetPerson).Methods("GET")
//r.HandleFunc("/persons", router.GetAllPersons).Methods("GET")
//r.HandleFunc("/personsWithDebts", router.GetPersonsWithDebts).Methods("GET")
//r.HandleFunc("/persons/{id}", router.UpdatePerson).Methods("PUT")
//r.HandleFunc("/persons/{id}", router.DeletePerson).Methods("DELETE")
//r.HandleFunc("/persons/{id}/debts", router.GetDebts).Methods("GET")
//r.HandleFunc("/persons/{id}/debts", router.CreateDebt).Methods("POST")
//r.HandleFunc("/debts/{id}", router.DeleteDebt).Methods("DELETE")
//r.HandleFunc("/debts", router.GetAllDebts).Methods("GET")
//r.HandleFunc("/debts/{id}", router.GetDebt).Methods("GET")
//r.HandleFunc("/debts/{id}", router.UpdateDebt).Methods("PUT")
//r.HandleFunc("/init", util.Init).Methods("GET")
//r.HandleFunc("/biginit", util.BigInit).Methods("GET")
return r
}

44
src/router/Laeden.go
View file

@ -6,13 +6,14 @@ import (
"gibb165lb2/util"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"log"
"math/rand"
"net/http"
"time"
)
// curl -X GET localhost:3000/laeden
// GetLaeden curl -X GET localhost:3000/laeden
func GetLaeden(w http.ResponseWriter, r *http.Request) {
// MongoDB-Datenbank und -Sammlung auswählen
db := util.Client.Database("meineDatenbank")
@ -24,7 +25,12 @@ func GetLaeden(w http.ResponseWriter, r *http.Request) {
if err != nil {
log.Fatal(err)
}
defer cursor.Close(context.Background())
defer func(cursor *mongo.Cursor, ctx context.Context) {
err := cursor.Close(ctx)
if err != nil {
}
}(cursor, context.Background())
for cursor.Next(context.Background()) {
var laden util.Spieleladen
if err := cursor.Decode(&laden); err != nil {
@ -38,10 +44,13 @@ func GetLaeden(w http.ResponseWriter, r *http.Request) {
// Läden als JSON zurücksenden
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(laeden)
if err := json.NewEncoder(w).Encode(laeden); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X POST localhost:3000/initDatabase
// InitDatabase curl -X POST localhost:3000/initDatabase
func InitDatabase(w http.ResponseWriter, r *http.Request) {
// MongoDB-Datenbank und -Sammlungen auswählen
db := util.Client.Database("meineDatenbank")
@ -78,7 +87,7 @@ func InitDatabase(w http.ResponseWriter, r *http.Request) {
var spieleWithLadenIDs []interface{}
for _, spiel := range spiele {
// Läden-IDs zum Spiel hinzufügen
ladenids := []primitive.ObjectID{}
var ladenids []primitive.ObjectID
randomIndex1 := rand.Intn(len(laedenIDs))
ladenids = append(ladenids, laedenIDs[randomIndex1])
var randomIndex2 int
@ -109,10 +118,13 @@ func InitDatabase(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusOK)
w.Write([]byte("Datenbank erfolgreich initialisiert"))
if _, err := w.Write([]byte("Datenbank erfolgreich initialisiert")); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X DELETE -d '{"laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/deleteLaden
// DeleteLaden curl -X DELETE -d '{"laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/deleteLaden
func DeleteLaden(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var requestData struct {
@ -144,15 +156,17 @@ func DeleteLaden(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusOK)
w.Write([]byte("Laden erfolgreich gelöscht"))
if _, err := w.Write([]byte("Laden erfolgreich gelöscht")); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X POST -d '{"name": "Neuer Laden", "adresse": "Neue Adresse", "telefonnummer": "123-456"}' -H "Content-Type: application/json" localhost:3000/addNewLaden
// AddNewLaden curl -X POST -d '{"name": "Neuer Laden", "adresse": "Neue Adresse", "telefonnummer": "123-456"}' -H "Content-Type: application/json" localhost:3000/addNewLaden
func AddNewLaden(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var newLaden util.Spieleladen
err := json.NewDecoder(r.Body).Decode(&newLaden)
if err != nil {
if err := json.NewDecoder(r.Body).Decode(&newLaden); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@ -162,13 +176,15 @@ func AddNewLaden(w http.ResponseWriter, r *http.Request) {
laedenCollection := db.Collection("spielelaeden")
// Neuen Laden in die Datenbank einfügen
_, err = laedenCollection.InsertOne(context.Background(), newLaden)
if err != nil {
if _, err := laedenCollection.InsertOne(context.Background(), newLaden); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// Erfolgsmeldung senden
w.WriteHeader(http.StatusCreated)
w.Write([]byte("Neuer Laden erfolgreich erstellt"))
if _, err := w.Write([]byte("Neuer Laden erfolgreich erstellt")); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}

60
src/router/Spiele.go
View file

@ -7,11 +7,12 @@ import (
"gibb165lb2/util"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"log"
"net/http"
)
// curl -X GET localhost:3000/spiele
// GetSpiele curl -X GET localhost:3000/spiele
func GetSpiele(w http.ResponseWriter, r *http.Request) {
// MongoDB-Datenbank und -Sammlung auswählen
db := util.Client.Database("meineDatenbank")
@ -23,7 +24,12 @@ func GetSpiele(w http.ResponseWriter, r *http.Request) {
if err != nil {
log.Fatal(err)
}
defer cursor.Close(context.Background())
defer func(cursor *mongo.Cursor, ctx context.Context) {
err := cursor.Close(ctx)
if err != nil {
}
}(cursor, context.Background())
for cursor.Next(context.Background()) {
var spiel util.Spiel
if err := cursor.Decode(&spiel); err != nil {
@ -37,10 +43,13 @@ func GetSpiele(w http.ResponseWriter, r *http.Request) {
// Spiele als JSON zurücksenden
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(spiele)
if err := json.NewEncoder(w).Encode(spiele); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
fmt.Println(err)
}
}
// curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID"}' -H "Content-Type: application/json" localhost:3000/deleteSpiel
// DeleteSpiel curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID"}' -H "Content-Type: application/json" localhost:3000/deleteSpiel
func DeleteSpiel(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var requestData struct {
@ -72,10 +81,14 @@ func DeleteSpiel(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusOK)
w.Write([]byte("Spiel erfolgreich gelöscht"))
_, err = w.Write([]byte("Spiel erfolgreich gelöscht"))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X GET localhost:3000/spieleMitLaeden
// GetSpieleMitLaeden curl -X GET localhost:3000/spieleMitLaeden
func GetSpieleMitLaeden(w http.ResponseWriter, r *http.Request) {
// MongoDB-Datenbank und -Sammlungen auswählen
db := util.Client.Database("meineDatenbank")
@ -88,7 +101,12 @@ func GetSpieleMitLaeden(w http.ResponseWriter, r *http.Request) {
if err != nil {
log.Fatal(err)
}
defer cursor.Close(context.Background())
defer func(cursor *mongo.Cursor, ctx context.Context) {
err := cursor.Close(ctx)
if err != nil {
}
}(cursor, context.Background())
for cursor.Next(context.Background()) {
var spiel util.Spiel
if err := cursor.Decode(&spiel); err != nil {
@ -113,10 +131,14 @@ func GetSpieleMitLaeden(w http.ResponseWriter, r *http.Request) {
// Spiele mit Läden als JSON zurücksenden
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(spieleMitLaeden)
err = json.NewEncoder(w).Encode(spieleMitLaeden)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X POST -d '{"titel": "Neues Spiel", "erscheinungsdatum": "2024-04-05T00:00:00Z", "publisher": "Neuer Publisher", "genre": "Neues Genre", "plattform": "Neue Plattform", "bewertung": 9}' -H "Content-Type: application/json" localhost:3000/addNewSpiel
// AddNewSpiel curl -X POST -d '{"titel": "Neues Spiel", "erscheinungsdatum": "2024-04-05T00:00:00Z", "publisher": "Neuer Publisher", "genre": "Neues Genre", "plattform": "Neue Plattform", "bewertung": 9}' -H "Content-Type: application/json" localhost:3000/addNewSpiel
func AddNewSpiel(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var newSpiel util.Spiel
@ -139,10 +161,14 @@ func AddNewSpiel(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusCreated)
w.Write([]byte("Neues Spiel erfolgreich hinzugefügt"))
_, err = w.Write([]byte("Neues Spiel erfolgreich hinzugefügt"))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
// curl -X POST -d '{"spiel_id": "YOUR_SPIEL_ID", "neuer_laden_id": "YOUR_NEUER_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/addNewLadenToSpiel
// AddNewLadenToSpiel curl -X POST -d '{"spiel_id": "YOUR_SPIEL_ID", "neuer_laden_id": "YOUR_NEUER_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/addNewLadenToSpiel
func AddNewLadenToSpiel(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var requestData struct {
@ -186,10 +212,13 @@ func AddNewLadenToSpiel(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusCreated)
w.Write([]byte("Neuer Laden erfolgreich zum Spiel hinzugefügt"))
if _, err := w.Write([]byte("Neuer Laden erfolgreich zum Spiel hinzugefügt")); err != nil {
fmt.Println(err)
http.Error(w, err.Error(), http.StatusBadRequest)
}
}
// curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID", "laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/deleteLadenFromSpiel
// DeleteLadenFromSpiel curl -X DELETE -d '{"spiel_id": "YOUR_SPIEL_ID", "laden_id": "YOUR_LADEN_ID"}' -H "Content-Type: application/json" localhost:3000/deleteLadenFromSpiel
func DeleteLadenFromSpiel(w http.ResponseWriter, r *http.Request) {
// Parse JSON body
var requestData struct {
@ -232,5 +261,8 @@ func DeleteLadenFromSpiel(w http.ResponseWriter, r *http.Request) {
// Erfolgsmeldung senden
w.WriteHeader(http.StatusOK)
w.Write([]byte("Laden erfolgreich aus dem Spiel entfernt"))
if _, err := w.Write([]byte("Laden erfolgreich aus dem Spiel entfernt")); err != nil {
fmt.Println(err)
http.Error(w, err.Error(), http.StatusBadRequest)
}
}

134
src/router/debt.go
View file

@ -1,134 +0,0 @@
package router
import (
"context"
"encoding/json"
"gibb165lb2/util"
"github.com/gorilla/mux"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"net/http"
"time"
)
func GetDebts(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
personID := vars["id"]
w.Header().Set("Content-Type", "application/json")
debts, err := util.GetDebtsForPerson(util.Client, personID)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(debts)
}
func CreateDebt(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
w.Header().Set("Content-Type", "application/json")
var debt util.Debt
personID := vars["id"]
json.NewDecoder(r.Body).Decode(&debt)
debt.PersonID, _ = primitive.ObjectIDFromHex(personID)
collection := util.Client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := collection.InsertOne(ctx, debt)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}
func DeleteDebt(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
w.Header().Set("Content-Type", "application/json")
var debt util.Debt
debtId := vars["id"]
json.NewDecoder(r.Body).Decode(&debt)
debt.ID, _ = primitive.ObjectIDFromHex(debtId)
collection := util.Client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
filter := bson.M{"_id": debt.ID}
result, err := collection.DeleteOne(ctx, filter)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}
func GetAllDebts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var debts []util.Debt
collection := util.Client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cursor, err := collection.Find(ctx, bson.M{})
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
defer cursor.Close(ctx)
for cursor.Next(ctx) {
var debt util.Debt
cursor.Decode(&debt)
debts = append(debts, debt)
}
if err := cursor.Err(); err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(debts)
}
func GetDebt(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
debtID := vars["id"]
w.Header().Set("Content-Type", "application/json")
var debt util.Debt
collection := util.Client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
did, err := primitive.ObjectIDFromHex(debtID)
filter := bson.M{"_id": did}
err = collection.FindOne(ctx, filter).Decode(&debt)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(debt)
}
func UpdateDebt(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var debt util.Debt
vars := mux.Vars(r)
debtID := vars["id"]
debt.ID, _ = primitive.ObjectIDFromHex(debtID)
json.NewDecoder(r.Body).Decode(&debt)
collection := util.Client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
filter := bson.M{"_id": debt.ID}
update := bson.M{
"$set": bson.M{
"fk_pid": debt.PersonID,
"amount": debt.Amount,
"description": debt.Description,
"datetime": debt.Datetime,
},
}
result, err := collection.UpdateOne(ctx, filter, update)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}

154
src/router/person.go
View file

@ -1,154 +0,0 @@
package router
import (
"context"
"encoding/json"
"fmt"
"gibb165lb2/util"
"github.com/gorilla/mux"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"net/http"
"time"
)
func CreatePerson(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var person util.Person
json.NewDecoder(r.Body).Decode(&person)
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := collection.InsertOne(ctx, person)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}
func UpdatePerson(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var person util.Person
vars := mux.Vars(r)
personID := vars["id"]
person.ID, _ = primitive.ObjectIDFromHex(personID)
json.NewDecoder(r.Body).Decode(&person)
fmt.Println(person)
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
filter := bson.M{"_id": person.ID}
update := bson.M{
"$set": bson.M{
"name": person.Name,
"age": person.Age,
"email": person.Email,
},
}
result, err := collection.UpdateOne(ctx, filter, update)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}
func DeletePerson(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
vars := mux.Vars(r)
personID := vars["id"]
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
newPersonID, err := primitive.ObjectIDFromHex(personID)
filter := bson.M{"_id": newPersonID}
result, err := collection.DeleteOne(ctx, filter)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(result)
}
func GetPerson(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
personID := vars["id"]
w.Header().Set("Content-Type", "application/json")
var person util.Person
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
pid, err := primitive.ObjectIDFromHex(personID)
filter := bson.M{"_id": pid}
err = collection.FindOne(ctx, filter).Decode(&person)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(person)
}
func GetAllPersons(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var persons []util.Person
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cursor, err := collection.Find(ctx, bson.M{})
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
defer cursor.Close(ctx)
for cursor.Next(ctx) {
var person util.Person
cursor.Decode(&person)
persons = append(persons, person)
}
if err := cursor.Err(); err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
json.NewEncoder(w).Encode(persons)
}
func GetPersonsWithDebts(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var personsWithDebts []util.PersonWithDebts
var persons []util.Person
collection := util.Client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
cursor, err := collection.Find(ctx, bson.M{})
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
defer cursor.Close(ctx)
for cursor.Next(ctx) {
var person util.Person
cursor.Decode(&person)
persons = append(persons, person)
}
if err := cursor.Err(); err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
for _, person := range persons {
debts, err := util.GetDebtsForPerson(util.Client, person.ID.Hex())
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte(`{"message": "` + err.Error() + `"}`))
return
}
personsWithDebts = append(personsWithDebts, util.PersonWithDebts{Person: person, Debts: debts})
}
json.NewEncoder(w).Encode(personsWithDebts)
}

19
src/util/structs.go
View file

@ -5,25 +5,6 @@ import (
"time"
)
type Person struct {
ID primitive.ObjectID `bson:"_id,omitempty"`
Name string `bson:"name"`
Age int `bson:"age,omitempty" json:"age,omitempty"`
Email string `bson:"email,omitempty" json:"email,omitempty"`
}
type Debt struct {
ID primitive.ObjectID `bson:"_id,omitempty"`
PersonID primitive.ObjectID `bson:"fk_pid"`
Amount int `bson:"amount"`
Description string `bson:"description,omitempty" json:"description,omitempty"`
Datetime time.Time `bson:"datetime"`
}
type PersonWithDebts struct {
Person Person `json:"person"`
Debts []Debt `json:"debts"`
}
// Spieleladen repräsentiert die Datenstruktur für die MongoDB-Sammlung "spielelaeden"
type Spieleladen struct {
ID primitive.ObjectID `bson:"_id,omitempty" json:"id,omitempty"`

127
src/util/util.go
View file

@ -1,134 +1,7 @@
package util
import (
"context"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"log"
"net/http"
"time"
)
var Client *mongo.Client
func GetDebtsForPerson(client *mongo.Client, personID string) ([]Debt, error) {
var results []Debt
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
// Umwandlung der personID von string in primitive.ObjectID
objID, err := primitive.ObjectIDFromHex(personID)
if err != nil {
return nil, err
}
// Verbindung zur "debts" Sammlung
debtsCollection := client.Database("debtlist").Collection("debts")
// Abfrage erstellen, die alle Schulden findet, deren fk_pid mit der personID übereinstimmt
filter := bson.M{"fk_pid": objID}
cursor, err := debtsCollection.Find(ctx, filter)
if err != nil {
return nil, err
}
defer cursor.Close(ctx)
// Durchlaufen des Cursors und Hinzufügen der Ergebnisse zur results-Slice
for cursor.Next(ctx) {
var debt Debt
if err := cursor.Decode(&debt); err != nil {
return nil, err
}
results = append(results, debt)
}
if err := cursor.Err(); err != nil {
return nil, err
}
return results, nil
}
func InsertRandomData(client *mongo.Client) {
persons := []string{"Max", "Moritz", "Hans", "Peter", "Paul", "Klaus", "Karl", "Kai", "Kurt", "Karl-Heinz"}
debts := []Debt{}
for i := 0; i < 10; i++ {
person := Person{Name: persons[i]}
collection := client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := collection.InsertOne(ctx, person)
if err != nil {
log.Fatal(err)
}
for j := 0; j < 3; j++ {
debts = append(debts, Debt{PersonID: result.InsertedID.(primitive.ObjectID), Amount: j * 100, Description: "Test", Datetime: time.Now()})
}
}
collection := client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
for _, debt := range debts {
_, err := collection.InsertOne(ctx, debt)
if err != nil {
log.Fatal(err)
}
}
}
func InsertRandomData2(client *mongo.Client) {
persons := []string{
"John Smith", "Jane Doe", "Michael Johnson", "Emily Davis", "Christopher Wilson",
"Sarah Brown", "Matthew Anderson", "Jessica Miller", "William Taylor", "Olivia Garcia",
"David Martinez", "Ashley Jackson", "James White", "Emma Harris", "Daniel Thomas",
"Sophia Lee", "Joseph Moore", "Chloe Taylor", "Ryan Harris", "Mia Davis",
"Benjamin Clark", "Ava Williams", "Alexander Walker", "Grace Lewis", "Samuel Turner",
"Lily Martin", "Nicholas Harris", "Ella Thompson", "Tyler Baker", "Natalie Wright",
"Andrew Carter", "Aria Rodriguez", "Ethan Robinson", "Addison Turner", "Christopher Wright",
"Zoey Phillips", "Daniel Turner", "Victoria Brooks", "Nicholas Mitchell", "Scarlett Davis",
"Logan Wilson", "Penelope Anderson", "Caleb Baker", "Harper Martinez", "Dylan Turner",
"Layla Johnson", "Isaac Harris", "Stella Miller", "Nathan Jackson", "Sofia Clark",
"Brandon Walker", "Aurora Taylor", "Jackson Lewis", "Leah Anderson", "Owen Thompson",
"Maya Williams", "Caleb Lewis", "Addison Garcia", "Zachary Turner", "Brooklyn Wright",
"Christopher Davis", "Ellie Robinson", "Matthew Taylor", "Amelia Harris", "Gabriel Turner",
"Peyton Robinson", "Wyatt Anderson", "Zoe Martin", "Henry Harris", "Eva Phillips",
"Connor Wilson", "Scarlett Lee", "Dylan Baker", "Isabella Taylor", "Samuel Davis",
"Ava Turner", "Caleb Martinez", "Mia Walker", "Owen Lewis", "Abigail Johnson",
"Logan Clark", "Grace Harris", "Lucas Turner", "Madison Robinson", "Brayden Taylor",
"Lillian Anderson", "Jackson Martin", "Lily Harris", "Daniel Turner", "Riley Wright",
"Sebastian Turner", "Harper Davis", "Elijah Walker", "Addison Phillips", "Owen Harris",
"Chloe Robinson", "Ethan Anderson", "Zoe Taylor", "Gabriel Wilson", "Aurora Davis",
}
debts := []Debt{}
for i := 0; i < 100; i++ {
person := Person{Name: persons[i]}
collection := client.Database("debtlist").Collection("persons")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
result, err := collection.InsertOne(ctx, person)
if err != nil {
log.Fatal(err)
}
for j := 0; j < 6; j++ {
debts = append(debts, Debt{PersonID: result.InsertedID.(primitive.ObjectID), Amount: j * 100, Description: "Test", Datetime: time.Now()})
}
}
collection := client.Database("debtlist").Collection("debts")
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
for _, debt := range debts {
_, err := collection.InsertOne(ctx, debt)
if err != nil {
log.Fatal(err)
}
}
}
func Init(w http.ResponseWriter, r *http.Request) {
InsertRandomData(Client)
w.Write([]byte("Init"))
}
func BigInit(w http.ResponseWriter, r *http.Request) {
InsertRandomData2(Client)
w.Write([]byte("Init"))
}