.idea/.gitignore

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

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?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,28 +1,22 @@
+# 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: root12345
+            MONGO_INITDB_ROOT_PASSWORD: example
 
     mongo-express:
         image: mongo-express
         restart: always
         ports:
-            - "8081:8081"
+            - 8081:8081
         environment:
             ME_CONFIG_MONGODB_ADMINUSERNAME: root
-            ME_CONFIG_MONGODB_ADMINPASSWORD: root12345
+            ME_CONFIG_MONGODB_ADMINPASSWORD: example
-            ME_CONFIG_MONGODB_URL: mongodb://root:root12345@mongo:27017/
+            ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/

go.mod

@@ -2,19 +2,16 @@ 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

go.sum

@@ -1,9 +1,5 @@
-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=
@@ -50,5 +46,3 @@ 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=

main.go

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

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

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

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

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

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

src/Dockerfile

@@ -1,9 +0,0 @@
-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/main.go

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

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

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

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

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

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

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