cancel and add order without travel

go.work.sum

@@ -3,3 +3,4 @@ cloud.google.com/go/compute v1.19.0 h1:+9zda3WGgW1ZSTlVppLCYFIr48Pa35q1uG2N1itbC
 github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64=

src/highlanderticketing/go.sum

@@ -89,8 +89,6 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc h1:8DyZCyvI8mE1IdLy/60bS+52xfymkE72wv1asokgtao=
-google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=

src/highlanderticketing/handler/order.go

@@ -52,48 +52,6 @@ func AddMatchOrder(w http.ResponseWriter, r *http.Request) {
 	}
 	sendJson(w, order)
 
-}
-func AddTravelOrder(w http.ResponseWriter, r *http.Request) {
-	if err := CheckAccessToken(w, r, false); err != nil {
-		log.Errorf("Eror checking AccessToken: %v", err)
-		http.Error(w, err.Error(), http.StatusUnauthorized)
-		return
-	}
-	id, err := getID(r)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	order, err := getOrder(r)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	reqToken, err := getBearerToken(r)
-	if err != nil {
-		log.Errorf("Failure loading bearer token  %v", err)
-		http.Error(w, err.Error(), http.StatusBadRequest)
-	}
-	userOfOrder, err := service.GetUserInfoByToken(reqToken)
-	if err != nil {
-		log.Errorf("Failure loading user Info %v", err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-	internalUser, err := service.GetUserByEmail(userOfOrder.Email)
-	if err != nil {
-		log.Errorf("Failure loading internal user Info %v", err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-	order.User = *internalUser
-
-	err = service.AddTravelOrder(id, order)
-	if err != nil {
-		log.Errorf("Failure adding donation to campaign with ID %v: %v", id, err)
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	sendJson(w, order)
-
 }
 func CancelOrder(w http.ResponseWriter, r *http.Request) {
 	if err := CheckAccessToken(w, r, false); err != nil {

src/highlanderticketing/main.go

 package main
 
 import (
-	"fmt"
 	"net/http"
 	"os"
 
@@ -9,20 +8,18 @@ import (
 	"github.com/joho/godotenv"
 	"github.com/nats-io/nats.go"
 	log "github.com/sirupsen/logrus"
-	"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/api"
 	"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/db"
 	"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/handler"
-	"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/model"
 	"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/service"
 )
 
 func main() {
-	service.DeleteAllUsers()
+	/*service.DeleteAllUsers()
 	var userArray []model.User
 	userArray, _ = service.GetAllUsers()
 	fmt.Println(userArray)
 	service.DeleteAllMatches()
-	api.GetMatchesOfApiToDb("https://api.openligadb.de/getmatchesbyteamid/16/5/0")
+	api.GetMatchesOfApiToDb("https://api.openligadb.de/getmatchesbyteamid/16/5/0")*/
 
 	if err := godotenv.Load(".env"); err != nil {
 		log.Fatalf("Error loading .env file")
@@ -53,7 +50,6 @@ func main() {
 	router.HandleFunc("/match/{id}", handler.UpdateMatch).Methods("PUT")
 	router.HandleFunc("/match/{id}", handler.DeleteMatch).Methods("DELETE")
 	router.HandleFunc("/match/{id}/matchorder", handler.AddMatchOrder).Methods("POST")
-	router.HandleFunc("/match/{id}/travelorder", handler.AddTravelOrder).Methods("POST")
 	router.HandleFunc("/match/{id}/cancelorder/{orderid}", handler.CancelOrder).Methods("PUT")
 	if err := http.ListenAndServe(":8000", router); err != nil {
 		log.Fatal(err)

src/highlanderticketing/model/match.go

@@ -11,7 +11,6 @@ type Match struct {
 	AwayMatch             bool               `bson:"away_match"`
 	Location              string             `bson:"location"`
 	Date                  string             `bson:"date, omitempty"`
-	Travel                Travel             `bson:"travel"`
 	OrderAmount           int32              `bson:"orderamount, omitempty"`
 	Orders                []Order            `bson:"orders"`
 }

src/highlanderticketing/model/travel.go

-package model
-
-import (
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"google.golang.org/genproto/googleapis/type/date"
-)
-
-type Travel struct {
-	ID                  primitive.ObjectID `bson:"_id, omitempty"`
-	TravelType          TravelType
-	InitialSeatAmount   int32
-	AvailableSeatAmount int32
-	StartLocation       string
-	EndLocation         string
-	StartDate           date.Date
-	Orders              []Order
-}
-
-type TravelType string
-
-const (
-	CAR   TravelType = "CAR"
-	BUS   TravelType = "BUS"
-	PLANE TravelType = "PLANE"
-)
-
-// Funktion ins Modell (siehe
-//Myaktion), welche den available_ Ticket_Amount berechnet

src/highlanderticketing/service/match.go

@@ -14,8 +14,6 @@ import (
 func CreateMatch(match *model.Match) error {
 	match.ID = primitive.NewObjectID()
 	match.Orders = []model.Order{}
-	match.Travel.ID = primitive.NewObjectID()
-	match.Travel.Orders = []model.Order{}
 	client, err := db.GetMongoClient()
 	if err != nil {
 		return err

src/highlanderticketing/service/order.go

@@ -14,45 +14,13 @@ import (
 func AddMatchOrder(matchID primitive.ObjectID, order *model.Order) error {
 	filter := bson.D{primitive.E{Key: "_id", Value: matchID}}
 	order.ID = primitive.NewObjectID()
-	matchToFind := model.Match{}
+	matchToFind := &model.Match{}
+	emailContent := model.EmialContent{Name: order.User.Name, AwayMatch: matchToFind.AwayMatch, Location: matchToFind.Location, Date: matchToFind.Date, Emailadress: order.User.Email, OrderID: matchToFind.ID.String()}
 
 	updater := bson.D{primitive.E{Key: "$push", Value: bson.D{
 		primitive.E{Key: "orders", Value: order},
 	}}}
 
-	client, err := db.GetMongoClient()
-	if err != nil {
-		return err
-	}
-
-	collection := client.Database(db.DB).Collection(db.MATCHES)
-
-	err = collection.FindOne(context.TODO(), filter).Decode(&matchToFind)
-	if err != nil {
-		return err
-	}
-
-	updateResult, err := collection.UpdateOne(context.TODO(), filter, updater)
-	if err != nil {
-		return err
-	}
-
-	if updateResult.ModifiedCount == 0 {
-		return fmt.Errorf("no document was updated, please send order again")
-	}
-
-	natsServer, err := ConnectToNats()
-	defer natsServer.Nc.Close()
-
-	emailContent := model.EmialContent{Name: order.User.Name, AwayMatch: matchToFind.AwayMatch, Location: matchToFind.Location, Date: matchToFind.Date, Emailadress: order.User.Email, OrderID: matchToFind.ID.String()}
-	if err := natsServer.ConfirmOrder(&emailContent); err != nil {
-		// hier warten und nochmal versuchen zu senden
-		order.Ordernotified = false
-		return fmt.Errorf("error sending confirm email: %v", err)
-	} else {
-		order.Ordernotified = true
-	}
-
 	updaterNotification := bson.D{primitive.E{Key: "$set", Value: bson.D{
 		primitive.E{Key: "orders.$[element]", Value: order},
 	}}}
@@ -63,25 +31,6 @@ func AddMatchOrder(matchID primitive.ObjectID, order *model.Order) error {
 		},
 	})
 
-	updateNotification, err := collection.UpdateOne(context.TODO(), filter, updaterNotification, options)
-	if err != nil {
-		return fmt.Errorf("no document was updated, please send order again")
-	}
-
-	if updateNotification.ModifiedCount == 0 {
-		return fmt.Errorf("no document was updated, please send order again")
-	}
-
-	return nil
-}
-
-func AddTravelOrder(matchID primitive.ObjectID, order *model.Order) error {
-	filter := bson.D{primitive.E{Key: "_id", Value: matchID}}
-	order.ID = primitive.NewObjectID()
-	matchToFind := model.Match{}
-
-	updater := bson.M{"$push": bson.M{"travel.orders": order}}
-
 	client, err := db.GetMongoClient()
 	if err != nil {
 		return err
@@ -93,57 +42,78 @@ func AddTravelOrder(matchID primitive.ObjectID, order *model.Order) error {
 	if err != nil {
 		return err
 	}
+	if matchToFind.AvailableTicketAmount < order.Amount {
+		return fmt.Errorf("ticket amount not available")
+	} else {
+		matchToFind.AvailableTicketAmount = matchToFind.AvailableTicketAmount - order.Amount
+	}
 
 	updateResult, err := collection.UpdateOne(context.TODO(), filter, updater)
 	if err != nil {
 		return err
 	}
-
 	if updateResult.ModifiedCount == 0 {
 		return fmt.Errorf("no document was updated, please send order again")
 	}
 
+	_, errUpdate := UpdateMatch(matchToFind.ID, matchToFind)
+	if errUpdate != nil {
+		errUpdate = fmt.Errorf("can not update match amount, please send order again")
+		err := deleteOrder(order.ID, matchToFind.ID)
+		natsServer, err := ConnectToNats()
+		if err != nil {
+			return err
+		}
+		defer natsServer.Nc.Close()
+		if err := natsServer.ConfirmCancel(&emailContent); err != nil {
+			// hier warten und nochmal versuchen zu senden
+			order.Cancelnotified = false
+			err := fmt.Errorf("error sending confirm email: %v", err)
+			return err
+		}
+	}
+
 	natsServer, err := ConnectToNats()
+	if err != nil {
+		return err
+	}
+
 	defer natsServer.Nc.Close()
 
-	emailContent := model.EmialContent{Name: order.User.Name, AwayMatch: matchToFind.AwayMatch, Location: matchToFind.Location, Date: matchToFind.Date, Emailadress: order.User.Email, OrderID: matchToFind.ID.String()}
 	if err := natsServer.ConfirmOrder(&emailContent); err != nil {
 		// hier warten und nochmal versuchen zu senden
 		order.Ordernotified = false
-		return fmt.Errorf("error sending confirm email %v", err)
+		err = fmt.Errorf("error sending confirm email: %v", err)
+		return err
 	} else {
 		order.Ordernotified = true
 	}
 
-	updaterNotification := bson.D{primitive.E{Key: "$set", Value: bson.D{
-		primitive.E{Key: "orders.$[element]", Value: order},
-	}}}
-
-	options := options.Update().SetArrayFilters(options.ArrayFilters{
-		Filters: []interface{}{
-			bson.D{{Key: "element._id", Value: order.ID}},
-		},
-	})
-
 	updateNotification, err := collection.UpdateOne(context.TODO(), filter, updaterNotification, options)
 	if err != nil {
-		return fmt.Errorf("no document was updated, please send order again")
+		err = fmt.Errorf("no document was updated, please send order again")
+		return err
 	}
 
 	if updateNotification.ModifiedCount == 0 {
-		return fmt.Errorf("no document was updated, please send order again")
+		err = fmt.Errorf("no document was updated, please send order again")
+		return err
 	}
 
 	return nil
 }
 
-var isMatchOrder bool = true
-
 func CancelOrder(matchID primitive.ObjectID, order *model.Order) error {
+	fmt.Println("order", order)
+	if order.Canceled == true {
+		return fmt.Errorf("order already canceled")
+	}
 	filter := bson.D{primitive.E{Key: "_id", Value: matchID}}
 	matchToFind, err := GetMatchByID(matchID)
 	if err != nil {
 		return err
+	} else {
+		matchToFind.AvailableTicketAmount = matchToFind.AvailableTicketAmount + order.Amount
 	}
 
 	client, err := db.GetMongoClient()
@@ -159,10 +129,6 @@ func CancelOrder(matchID primitive.ObjectID, order *model.Order) error {
 		primitive.E{Key: "orders.$[element]", Value: order},
 	}}}
 
-	updaterTravelCancel := bson.D{primitive.E{Key: "$set", Value: bson.D{
-		primitive.E{Key: "travel.orders.$[element]", Value: order},
-	}}}
-
 	options := options.Update().SetArrayFilters(options.ArrayFilters{
 		Filters: []interface{}{
 			bson.D{{Key: "element._id", Value: order.ID}},
@@ -174,15 +140,22 @@ func CancelOrder(matchID primitive.ObjectID, order *model.Order) error {
 		return err
 	}
 	if updateMatchCancel.ModifiedCount == 0 {
-		isMatchOrder = false
-		updateTravelCancel, err := collection.UpdateOne(context.TODO(), filter, updaterTravelCancel, options)
+		return fmt.Errorf("not updated")
+
+	}
+
+	_, errUpdateAmount := UpdateMatch(matchToFind.ID, matchToFind)
+	if errUpdateAmount != nil {
+		order.Canceled = false
+		updateMatchCancel, err := collection.UpdateOne(context.TODO(), filter, updaterMatchCancel, options)
 		if err != nil {
 			return err
 		}
-		if updateTravelCancel.ModifiedCount == 0 {
-			return fmt.Errorf("orderid not in system")
-		}
+		if updateMatchCancel.ModifiedCount == 0 {
+			return fmt.Errorf("not updated")
 
+		}
+		return fmt.Errorf("error canceling match internal, please try again %v", err)
 	}
 
 	natsServer, err := ConnectToNats()
@@ -191,41 +164,40 @@ func CancelOrder(matchID primitive.ObjectID, order *model.Order) error {
 	emailContent := model.EmialContent{Name: order.User.Name, AwayMatch: matchToFind.AwayMatch, Location: matchToFind.Location, Date: matchToFind.Date, Emailadress: order.User.Email, OrderID: order.ID.String()}
 	if err := natsServer.ConfirmCancel(&emailContent); err != nil {
 		return fmt.Errorf("error sending confirm email %v", err)
+	} else {
+		order.Cancelnotified = true
 	}
 
-	order.Cancelnotified = true
-
-	if isMatchOrder == false {
-		updateTravelCancelNotifi, err := collection.UpdateOne(context.TODO(), filter, updaterTravelCancel, options)
-		if err != nil {
-			return err
-		}
-		if updateTravelCancelNotifi.ModifiedCount == 0 {
-			return fmt.Errorf("orderid not in system")
-		}
-		isMatchOrder = true
-	} else {
-		updateMatchCancelNotifi, err := collection.UpdateOne(context.TODO(), filter, updaterMatchCancel, options)
-		if err != nil {
-			return err
-		}
-		if updateMatchCancelNotifi.ModifiedCount == 0 {
-			return fmt.Errorf("orderid not in system")
-		}
+	updateMatchCancelNotifi, err := collection.UpdateOne(context.TODO(), filter, updaterMatchCancel, options)
+	if err != nil {
+		return err
+	}
+	if updateMatchCancelNotifi.ModifiedCount == 0 {
+		return fmt.Errorf("orderid not in system")
 	}
 	return nil
 
 }
-func deleteOrder(orderID primitive.ObjectID) error {
-	filter := bson.D{primitive.E{Key: "_id", Value: orderID}}
+
+func deleteOrder(matchID primitive.ObjectID, orderID primitive.ObjectID) error {
+	filter := bson.D{primitive.E{Key: "_id", Value: matchID}}
+	updater := bson.D{primitive.E{Key: "$pull", Value: bson.D{
+		primitive.E{Key: "orders", Value: bson.D{
+			primitive.E{Key: "_id", Value: orderID},
+		}},
+	}}}
+
 	client, err := db.GetMongoClient()
 	if err != nil {
 		return err
 	}
+
 	collection := client.Database(db.DB).Collection(db.MATCHES)
-	_, err = collection.DeleteOne(context.TODO(), filter)
+
+	_, err = collection.UpdateOne(context.TODO(), filter, updater)
 	if err != nil {
 		return err
 	}
+
 	return nil
 }