Skip to content
Snippets Groups Projects
Commit ee59aa75 authored by Yege1893's avatar Yege1893
Browse files

user registration

parent 5f1bde76
No related branches found
No related tags found
1 merge request!4Master
......@@ -2,8 +2,6 @@ package handler
import (
"context"
"encoding/json"
"fmt"
"net/http"
log "github.com/sirupsen/logrus"
......@@ -28,52 +26,6 @@ func HandleCallback(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Fehler beim Authentifizieren", http.StatusInternalServerError)
return
}
// Verwende das Token, um auf die Google API zuzugreifen oder speichere es für spätere Verwendung
// token.AccessToken enthält den Zugriffstoken
// token.RefreshToken enthält den Aktualisierungstoken
h, err := service.ValidateGoogleAccessToken(token.AccessToken)
if err != nil {
fmt.Printf("Fehler bei der Überprüfung des Tokens: %s\n", err.Error())
} else if h {
fmt.Println("Der Access Token ist gültig.")
} else {
fmt.Println("Der Access Token ist ungültig.")
}
fmt.Fprintf(w, "Token %s", token.AccessToken)
fmt.Fprintf(w, "Token %s", token.RefreshToken)
// Beispiel: Drucke den Namen des authentifizierten Benutzers
client := oauthConfig.Client(context.Background(), token)
response, err := client.Get("https://www.googleapis.com/oauth2/v2/userinfo")
if err != nil {
log.Println("Fehler beim Abrufen der Benutzerinfo:", err)
http.Error(w, "Fehler beim Abrufen der Benutzerinfo", http.StatusInternalServerError)
return
}
defer response.Body.Close()
// Lese die Benutzerinfo als JSON-Daten
var userinfo struct {
Email string `json:"email"`
ID string `json:"id"`
Namen string `json:"name"`
GivenName string `json:"given_name"`
FamilyName string `json:"family_name"`
Locale string `json:"locale"`
}
err = json.NewDecoder(response.Body).Decode(&userinfo)
if err != nil {
log.Println("Fehler beim Lesen der Benutzerinfo:", err)
http.Error(w, "Fehler beim Lesen der Benutzerinfo", http.StatusInternalServerError)
return
}
// Hier kannst du die E-Mail-Adresse des Benutzers verwenden
fmt.Fprintf(w, "E-Mail-Adresse: %s", userinfo.Email)
fmt.Fprintf(w, "ID: %s", userinfo.ID)
fmt.Fprintf(w, "Name: %s", userinfo.Namen)
fmt.Fprintf(w, "FamilyName: %s", userinfo.FamilyName)
fmt.Fprintf(w, "GivenName: %s", userinfo.GivenName)
fmt.Fprintf(w, "Locale: %s", userinfo.Locale)
service.Register(token.AccessToken)
sendJson(w, token.AccessToken)
}
package model
import "go.mongodb.org/mongo-driver/bson/primitive"
type User struct {
FirstName string
LastName string
Role string
ID primitive.ObjectID `bson:"_id, omitempty"`
Email string `json:"email" bson:"email"`
GoogleID string `json:"id" bson:"google_id"`
Name string `json:"name" bson:"name"`
FamilyName string `json:"family_name" bson:"family_name"`
IsAdmin bool `json:"is_admin" bson:"is_admin"`
}
......@@ -29,28 +29,6 @@ func CreateMatch(match *model.Match) error {
return nil
}
// noch testen nur intern für anbindung an die api
/*func CreateMatches(list *[]model.Match) error {
insertableList := make([]interface{}, len(*list))
for i, v := range *list {
insertableList[i] = v
}
client, err := db.GetMongoClient()
if err != nil {
return err
}
collection := client.Database(db.DB).Collection(db.MATCHES)
_, err = collection.InsertMany(context.TODO(), insertableList)
if err != nil {
return err
}
return nil
}*/
func UpdateMatch(matchID primitive.ObjectID, match *model.Match) (*model.Match, error) {
result := model.Match{}
existingMatch, err := GetMatchByID(matchID)
......
......@@ -5,6 +5,8 @@ import (
"fmt"
"io/ioutil"
"net/http"
"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/model"
)
func ValidateGoogleAccessToken(accessToken string) (bool, error) {
......@@ -45,3 +47,32 @@ func ValidateGoogleAccessToken(accessToken string) (bool, error) {
return false, nil
}
func GetUserInfo(accessToken string) (model.User, error) {
var userInfo model.User
client := &http.Client{}
req, err := http.NewRequest("GET", "https://www.googleapis.com/oauth2/v1/userinfo", nil)
if err != nil {
return userInfo, err
}
req.Header.Set("Authorization", "Bearer "+accessToken)
resp, err := client.Do(req)
if err != nil {
return userInfo, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return userInfo, err
}
err = json.Unmarshal(body, &userInfo)
if err != nil {
return userInfo, err
}
return userInfo, nil
}
package service
import (
"fmt"
)
func Register(accessToken string) error {
user, err := GetUserInfo(accessToken)
if err != nil {
return err
}
fmt.Println(user)
err1 := CreateUser(&user)
if err1 != nil {
return err1
}
/*var userArray []model.User
userArray, _ = GetAllUsers()
fmt.Println(userArray)*/
return nil
}
package service
import (
"context"
"fmt"
"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/db"
"gitlab.reutlingen-university.de/ege/highlander-ticketing-go-ss2023/src/highlanderticketing/model"
"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"
)
var isFirstCall = true
func CreateUser(user *model.User) error {
if isFirstCall == false {
user.IsAdmin = false
} else if isFirstCall == true {
users, err := GetAllUsers()
if err != nil {
return err
}
if len(users) == 0 {
user.IsAdmin = true
} else {
user.IsAdmin = false
}
isFirstCall = false
}
user.ID = primitive.NewObjectID()
client, err := db.GetMongoClient()
if err != nil {
return err
}
filter := bson.D{primitive.E{Key: "email", Value: user.Email}}
update := bson.M{
"$setOnInsert": bson.M{
"_id": user.ID,
"email": user.Email,
"google_id": user.GoogleID,
"name": user.Name,
"family_name": user.FamilyName,
"is_admin": user.IsAdmin,
},
}
collection := client.Database(db.DB).Collection(db.USERS)
options := options.FindOneAndUpdate().SetUpsert(true)
result := collection.FindOneAndUpdate(context.TODO(), filter, update, options)
if result.Err() == mongo.ErrNoDocuments {
return nil // dokument wurd erstellt
} else if result.Err() != nil {
return result.Err() // fehler beim process an sich
} else {
return nil // erstellt oder nicht aktualisiert
}
}
func UpdateUser(userID primitive.ObjectID, user *model.User) (*model.User, error) { //darf nur ein admin machen
result := model.User{}
existingUser, err := GetUserByID(userID)
if existingUser == nil || err != nil {
return existingUser, err
}
filter := bson.D{primitive.E{Key: "_id", Value: userID}}
updater := bson.D{primitive.E{Key: "$set", Value: bson.D{
primitive.E{Key: "email", Value: user.Email},
primitive.E{Key: "google_id", Value: user.GoogleID},
primitive.E{Key: "name", Value: user.Name},
primitive.E{Key: "family_name", Value: user.FamilyName},
primitive.E{Key: "is_admin", Value: user.IsAdmin},
}}}
client, err := db.GetMongoClient()
if err != nil {
return nil, err
}
collection := client.Database(db.DB).Collection(db.MATCHES)
updateResult, err := collection.UpdateOne(context.TODO(), filter, updater)
if err != nil {
return nil, err
}
if updateResult.ModifiedCount == 0 {
return nil, fmt.Errorf("no document was updated")
}
err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
return nil, err
}
return &result, nil
}
func GetAllUsers() ([]model.User, error) {
filter := bson.D{{}}
users := []model.User{}
client, err := db.GetMongoClient()
if err != nil {
return users, err
}
collection := client.Database(db.DB).Collection(db.USERS)
cur, err := collection.Find(context.TODO(), filter)
if err != nil {
return users, err
}
defer cur.Close(context.TODO())
for cur.Next(context.TODO()) {
var user model.User
if err := cur.Decode(&user); err != nil {
return users, err
}
users = append(users, user)
}
if len(users) == 0 {
return users, mongo.ErrNoDocuments
}
return users, nil
}
func GetUserByID(userID primitive.ObjectID) (*model.User, error) {
result := model.User{}
filter := bson.D{primitive.E{Key: "_id", Value: userID}}
client, err := db.GetMongoClient()
if err != nil {
return &result, err
}
collection := client.Database(db.DB).Collection(db.USERS)
err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
return &result, err
}
return &result, nil
}
func DeleteUser(UserID primitive.ObjectID) error {
filter := bson.D{primitive.E{Key: "_id", Value: UserID}}
client, err := db.GetMongoClient()
if err != nil {
return err
}
collection := client.Database(db.DB).Collection(db.USERS)
_, err = collection.DeleteOne(context.TODO(), filter)
if err != nil {
return err
}
return nil
}
func DeleteAllUsers() error {
selector := bson.D{{}}
client, err := db.GetMongoClient()
if err != nil {
return err
}
collection := client.Database(db.DB).Collection(db.USERS)
_, err = collection.DeleteMany(context.TODO(), selector)
if err != nil {
return err
}
return nil
}
......@@ -8,3 +8,4 @@
- google oauth2 anbinden
- schauen wie thread save machen (evtl. mit abfrage von api)
- api anbinden
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment