- improve comments all around

- minor change on requireAuth, now there is a specific function to deal with the rate limit
- minor bug fix on UpdateName in crud file

Author: DanielFillol

controllers/crud.go

@@ -9,57 +9,62 @@ import (
 	"sync"
 )
 
-//CreateName create new name on database of type NameType
+//CreateName creates a new name in the database of type NameType
 func CreateName(c *gin.Context) {
-	//name is passed by middlewares
+	// The name is passed by middlewares
 	nameValue, ok := c.Get("name")
 	if !ok {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "name is not present on middlewares"})
 		return
 	}
 
-	//parse nameValue into models.NameTypeInput
+	// Parse nameValue into models.NameTypeInput
 	var input models.NameType
 	input, ok = nameValue.(models.NameType)
 	if !ok {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "failed to parse name"})
 		return
 	}
 
-	//Check the cache
+	// Check the cache
 	preloadTable := checkCache(c)
 
-	//Check if there's an exact name on the database
+	// Check if there's an exact name on the database
 	for _, name := range preloadTable {
 		if name.Name == input.Name {
 			c.JSON(http.StatusBadRequest, gin.H{"Message": " Duplicate entry " + name.Name})
 			return
 		}
 	}
 
-	//create name
+	// Create name
 	n, err := input.CreateName()
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"Error": err.Error()})
 		return
 	}
 
+	// Clear cache
 	clearCache(c)
+
+	// Return successful response
 	c.JSON(http.StatusOK, n)
 	return
 }
 
-//GetID read name by id
+//GetID reads a name by id
 func GetID(c *gin.Context) {
 	var name models.NameType
 
+	// Convert id string into int
 	param := c.Params.ByName("id")
 	id, err := strconv.Atoi(param)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"Id": "error on converting id"})
 		return
 	}
 
+	// Get the name by id
 	n, _, err := name.GetNameById(id)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"Not found": "name id not found"})
@@ -70,14 +75,19 @@ func GetID(c *gin.Context) {
 		return
 	}
 
+	// Return successful response
 	c.JSON(http.StatusOK, n)
+	return
 }
 
-//GetName read name by name
+//GetName reads a name by name
 func GetName(c *gin.Context) {
 	var name models.NameType
 
+	// Get name to be searched
 	param := c.Params.ByName("name")
+
+	// Search for name
 	n, err := name.GetNameByName(strings.ToUpper(param))
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"Not found": "name not found"})
@@ -88,42 +98,43 @@ func GetName(c *gin.Context) {
 		return
 	}
 
+	// Return successful response
 	c.JSON(http.StatusOK, n)
 	return
 }
 
-//GetMetaphoneMatch read name by metaphone
+//GetMetaphoneMatch reads a name by metaphone
 func GetMetaphoneMatch(c *gin.Context) {
 	var nameType models.NameType
 
-	//name to be searched
+	// Get name to be searched
 	name := c.Params.ByName("name")
 
-	//Check the cache
+	// Check the cache
 	preloadTable := checkCache(c)
 
-	//search similar names
+	// Search for similar names
 	canonicalEntity, err := nameType.GetSimilarMatch(name, preloadTable)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"Message": "Couldn't find canonical entity"})
 		return
-	} else {
-		c.JSON(200, canonicalEntity)
-		return
 	}
+
+	// Return successful response
+	c.JSON(200, canonicalEntity)
+	return
 }
 
-//UpdateName update name by id
+// UpdateName updates name by id
 func UpdateName(c *gin.Context) {
-	//convert id string into int
+	// Convert id string into int
 	param := c.Params.ByName("id")
 	id, err := strconv.Atoi(param)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"Id": "error on converting id"})
 		return
 	}
-
-	//get the name by id
+	// Get the name by id
 	var n models.NameType
 	name, db, err := n.GetNameById(id)
 	if err != nil {
@@ -135,62 +146,68 @@ func UpdateName(c *gin.Context) {
 		return
 	}
 
-	//name is passed by middlewares
+	// Name is passed by middlewares
 	nameValue, ok := c.Get("name")
 	if !ok {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "name is not present on middlewares"})
 		return
 	}
 
-	//parse nameValue into models.NameTypeInput
+	// Parse nameValue into models.NameTypeInput
 	var input models.NameType
 	input, ok = nameValue.(models.NameType)
 	if !ok {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "failed to parse name"})
 		return
 	}
 
+	// Check if input is the same as the name in the database
 	if input.Name == name.Name && input.Classification == name.Classification && input.Metaphone == name.Metaphone && input.NameVariations == name.NameVariations {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "Every item on json is the same on the database id " + param})
 		return
 	} else {
-		if input.Name != "" && input.Name == name.Name {
+		// Update the name properties if they have changed
+		if input.Name != "" && input.Name != name.Name {
 			name.Name = input.Name
 		}
-		if input.Classification != "" && input.Classification == name.Classification {
+		if input.Classification != "" && input.Classification != name.Classification {
 			name.Classification = input.Classification
 		}
-		if input.Metaphone != "" && input.Metaphone == name.Metaphone {
+		if input.Metaphone != "" && input.Metaphone != name.Metaphone {
 			name.Metaphone = input.Metaphone
 		}
-		if input.NameVariations != "" && input.NameVariations == name.NameVariations {
+		if input.NameVariations != "" && input.NameVariations != name.NameVariations {
 			name.NameVariations = input.NameVariations
 		}
 
-		r := db.Save(name)
-		if r.Error != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"Error": r.Error})
+		// Save the updated name to the database
+		if err := db.Save(name).Error; err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"Error": err})
 			return
 		}
 
+		// Return the updated name
 		c.JSON(http.StatusOK, name)
+
+		// Clear the cache
 		clearCache(c)
+
 		return
 	}
-
 }
 
-//DeleteName delete name off database by id
+// DeleteName deletes name off database by id
 func DeleteName(c *gin.Context) {
 	var name models.NameType
-
+	// Convert id string into int
 	param := c.Params.ByName("id")
 	id, err := strconv.Atoi(param)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"Error": "error on converting id"})
 		return
 	}
 
+	// Check if the name with given id exists
 	n, _, err := name.GetNameById(id)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"Not found": "name id not found"})
@@ -201,40 +218,48 @@ func DeleteName(c *gin.Context) {
 		return
 	}
 
-	_, err = name.DeleteNameById(id)
-	if err != nil {
+	// Delete the name from the database
+	if _, err = name.DeleteNameById(id); err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"Not found": "name id not found"})
 		return
 	}
-
-	c.JSON(http.StatusOK, gin.H{"Delete": "id " + param + " was deleted"})
-	clearCache(c)
-	return
 }
 
+// checkCache retrieves the cached name types from the context if they exist, otherwise it retrieves them from the database
 func checkCache(c *gin.Context) []models.NameType {
+	// Initialize a variable for the NameType type
 	var nameType models.NameType
+	// Initialize a variable for the cached name types
 	var preloadTable []models.NameType
-
+	// Get the cached name types from the context
 	cache, existKey := c.Get("nameTypes")
+	// If the name types are found in the cache, set them to the `preloadTable` variable
 	if existKey {
 		preloadTable = cache.([]models.NameType)
 	} else {
+		// If the name types are not found in the cache, retrieve them from the database
 		allNames, err := nameType.GetAllNames()
 		if err != nil {
+			// If there is an error retrieving the name types from the database, return nil
 			c.JSON(http.StatusInternalServerError, gin.H{"Message": "Error on caching all name types"})
 			return nil
 		}
+		// Set the retrieved name types in the cache
 		preloadTable = allNames
 		c.Set("nameTypes", preloadTable)
 	}
 
+	// Return the cached name types
 	return preloadTable
 }
 
+// clearCache deletes the cached name types from the context if they exist
 func clearCache(c *gin.Context) {
+	// Get the cached name types from the context
 	cache, exist := c.Get("nameTypes")
+	// If the name types are found in the cache, delete them
 	if exist {
+		// Convert the cache to a sync.Map so that we can delete the cached name types
 		if cm, ok := cache.(sync.Map); ok {
 			cm.Delete("preloadTable")
 		}

controllers/login.go

@@ -2,50 +2,49 @@ package controllers
 
 import (
 	"errors"
-	"github.com/Darklabel91/API_Names/models"
-	"github.com/gin-gonic/gin"
-	"github.com/golang-jwt/jwt/v5"
-	"golang.org/x/crypto/bcrypt"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
+
+	"github.com/Darklabel91/API_Names/models"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v4"
+	"golang.org/x/crypto/bcrypt"
 )
 
-//Login verifies cookie session for login
+// Login verifies email and password and sets a JWT token as a cookie for authentication
 func Login(c *gin.Context) {
-	// Get the email and password from request body
+	// Get email and password from request body
 	var body models.UserInputBody
-
-	if c.Bind(&body) != nil {
+	if err := c.Bind(&body); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "Failed to read body"})
 		return
 	}
 
-	// Look up requested user
+	// Look up user by email
 	var user models.User
 	u, err := user.GetUserByEmail(body.Email)
 	if err != nil {
 		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(u.Password), []byte(body.Password))
-	if err != nil {
+	// Compare password from request body with user's hashed password
+	if err := bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(body.Password)); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"Message": "Invalid email or password"})
 		return
 	}
 
 	// Generate JWT token
-	token, err := generateJWTToken(u.ID, 1)
+	token, err := generateJWTToken(u.ID, 1*time.Hour*24)
 	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)
+	c.SetCookie("token", token, int(1*time.Hour.Seconds()), "/", "", false, true)
 
 	// Return success response
 	c.JSON(http.StatusOK, gin.H{"Message": "Login successful"})
@@ -57,10 +56,10 @@ func generateJWTToken(userID uint, amountDays time.Duration) (string, error) {
 	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)),
+	claims := jwt.MapClaims{
+		"exp": expirationTime.Unix(),
+		"iat": time.Now().Unix(),
+		"sub": strconv.Itoa(int(userID)),
 	}
 
 	// Create token using claims and signing method