SpieleLaden-NoSQL/src/router/Laeden.go

package router

import (
	"context"
	"encoding/json"
	"gibb165lb2/util"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"log"
	"math/rand"
	"net/http"
	"time"
)

// GetLaeden 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 func(cursor *mongo.Cursor, ctx context.Context) {
		err := cursor.Close(ctx)
		if err != nil {

		}
	}(cursor, 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")
	if err := json.NewEncoder(w).Encode(laeden); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}

// InitDatabase 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
		var 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)
	if _, err := w.Write([]byte("Datenbank erfolgreich initialisiert")); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}

// DeleteLaden 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)
	if _, err := w.Write([]byte("Laden erfolgreich gelöscht")); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}

// AddNewLaden 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
	if err := json.NewDecoder(r.Body).Decode(&newLaden); 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
	if _, err := laedenCollection.InsertOne(context.Background(), newLaden); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Erfolgsmeldung senden
	w.WriteHeader(http.StatusCreated)
	if _, err := w.Write([]byte("Neuer Laden erfolgreich erstellt")); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}