diff --git a/src/.idea/.gitignore b/src/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/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 diff --git a/src/.idea/modules.xml b/src/.idea/modules.xml new file mode 100644 index 0000000..f669a0e --- /dev/null +++ b/src/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/src/.idea/src.iml b/src/.idea/src.iml new file mode 100644 index 0000000..5e764c4 --- /dev/null +++ b/src/.idea/src.iml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/src/.idea/vcs.xml b/src/.idea/vcs.xml new file mode 100644 index 0000000..6c0b863 --- /dev/null +++ b/src/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/go.mod b/src/go.mod index 22f5180..1321f98 100644 --- a/src/go.mod +++ b/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 diff --git a/src/go.sum b/src/go.sum index acc431a..6716fe6 100644 --- a/src/go.sum +++ b/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= diff --git a/src/main.go b/src/main.go index 4e4b05f..54c7380 100644 --- a/src/main.go +++ b/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) diff --git a/src/router.go b/src/router.go index c2bd4d5..a0ffc73 100644 --- a/src/router.go +++ b/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("/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") + 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 } diff --git a/src/router/Laeden.go b/src/router/Laeden.go new file mode 100644 index 0000000..410af97 --- /dev/null +++ b/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")) +} diff --git a/src/router/Spiele.go b/src/router/Spiele.go new file mode 100644 index 0000000..5773b28 --- /dev/null +++ b/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")) +} diff --git a/src/util/structs.go b/src/util/structs.go index 94a9cad..d63d56f 100644 --- a/src/util/structs.go +++ b/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 +}