ZennDev1337/SpieleLaden-NoSQL
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

first commit

Browse source
This commit is contained in:
ZennDev1337 2024-04-05 13:23:48 +02:00
parent d7a1c59bec
commit 6f61c68c9b
11 changed files with 525 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/.idea/.gitignore generated vendored Normal file
View file

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

8
src/.idea/modules.xml generated Normal file
View file

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

9
src/.idea/src.iml generated Normal file
View file

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

6
src/.idea/vcs.xml generated Normal file
View file

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

7
src/go.mod
View file

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

6
src/go.sum
View file

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

2
src/main.go
View file

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

39
src/router.go
View file

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

174
src/router/Laeden.go Normal file
View file

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

236
src/router/Spiele.go Normal file
View file

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

48
src/util/structs.go
View file

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