first commit

readme.md

@@ -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:

src/main.go

@@ -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")
+	var conUri = os.Getenv("MONGO_URL")
-	if con_uri == "" {
+	if conUri == "" {
-		con_uri = "mongodb://root:root12345@localhost:27017"
+		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)
 	}

src/router.go

@@ -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
 }

src/router/Laeden.go

@@ -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 := json.NewDecoder(r.Body).Decode(&newLaden); err != nil {
-	if 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 := laedenCollection.InsertOne(context.Background(), newLaden); err != nil {
-	if 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
+	}
 }

src/router/Spiele.go

@@ -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)
+	}
 }

src/router/debt.go

@@ -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)
-}

src/router/person.go

@@ -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)
-}

src/util/structs.go

@@ -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"`

src/util/util.go

@@ -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"))
-}