first commit

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

@@ -26,7 +26,7 @@ func main() {
 	}
 	defer util.Client.Disconnect(ctx)
 	r := GetRouter()
-	fmt.Println("Server is running on port 3333")
+	fmt.Println("Server is running on port 3000")
 	err = http.ListenAndServe(":3333", r)
 	if err != nil {
 		log.Fatal(err)

src/router.go

@@ -2,25 +2,34 @@ package main
 
 import (
 	"gibb165lb2/router"
-	"gibb165lb2/util"
 	"github.com/gorilla/mux"
 )
 
 func GetRouter() *mux.Router {
 	r := mux.NewRouter()
-	r.HandleFunc("/persons", router.CreatePerson).Methods("POST")
+	r.HandleFunc("/spiele", router.GetSpiele).Methods("GET")
-	r.HandleFunc("/persons/{id}", router.GetPerson).Methods("GET")
+	r.HandleFunc("/spiele", router.DeleteSpiel).Methods("DELETE")
-	r.HandleFunc("/persons", router.GetAllPersons).Methods("GET")
+	r.HandleFunc("/laeden", router.GetLaeden).Methods("GET")
-	r.HandleFunc("/personsWithDebts", router.GetPersonsWithDebts).Methods("GET")
+	r.HandleFunc("/laeden", router.DeleteLaden).Methods("DELETE")
-	r.HandleFunc("/persons/{id}", router.UpdatePerson).Methods("PUT")
+	r.HandleFunc("/init", router.InitDatabase).Methods("GET")
-	r.HandleFunc("/persons/{id}", router.DeletePerson).Methods("DELETE")
+	r.HandleFunc("/spiele-mit-laeden", router.GetSpieleMitLaeden).Methods("GET")
-	r.HandleFunc("/persons/{id}/debts", router.GetDebts).Methods("GET")
+	r.HandleFunc("/spiele-mit-laeden", router.DeleteLadenFromSpiel).Methods("DELETE")
-	r.HandleFunc("/persons/{id}/debts", router.CreateDebt).Methods("POST")
+	r.HandleFunc("/spiele-mit-laeden", router.AddNewLadenToSpiel).Methods("POST")
-	r.HandleFunc("/debts/{id}", router.DeleteDebt).Methods("DELETE")
+	r.HandleFunc("/spiele", router.AddNewSpiel).Methods("POST")
-	r.HandleFunc("/debts", router.GetAllDebts).Methods("GET")
+	r.HandleFunc("/laeden", router.AddNewLaden).Methods("POST")
-	r.HandleFunc("/debts/{id}", router.GetDebt).Methods("GET")
+	//r.HandleFunc("/persons", router.CreatePerson).Methods("POST")
-	r.HandleFunc("/debts/{id}", router.UpdateDebt).Methods("PUT")
+	//r.HandleFunc("/persons/{id}", router.GetPerson).Methods("GET")
-	r.HandleFunc("/init", util.Init).Methods("GET")
+	//r.HandleFunc("/persons", router.GetAllPersons).Methods("GET")
-	r.HandleFunc("/biginit", util.BigInit).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/util/structs.go

@@ -23,3 +23,51 @@ 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
+}