first commit

.idea/.gitignore

@@ -6,3 +6,5 @@
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
+# GitHub Copilot persisted chat sessions
+/copilot/chatSessions

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

docker-compose.yaml

@@ -1,22 +1,28 @@
-# Use root/example as user/password credentials
 version: "3.1"
-
 services:
+    backend:
+        build: ./src
+        restart: always
+        ports:
+            - "3333:3333"
+        environment:
+            MONGO_URL: mongodb://root:root12345@mongo:27017/
+        depends_on:
+            mongo:
+                condition: service_started
     mongo:
         image: mongo
         restart: always
-        ports:
-            - 27017:27017
         environment:
             MONGO_INITDB_ROOT_USERNAME: root
-            MONGO_INITDB_ROOT_PASSWORD: example
+            MONGO_INITDB_ROOT_PASSWORD: root12345
 
     mongo-express:
         image: mongo-express
         restart: always
         ports:
-            - 8081:8081
+            - "8081:8081"
         environment:
             ME_CONFIG_MONGODB_ADMINUSERNAME: root
-            ME_CONFIG_MONGODB_ADMINPASSWORD: example
-            ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/
+            ME_CONFIG_MONGODB_ADMINPASSWORD: root12345
+            ME_CONFIG_MONGODB_URL: mongodb://root:root12345@mongo:27017/

main.go

@@ -1,189 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/gorilla/mux"
-)
-
-var client *mongo.Client
-
-type Person struct {
-	ID   primitive.ObjectID `bson:"_id,omitempty"`
-	Name string             `bson:"name"`
-}
-
-type Debt struct {
-	ID          primitive.ObjectID `bson:"_id,omitempty"`
-	PersonID    primitive.ObjectID `bson:"fk_pid"`
-	Amount      int                `bson:"amount"`
-	Description string             `bson:"description,omitempty"`
-	Datetime    time.Time          `bson:"datetime"`
-}
-
-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 main() {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-	var err error
-	client, err = mongo.Connect(ctx, options.Client().ApplyURI("mongodb://root:example@localhost:27017"))
-	if err != nil {
-		panic(err)
-	}
-
-	// Router initialisieren
-	r := mux.NewRouter()
-	r.HandleFunc("/persons", createPerson).Methods("POST")
-	r.HandleFunc("/persons/{id}", getPerson).Methods("GET")
-	r.HandleFunc("/persons", getAllPersons).Methods("GET")
-	r.HandleFunc("/persons/{id}", updatePerson).Methods("PUT")
-	r.HandleFunc("/persons/{id}", deletePerson).Methods("DELETE")
-	err = http.ListenAndServe(":3333", r)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-func createPerson(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	var person Person
-	json.NewDecoder(r.Body).Decode(&person)
-	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 {
-		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 Person
-	json.NewDecoder(r.Body).Decode(&person)
-	collection := 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,
-		},
-	}
-	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")
-	var person Person
-	json.NewDecoder(r.Body).Decode(&person)
-	collection := client.Database("debtlist").Collection("persons")
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	filter := bson.M{"_id": person.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 getPerson(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	personID := vars["id"]
-	w.Header().Set("Content-Type", "application/json")
-	var person Person
-	collection := 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 []Person
-	collection := 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 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)
-}

readme.md

@@ -0,0 +1,34 @@
+# Gibb 165 LB 2
+
+Ein Schulprojekt für NoSql-Databases
+
+## Voraussetzungen
+
+Stellen Sie sicher, dass die folgenden Tools auf Ihrem System installiert sind:
+
+-   Docker
+-   Docker Compose
+
+## Installation
+
+1. Klone das Repository:
+
+    ```bash
+    git clone https://repo.zenndev.xyz/Gibb-Projekte/modul-165-lb2
+    ```
+
+2. Wechsel in das Projektverzeichnis:
+
+    ```bash
+    cd modul-165-lb2
+    ```
+
+3. Starte das Projekt mit Docker Compose:
+
+    ```bash
+    docker-compose up -d
+    ```
+
+4. Öffne deinen Webbrowser und gehe zu `http://localhost:3333`, um das Projekt zu sehen.
+
+# Todo

src/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

src/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/src.iml" filepath="$PROJECT_DIR$/.idea/src.iml" />
+    </modules>
+  </component>
+</project>

src/.idea/src.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

src/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

src/Dockerfile

@@ -0,0 +1,9 @@
+FROM golang:1.22
+LABEL authors="ZennDev1337"
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY ./ ./
+RUN CGO_ENABLED=0 GOOS=linux go build -o /gibb165lb2
+
+CMD ["/gibb165lb2"]

src/go.mod

@@ -2,16 +2,19 @@ module gibb165lb2
 
 go 1.22
 
+require (
+	github.com/gorilla/mux v1.8.1
+	go.mongodb.org/mongo-driver v1.14.0
+)
+
 require (
 	github.com/golang/snappy v0.0.1 // indirect
-	github.com/gorilla/mux v1.8.1 // indirect
 	github.com/klauspost/compress v1.13.6 // indirect
 	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
-	go.mongodb.org/mongo-driver v1.14.0 // indirect
 	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect

src/go.sum

@@ -1,5 +1,9 @@
+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/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
@@ -46,3 +50,5 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

src/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"gibb165lb2/util"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"log"
+	"net/http"
+	"os"
+	"time"
+)
+
+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"
+	}
+	util.Client, err = mongo.Connect(ctx, options.Client().ApplyURI(con_uri))
+	if err != nil {
+		panic(err)
+	}
+	defer util.Client.Disconnect(ctx)
+	r := GetRouter()
+	fmt.Println("Server is running on port 3000")
+	err = http.ListenAndServe(":3333", r)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

src/router.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"gibb165lb2/router"
+	"github.com/gorilla/mux"
+)
+
+func GetRouter() *mux.Router {
+	r := mux.NewRouter()
+	r.HandleFunc("/spiele", router.GetSpiele).Methods("GET")
+	r.HandleFunc("/spiele", router.DeleteSpiel).Methods("DELETE")
+	r.HandleFunc("/laeden", router.GetLaeden).Methods("GET")
+	r.HandleFunc("/laeden", router.DeleteLaden).Methods("DELETE")
+	r.HandleFunc("/init", router.InitDatabase).Methods("GET")
+	r.HandleFunc("/spiele-mit-laeden", router.GetSpieleMitLaeden).Methods("GET")
+	r.HandleFunc("/spiele-mit-laeden", router.DeleteLadenFromSpiel).Methods("DELETE")
+	r.HandleFunc("/spiele-mit-laeden", router.AddNewLadenToSpiel).Methods("POST")
+	r.HandleFunc("/spiele", router.AddNewSpiel).Methods("POST")
+	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

@@ -0,0 +1,174 @@
+package router
+
+import (
+	"context"
+	"encoding/json"
+	"gibb165lb2/util"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"log"
+	"math/rand"
+	"net/http"
+	"time"
+)
+
+// 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")
+	laedenCollection := db.Collection("spielelaeden")
+
+	// Läden aus der Datenbank abrufen
+	var laeden []util.Spieleladen
+	cursor, err := laedenCollection.Find(context.Background(), bson.M{})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer cursor.Close(context.Background())
+	for cursor.Next(context.Background()) {
+		var laden util.Spieleladen
+		if err := cursor.Decode(&laden); err != nil {
+			log.Fatal(err)
+		}
+		laeden = append(laeden, laden)
+	}
+	if err := cursor.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Läden als JSON zurücksenden
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(laeden)
+}
+
+// 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")
+	spieleCollection := db.Collection("spiele")
+	laedenCollection := db.Collection("spielelaeden")
+
+	// Musterdaten für Läden und Spiele erstellen
+	laeden := []util.Spieleladen{
+		{Name: "GameZone", Adresse: "123 Main Street", Telefonnummer: "555-1234"},
+		{Name: "Gamer's Haven", Adresse: "456 Elm Street", Telefonnummer: "555-5678"},
+		{Name: "TechZone", Adresse: "789 Oak Avenue", Telefonnummer: "555-9012"},
+		{Name: "GameStop", Adresse: "321 Pine Road", Telefonnummer: "555-3456"},
+		{Name: "Pixel Palace", Adresse: "555 Maple Lane", Telefonnummer: "555-7890"},
+	}
+
+	spiele := []util.Spiel{
+		{Titel: "Red Dead Redemption 2", Erscheinungsdatum: time.Date(2018, 10, 26, 0, 0, 0, 0, time.UTC), Publisher: "Rockstar Games", Genre: "Action-Adventure", Plattform: "PlayStation 4", Bewertung: 10},
+		{Titel: "The Legend of Zelda: Breath of the Wild", Erscheinungsdatum: time.Date(2017, 3, 3, 0, 0, 0, 0, time.UTC), Publisher: "Nintendo", Genre: "Action-Adventure", Plattform: "Nintendo Switch", Bewertung: 10},
+		{Titel: "God of War", Erscheinungsdatum: time.Date(2018, 4, 20, 0, 0, 0, 0, time.UTC), Publisher: "Sony Interactive Entertainment", Genre: "Action-Adventure", Plattform: "PlayStation 4", Bewertung: 9},
+		{Titel: "The Witcher 3: Wild Hunt", Erscheinungsdatum: time.Date(2015, 5, 19, 0, 0, 0, 0, time.UTC), Publisher: "CD Projekt", Genre: "Action-RPG", Plattform: "PlayStation 4", Bewertung: 9},
+	}
+
+	// Läden in die Datenbank einfügen
+	var laedenIDs []primitive.ObjectID
+	for _, l := range laeden {
+		result, err := laedenCollection.InsertOne(context.Background(), l)
+		if err != nil {
+			log.Fatal(err)
+		}
+		laedenIDs = append(laedenIDs, result.InsertedID.(primitive.ObjectID))
+	}
+
+	// Spiele in die Datenbank einfügen
+	var spieleWithLadenIDs []interface{}
+	for _, spiel := range spiele {
+		// Läden-IDs zum Spiel hinzufügen
+		ladenids := []primitive.ObjectID{}
+		randomIndex1 := rand.Intn(len(laedenIDs))
+		ladenids = append(ladenids, laedenIDs[randomIndex1])
+		var randomIndex2 int
+		for {
+			randomIndex2 = rand.Intn(len(laedenIDs))
+			if randomIndex2 != randomIndex1 {
+				break
+			}
+		}
+		ladenids = append(ladenids, laedenIDs[randomIndex2])
+		spiel.Laeden = ladenids
+		// Spiel in bson.M-Format konvertieren
+		spielBSON := bson.M{
+			"Laeden":            spiel.Laeden,
+			"Titel":             spiel.Titel,
+			"Erscheinungsdatum": spiel.Erscheinungsdatum,
+			"Publisher":         spiel.Publisher,
+			"Genre":             spiel.Genre,
+			"Plattform":         spiel.Plattform,
+			"Bewertung":         spiel.Bewertung,
+		}
+		spieleWithLadenIDs = append(spieleWithLadenIDs, spielBSON)
+	}
+	_, err := spieleCollection.InsertMany(context.Background(), spieleWithLadenIDs)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Datenbank erfolgreich initialisiert"))
+}
+
+// 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 {
+		LadenID string `json:"laden_id"`
+	}
+	err := json.NewDecoder(r.Body).Decode(&requestData)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse LadenID as ObjectID
+	ladenID, err := primitive.ObjectIDFromHex(requestData.LadenID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// MongoDB-Datenbank und -Sammlungen auswählen
+	db := util.Client.Database("meineDatenbank")
+	laedenCollection := db.Collection("spielelaeden")
+
+	// Laden aus der Datenbank löschen
+	_, err = laedenCollection.DeleteOne(context.Background(), bson.M{"_id": ladenID})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Laden erfolgreich gelöscht"))
+}
+
+// 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 {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// MongoDB-Datenbank und -Sammlung auswählen
+	db := util.Client.Database("meineDatenbank")
+	laedenCollection := db.Collection("spielelaeden")
+
+	// Neuen Laden in die Datenbank einfügen
+	_, err = laedenCollection.InsertOne(context.Background(), newLaden)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusCreated)
+	w.Write([]byte("Neuer Laden erfolgreich erstellt"))
+}

src/router/Spiele.go

@@ -0,0 +1,236 @@
+package router
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"gibb165lb2/util"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"log"
+	"net/http"
+)
+
+// 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")
+	spieleCollection := db.Collection("spiele")
+
+	// Spiele aus der Datenbank abrufen
+	var spiele []util.Spiel
+	cursor, err := spieleCollection.Find(context.Background(), bson.M{})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer cursor.Close(context.Background())
+	for cursor.Next(context.Background()) {
+		var spiel util.Spiel
+		if err := cursor.Decode(&spiel); err != nil {
+			log.Fatal(err)
+		}
+		spiele = append(spiele, spiel)
+	}
+	if err := cursor.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Spiele als JSON zurücksenden
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(spiele)
+}
+
+// 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 {
+		SpielID string `json:"spiel_id"`
+	}
+	err := json.NewDecoder(r.Body).Decode(&requestData)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse SpielID as ObjectID
+	spielID, err := primitive.ObjectIDFromHex(requestData.SpielID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// MongoDB-Datenbank und -Sammlungen auswählen
+	db := util.Client.Database("meineDatenbank")
+	spieleCollection := db.Collection("spiele")
+
+	// Spiel aus der Datenbank löschen
+	_, err = spieleCollection.DeleteOne(context.Background(), bson.M{"_id": spielID})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Spiel erfolgreich gelöscht"))
+}
+
+// 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")
+	spieleCollection := db.Collection("spiele")
+	laedenCollection := db.Collection("spielelaeden")
+
+	// Spiele aus der Datenbank abrufen
+	var spieleMitLaeden []util.SpieleMitLaden
+	cursor, err := spieleCollection.Find(context.Background(), bson.M{})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer cursor.Close(context.Background())
+	for cursor.Next(context.Background()) {
+		var spiel util.Spiel
+		if err := cursor.Decode(&spiel); err != nil {
+			log.Fatal(err)
+		}
+		spieleMitLaedenMut := spiel.ToSpieleMitLaden()
+		fmt.Printf("%+v\n", spieleMitLaedenMut)
+		// Lädeninformationen für jedes Spiel abrufen
+		for _, ladenID := range spiel.Laeden {
+			var laden util.Spieleladen
+			err := laedenCollection.FindOne(context.Background(), bson.M{"_id": ladenID}).Decode(&laden)
+			if err != nil {
+				log.Fatal(err)
+			}
+			spieleMitLaedenMut.Laeden = append(spieleMitLaedenMut.Laeden, laden)
+		}
+		spieleMitLaeden = append(spieleMitLaeden, spieleMitLaedenMut)
+	}
+	if err := cursor.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Spiele mit Läden als JSON zurücksenden
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(spieleMitLaeden)
+}
+
+// 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
+	err := json.NewDecoder(r.Body).Decode(&newSpiel)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// MongoDB-Datenbank und -Sammlung auswählen
+	db := util.Client.Database("meineDatenbank")
+	spieleCollection := db.Collection("spiele")
+
+	// Spiel in die Datenbank einfügen
+	_, err = spieleCollection.InsertOne(context.Background(), newSpiel)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusCreated)
+	w.Write([]byte("Neues Spiel erfolgreich hinzugefügt"))
+}
+
+// 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 {
+		SpielID string `json:"spiel_id"`
+		LadenID string `json:"neuer_laden_id"`
+	}
+	err := json.NewDecoder(r.Body).Decode(&requestData)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse SpielID as ObjectID
+	spielID, err := primitive.ObjectIDFromHex(requestData.SpielID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse NeuerLadenID as ObjectID
+	neuerLadenID, err := primitive.ObjectIDFromHex(requestData.LadenID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// MongoDB-Datenbank und -Sammlungen auswählen
+	db := util.Client.Database("meineDatenbank")
+	spieleCollection := db.Collection("spiele")
+
+	// Neuen Laden zur Spiel-Sammlung hinzufügen
+	_, err = spieleCollection.UpdateOne(
+		context.Background(),
+		bson.M{"_id": spielID},
+		bson.M{"$push": bson.M{"Läden": neuerLadenID}},
+	)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusCreated)
+	w.Write([]byte("Neuer Laden erfolgreich zum Spiel hinzugefügt"))
+}
+
+// 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 {
+		SpielID string `json:"spiel_id"`
+		LadenID string `json:"laden_id"`
+	}
+	err := json.NewDecoder(r.Body).Decode(&requestData)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse SpielID as ObjectID
+	spielID, err := primitive.ObjectIDFromHex(requestData.SpielID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Parse LadenID as ObjectID
+	ladenID, err := primitive.ObjectIDFromHex(requestData.LadenID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	// MongoDB-Datenbank und -Sammlungen auswählen
+	db := util.Client.Database("meineDatenbank")
+	spieleCollection := db.Collection("spiele")
+
+	// Laden aus der Spiel-Sammlung entfernen
+	_, err = spieleCollection.UpdateOne(
+		context.Background(),
+		bson.M{"_id": spielID},
+		bson.M{"$pull": bson.M{"Läden": ladenID}},
+	)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Erfolgsmeldung senden
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Laden erfolgreich aus dem Spiel entfernt"))
+}

src/router/debt.go

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,154 @@
+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

@@ -0,0 +1,73 @@
+package util
+
+import (
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"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"`
+	Name          string             `bson:"Name,omitempty" json:"Name,omitempty"`
+	Adresse       string             `bson:"Adresse,omitempty" json:"Adresse,omitempty"`
+	Telefonnummer string             `bson:"Telefonnummer,omitempty" json:"Telefonnummer,omitempty"`
+}
+
+// Spiel repräsentiert die Datenstruktur für die MongoDB-Sammlung "spiele"
+type Spiel struct {
+	ID                primitive.ObjectID   `bson:"_id,omitempty" json:"id,omitempty"`
+	Laeden            []primitive.ObjectID `bson:"Laeden,omitempty" json:"Laeden,omitempty"`
+	Titel             string               `bson:"Titel,omitempty" json:"Titel,omitempty"`
+	Erscheinungsdatum time.Time            `bson:"Erscheinungsdatum,omitempty" json:"Erscheinungsdatum,omitempty"`
+	Publisher         string               `bson:"Publisher,omitempty" json:"Publisher,omitempty"`
+	Genre             string               `bson:"Genre,omitempty" json:"Genre,omitempty"`
+	Plattform         string               `bson:"Plattform,omitempty" json:"Plattform,omitempty"`
+	Bewertung         int                  `bson:"Bewertung,omitempty" json:"Bewertung,omitempty"`
+}
+
+// SpieleMitLaden repräsentiert die Datenstruktur für die MongoDB-Sammlung "spiele"
+type SpieleMitLaden struct {
+	ID                primitive.ObjectID   `bson:"_id,omitempty" json:"id,omitempty"`
+	Laeden            []Spieleladen        `json:"Laeden,omitempty"`
+	LaedenId          []primitive.ObjectID `bson:"Laeden,omitempty"`
+	Titel             string               `bson:"Titel,omitempty" json:"Titel,omitempty"`
+	Erscheinungsdatum time.Time            `bson:"Erscheinungsdatum,omitempty" json:"Erscheinungsdatum,omitempty"`
+	Publisher         string               `bson:"Publisher,omitempty" json:"Publisher,omitempty"`
+	Genre             string               `bson:"Genre,omitempty" json:"Genre,omitempty"`
+	Plattform         string               `bson:"Plattform,omitempty" json:"Plattform,omitempty"`
+	Bewertung         int                  `bson:"Bewertung,omitempty" json:"Bewertung,omitempty"`
+}
+
+func (s Spiel) ToSpieleMitLaden() SpieleMitLaden {
+	spielmitladen := SpieleMitLaden{
+		ID:                s.ID,
+		Laeden:            nil,
+		LaedenId:          s.Laeden,
+		Titel:             s.Titel,
+		Erscheinungsdatum: s.Erscheinungsdatum,
+		Publisher:         s.Publisher,
+		Genre:             s.Genre,
+		Plattform:         s.Plattform,
+		Bewertung:         s.Bewertung,
+	}
+	return spielmitladen
+}

src/util/util.go

@@ -0,0 +1,134 @@
+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"))
+}