diff --git a/.idea/.gitignore b/.idea/.gitignore index a9d7db9..13566b8 100644 --- a/.idea/.gitignore +++ b/.idea/.gitignore @@ -6,5 +6,3 @@ # Datasource local storage ignored files /dataSources/ /dataSources.local.xml -# GitHub Copilot persisted chat sessions -/copilot/chatSessions diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 94a25f7..0000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/docker-compose.yaml b/docker-compose.yaml index c65ee1a..5db86a4 100644 --- a/docker-compose.yaml +++ b/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_URL: mongodb://root:root12345@mongo:27017/ + ME_CONFIG_MONGODB_ADMINPASSWORD: example + ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/ diff --git a/src/go.mod b/go.mod similarity index 85% rename from src/go.mod rename to go.mod index 1321f98..22f5180 100644 --- a/src/go.mod +++ b/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 diff --git a/src/go.sum b/go.sum similarity index 89% rename from src/go.sum rename to go.sum index 6716fe6..acc431a 100644 --- a/src/go.sum +++ b/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= diff --git a/main.go b/main.go new file mode 100644 index 0000000..e968a28 --- /dev/null +++ b/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) +} diff --git a/readme.md b/readme.md deleted file mode 100644 index 3008a7b..0000000 --- a/readme.md +++ /dev/null @@ -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 diff --git a/src/.idea/.gitignore b/src/.idea/.gitignore deleted file mode 100644 index 13566b8..0000000 --- a/src/.idea/.gitignore +++ /dev/null @@ -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 diff --git a/src/.idea/modules.xml b/src/.idea/modules.xml deleted file mode 100644 index f669a0e..0000000 --- a/src/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/src/.idea/src.iml b/src/.idea/src.iml deleted file mode 100644 index 5e764c4..0000000 --- a/src/.idea/src.iml +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - \ No newline at end of file diff --git a/src/.idea/vcs.xml b/src/.idea/vcs.xml deleted file mode 100644 index 6c0b863..0000000 --- a/src/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/src/Dockerfile b/src/Dockerfile deleted file mode 100644 index e0d5d25..0000000 --- a/src/Dockerfile +++ /dev/null @@ -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"] \ No newline at end of file diff --git a/src/main.go b/src/main.go deleted file mode 100644 index 54c7380..0000000 --- a/src/main.go +++ /dev/null @@ -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) - } -} diff --git a/src/router.go b/src/router.go deleted file mode 100644 index a0ffc73..0000000 --- a/src/router.go +++ /dev/null @@ -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 -} diff --git a/src/router/Laeden.go b/src/router/Laeden.go deleted file mode 100644 index 410af97..0000000 --- a/src/router/Laeden.go +++ /dev/null @@ -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")) -} diff --git a/src/router/Spiele.go b/src/router/Spiele.go deleted file mode 100644 index 5773b28..0000000 --- a/src/router/Spiele.go +++ /dev/null @@ -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")) -} diff --git a/src/router/debt.go b/src/router/debt.go deleted file mode 100644 index a01e991..0000000 --- a/src/router/debt.go +++ /dev/null @@ -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) -} diff --git a/src/router/person.go b/src/router/person.go deleted file mode 100644 index ee0c802..0000000 --- a/src/router/person.go +++ /dev/null @@ -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) -} diff --git a/src/util/structs.go b/src/util/structs.go deleted file mode 100644 index d63d56f..0000000 --- a/src/util/structs.go +++ /dev/null @@ -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 -} diff --git a/src/util/util.go b/src/util/util.go deleted file mode 100644 index 94c9da4..0000000 --- a/src/util/util.go +++ /dev/null @@ -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")) -}