- create user endpoint;

- login endpoint;
- use of jwt for authenticate users
- create middleware for all other endpoint's
- use init to start the database

Author: DanielFillol

controllers/controller.go

@@ -6,13 +6,120 @@ import (
 	"github.com/Darklabel91/API_Names/models"
 	Metaphone "github.com/Darklabel91/metaphone-br"
 	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
 	"net/http"
+	"os"
 	"sort"
+	"strconv"
 	"strings"
+	"time"
 )
 
 const levenshtein = 0.8
 
+//Signup a new user to the database
+func Signup(c *gin.Context) {
+	//get email/pass off req body
+	var body struct {
+		Email    string
+		Password string
+	}
+
+	if c.Bind(&body) != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Failed to read body"})
+		return
+	}
+
+	//hash the password
+	hash, err := bcrypt.GenerateFromPassword([]byte(body.Password), 10)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Failed to hash password"})
+		return
+	}
+
+	//create the user
+	user := models.User{Email: body.Email, Password: string(hash)}
+	result := database.Db.Create(&user)
+
+	if result.Error != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Email already registered"})
+		return
+	}
+
+	//respond
+	c.JSON(http.StatusOK, gin.H{"Message": "User created", "User": user})
+}
+
+//Login verifies cookie session for login
+func Login(c *gin.Context) {
+	// Get the email and password from request body
+	var body struct {
+		Email    string
+		Password string
+	}
+
+	if c.Bind(&body) != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Failed to read body"})
+		return
+	}
+
+	// Look up requested user
+	var user models.User
+	database.Db.First(&user, "email = ?", body.Email)
+
+	if user.ID == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Invalid email or password"})
+		return
+	}
+
+	// Compare sent-in password with saved user password hash
+	err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(body.Password))
+
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"Message": "Invalid email or password"})
+		return
+	}
+
+	// Generate JWT token
+	token, err := generateJWTToken(user.ID, 1)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"Message": "Failed to generate token"})
+		return
+	}
+
+	// Set token as a cookie
+	c.SetCookie("token", token, 60*60, "/", "", false, true)
+
+	// Return success response
+	c.JSON(http.StatusOK, gin.H{"Token": token})
+}
+
+//generateJWTToken generates a JWT token with a specified expiration time and user ID. It first sets the token expiration time based on the amountDays parameter passed into the function.
+func generateJWTToken(userID uint, amountDays time.Duration) (string, error) {
+	// Set token expiration time
+	expirationTime := time.Now().Add(amountDays * 24 * time.Hour)
+
+	// Create JWT claims
+	claims := jwt.RegisteredClaims{
+		ExpiresAt: jwt.NewNumericDate(expirationTime),
+		IssuedAt:  jwt.NewNumericDate(time.Now()),
+		Subject:   strconv.Itoa(int(userID)),
+	}
+
+	// Create token using claims and signing method
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+
+	// Sign token using secret key
+	secretKey := []byte(os.Getenv("SECRET"))
+	signedToken, err := token.SignedString(secretKey)
+	if err != nil {
+		return "", errors.New("Failed to sign token")
+	}
+
+	return signedToken, nil
+}
+
 //CreateName create new name on database of type NameType
 func CreateName(c *gin.Context) {
 	var name models.NameType
@@ -43,24 +150,31 @@ func GetID(c *gin.Context) {
 //DeleteName delete name off database by id
 func DeleteName(c *gin.Context) {
 	var name models.NameType
+
 	id := c.Params.ByName("id")
+	database.Db.First(&name, id)
 
 	if name.ID == 0 {
 		c.JSON(http.StatusNotFound, gin.H{"Not found": "name id not found"})
 		return
 	}
 
 	database.Db.Delete(&name, id)
-	c.JSON(http.StatusOK, gin.H{"data": "name data deleted"})
+	c.JSON(http.StatusOK, gin.H{"Delete": "name id " + id + " was deleted"})
 }
 
 //UpdateName update name by id
 func UpdateName(c *gin.Context) {
 	var name models.NameType
-	id := c.Param("id")
 
+	id := c.Param("id")
 	database.Db.First(&name, id)
 
+	if name.ID == 0 {
+		c.JSON(http.StatusNotFound, gin.H{"Not found": "name id not found"})
+		return
+	}
+
 	if err := c.ShouldBindJSON(&name); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
@@ -146,7 +260,7 @@ func SearchSimilarNames(c *gin.Context) {
 	c.JSON(200, r)
 }
 
-/*-------ALL BELLOW USED ONLY ON searchSimilarNames-------*/
+/*---------- used on SearchSimilarNames ----------*/
 
 //searchForAllSimilarMetaphone used in case of not finding exact metaphone match
 func searchForAllSimilarMetaphone(mtf string) []models.NameType {
@@ -204,8 +318,8 @@ func findCanonical(name string, matchingMetaphoneNames []models.NameType, nameVa
 	return models.NameType{}, errors.New("couldn't find canonical name")
 }
 
-//findNames return []models.NameVar with all similar names of searched string. For recall purpose we reduce the threshold given in 0.1 in case of empty return
-func findNames(names []models.NameType, name string, threshold float32) []models.NameVar {
+//findNames return []models.NameLevenshtein with all similar names of searched string. For recall purpose we reduce the threshold given in 0.1 in case of empty return
+func findNames(names []models.NameType, name string, threshold float32) []models.NameLevenshtein {
 	similarNames := findSimilarNames(name, names, threshold)
 	//reduce the threshold given in 0.1 and search again
 	if len(similarNames) == 0 {
@@ -216,17 +330,17 @@ func findNames(names []models.NameType, name string, threshold float32) []models
 }
 
 //findSimilarNames loop for all names given checking the similarity between words by a given threshold, called on findNames
-func findSimilarNames(name string, names []models.NameType, threshold float32) []models.NameVar {
-	var similarNames []models.NameVar
+func findSimilarNames(name string, names []models.NameType, threshold float32) []models.NameLevenshtein {
+	var similarNames []models.NameLevenshtein
 
 	for _, n := range names {
 		similarity := Metaphone.SimilarityBetweenWords(strings.ToLower(name), strings.ToLower(n.Name))
 		if similarity >= threshold {
-			similarNames = append(similarNames, models.NameVar{Name: n.Name, Levenshtein: similarity})
+			similarNames = append(similarNames, models.NameLevenshtein{Name: n.Name, Levenshtein: similarity})
 			varWords := strings.Split(n.NameVariations, "|")
 			for _, vw := range varWords {
 				if vw != "" {
-					similarNames = append(similarNames, models.NameVar{Name: vw, Levenshtein: similarity})
+					similarNames = append(similarNames, models.NameLevenshtein{Name: vw, Levenshtein: similarity})
 				}
 			}
 		}
@@ -236,9 +350,9 @@ func findSimilarNames(name string, names []models.NameType, threshold float32) [
 }
 
 //orderByLevenshtein used to sort an array by Levenshtein and len of the name
-func orderByLevenshtein(arr []models.NameVar) []string {
+func orderByLevenshtein(arr []models.NameLevenshtein) []string {
 	// creates copy of original array
-	sortedArr := make([]models.NameVar, len(arr))
+	sortedArr := make([]models.NameLevenshtein, len(arr))
 	copy(sortedArr, arr)
 
 	// order by func

database/create_database.txt

@@ -1,18 +1,35 @@
 package database
 
 import (
+	"encoding/csv"
+	"errors"
 	"fmt"
 	"github.com/Darklabel91/API_Names/models"
+	"github.com/Darklabel91/metaphone-br"
 	"github.com/joho/godotenv"
+	"golang.org/x/crypto/bcrypt"
 	"gorm.io/driver/mysql"
 	"gorm.io/gorm"
+	"io"
 	"os"
+	"time"
 )
 
 var Db *gorm.DB
 
 func InitDb() *gorm.DB {
 	Db = connectDB()
+
+	err := createRoot()
+	if err != nil {
+		return nil
+	}
+
+	err = uploadCSVNameTypes()
+	if err != nil {
+		return nil
+	}
+
 	return Db
 }
 
@@ -32,15 +49,30 @@ func connectDB() *gorm.DB {
 		DbPort     = os.Getenv("DB_PORT")
 	)
 
+	//create database
+	err = createDatabase(DbHost, DbUsername, DbPassword, DbName)
+	if err != nil {
+		fmt.Printf("Error on gorm creating database : error=%v\n", err)
+		return nil
+	}
+
 	dsn := DbUsername + ":" + DbPassword + "@tcp" + "(" + DbHost + ":" + DbPort + ")/" + DbName + "?" + "parseTime=true&loc=Local"
 	fmt.Println("dsn : ", dsn)
-	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
 
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
 	if err != nil {
 		fmt.Printf("Error connecting to database : error=%v\n", err)
 		return nil
 	}
 
+	//create table users
+	err = db.AutoMigrate(&models.User{})
+	if err != nil {
+		fmt.Printf("Error on gorm auto migrate to database : error=%v\n", err)
+		return nil
+	}
+
+	//create table name_type
 	err = db.AutoMigrate(&models.NameType{})
 	if err != nil {
 		fmt.Printf("Error on gorm auto migrate to database : error=%v\n", err)
@@ -49,3 +81,112 @@ func connectDB() *gorm.DB {
 
 	return db
 }
+
+func createDatabase(host, username, password, dbName string) error {
+	fmt.Println("cra")
+	// Set up the MySQL DSN string
+	dsn := fmt.Sprintf("%s:%s@tcp(%s)/?charset=utf8mb4&parseTime=True&loc=Local", username, password, host)
+
+	// Open a connection to the MySQL server
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
+	if err != nil {
+		return fmt.Errorf("failed to connect to MySQL: %v", err)
+	}
+
+	// Check if the database already exists
+	var result int64
+	db.Raw("SELECT COUNT(*) FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", dbName).Scan(&result)
+	if result > 0 {
+		fmt.Println("database already exists")
+		return nil
+	}
+
+	// Create the database
+	fmt.Println("creating database")
+	err = db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbName)).Error
+	if err != nil {
+		return fmt.Errorf("failed to create database: %v", err)
+	}
+
+	return nil
+}
+
+func createRoot() error {
+	var user models.User
+	Db.First(&user, 1)
+
+	if user.ID == 0 {
+		fmt.Println("creating user root")
+
+		//password
+		hash, err := bcrypt.GenerateFromPassword([]byte(os.Getenv("SECRET")), 10)
+		if err != nil {
+			return err
+		}
+
+		userRoot := models.User{
+			Email:    "[email protected]",
+			Password: string(hash),
+		}
+
+		Db.Create(&userRoot)
+
+		fmt.Println("root user created")
+
+		return nil
+	} else {
+		fmt.Println("root user already on the database")
+		return nil
+	}
+}
+
+func uploadCSVNameTypes() error {
+	var name models.NameType
+	Db.Raw("SELECT * FROM name_types WHERE id = 1").Find(&name)
+
+	if name.ID == 0 {
+		start := time.Now()
+		fmt.Println("initiating csv upload to the database")
+
+		filePath := "database/name_types .csv"
+		file, err := os.Open(filePath)
+		if err != nil {
+			return errors.New("Error opening file:" + err.Error())
+
+		}
+		defer file.Close()
+
+		reader := csv.NewReader(file)
+		var rows [][]string
+		for {
+			row, err := reader.Read()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return errors.New("error reading CSV:" + err.Error())
+			}
+			rows = append(rows, row)
+		}
+
+		for i, row := range rows {
+			if i != 0 {
+				nameType := models.NameType{
+					Name:           row[0],
+					Classification: row[1],
+					Metaphone:      metaphone.Pack(row[0]),
+					NameVariations: row[3],
+				}
+				if err = Db.Create(&nameType).Error; err != nil {
+					return errors.New("error creating NameType:" + err.Error())
+				}
+			}
+		}
+
+		fmt.Println("csv upload finished in:" + time.Since(start).String())
+		return nil
+	}
+	fmt.Println("csv already imported")
+	return nil
+
+}