- minor bug fix

Author: DanielFillol

controllers/crud.go

@@ -1,7 +1,6 @@
 package controllers
 
 import (
-	"github.com/Darklabel91/API_Names/database"
 	"github.com/Darklabel91/API_Names/models"
 	"github.com/gin-gonic/gin"
 	"net/http"
@@ -81,26 +80,29 @@ func GetName(c *gin.Context) {
 
 //GetMetaphoneMatch read name by metaphone
 func GetMetaphoneMatch(c *gin.Context) {
+	var nameType models.NameType
+
 	//Check the cache
 	var preloadTable []models.NameType
 	cache, existKey := c.Get("nameTypes")
 	if existKey {
 		preloadTable = cache.([]models.NameType)
 	} else {
-		if err := database.DB.Find(&preloadTable).Error; err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to preload nameTypes"})
+		allNames, err := nameType.GetAllNames()
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"Message": "Error on caching all name types"})
 			return
 		}
+		preloadTable = allNames
 	}
 
 	//name to be searched
 	name := c.Params.ByName("name")
 
 	//search similar names
-	var nameType models.NameType
 	canonicalEntity, err := nameType.GetSimilarMatch(name, preloadTable)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"Message": err})
+		c.JSON(http.StatusNotFound, gin.H{"Message": "Couldn't find canonical entity"})
 		return
 	}
 

models/name.go

@@ -3,9 +3,7 @@ package models
 import (
 	"errors"
 	"github.com/Darklabel91/metaphone-br"
-	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"net/http"
 	"strings"
 )
 
@@ -80,19 +78,19 @@ func (n *NameType) GetSimilarMatch(name string, allNames []NameType) (*NameType,
 
 	//1- get the exact metaphone match
 	metaphoneNameMatches := n.SearchCacheMetaphone(nameMetaphone, allNames)
-	//case we don't find the exact match of metaphone we search all similar metaphones
+	//case we don't find the exact match of metaphone we search all similar metaphone
 	if len(metaphoneNameMatches) == 0 {
 		//get all similar metaphone code
 		metaphoneNameMatches = n.SearchSimilarMetaphone(nameMetaphone, allNames)
 		if len(metaphoneNameMatches) == 0 {
-			return nil, err
+			return nil, errors.New("no metaphone matches found")
 		}
 	}
 
 	//2- get all similar names by metaphone list
 	similarNames := n.SearchSimilarNames(name, metaphoneNameMatches, LEVENSHTEIN)
 	if len(similarNames) == 0 {
-		return nil, err
+		return nil, errors.New("no similar name matches")
 	}
 	//case similarNames is too small we search for all similar names of all similar names listed so far
 	if len(similarNames) < 5 {
@@ -175,16 +173,25 @@ func (*NameType) SearchSimilarNames(paradigmName string, allNames []NameType, th
 func (*NameType) SearchCanonicalName(paradigmName string, threshold float32, allNames []NameType, matchingMetaphoneNames []NameType, nameVariations []string) (*NameType, error) {
 	n := strings.ToUpper(paradigmName)
 
+	//transform the nameVariations into a string to be returned
+	var rNv string
+	for _, nv := range nameVariations {
+		rNv += nv + " | "
+	}
+
 	//search exact match on matchingMetaphoneNames
 	for _, similarName := range matchingMetaphoneNames {
 		if similarName.Name == n {
+			similarName.NameVariations = rNv
 			return &similarName, nil
 		}
 	}
 
 	//search for similar names on matchingMetaphoneNames
 	for _, similarName := range matchingMetaphoneNames {
-		if metaphone.SimilarityBetweenWords(n, strings.ToUpper(similarName.Name)) >= threshold {
+		sn := strings.ToUpper(similarName.NameVariations)
+		if metaphone.SimilarityBetweenWords(n, sn) >= threshold {
+			similarName.NameVariations = rNv
 			return &similarName, nil
 		}
 	}
@@ -195,32 +202,40 @@ func (*NameType) SearchCanonicalName(paradigmName string, threshold float32, all
 		if sn == n {
 			for _, name := range allNames {
 				if name.Name == n {
+					name.NameVariations = rNv
 					return &name, nil
 				}
 			}
 		}
 	}
 
-	return &NameType{}, errors.New("couldn't find canonical name")
-}
-
-func (*NameType) CachingNameTypes(nameTypesCache []NameType) gin.HandlerFunc {
-	var name NameType
-
-	if nameTypesCache == nil {
-		nameTypes, err := name.GetAllNames()
-		if err != nil {
-			return func(c *gin.Context) {
-				c.JSON(http.StatusInternalServerError, gin.H{"Message": "Error on caching all name types"})
+	//search for similar names on nameVariations
+	for _, similarName := range nameVariations {
+		sn := strings.ToUpper(similarName)
+		if metaphone.SimilarityBetweenWords(n, sn) >= threshold {
+			for _, name := range allNames {
+				if name.Name == sn {
+					name.NameVariations = rNv
+					return &name, nil
+				}
 			}
 		}
-		nameTypesCache = nameTypes
 	}
 
-	return func(c *gin.Context) {
-		c.Set("nameTypes", nameTypesCache)
-		c.Next()
+	//case none are found we establish a return similarity for names 0.1 bellow the original threshold
+	for _, similarName := range nameVariations {
+		sn := strings.ToUpper(similarName)
+		if metaphone.SimilarityBetweenWords(n, sn) >= threshold-0.1 {
+			for _, name := range allNames {
+				if name.Name == sn {
+					name.NameVariations = rNv
+					return &name, nil
+				}
+			}
+		}
 	}
+
+	return &NameType{}, errors.New("couldn't find canonical name")
 }
 
 func (*NameType) SearchCacheName(name string, cache []NameType) (*NameType, bool) {

routes/routes.go

@@ -5,13 +5,14 @@ import (
 	"github.com/Darklabel91/API_Names/middlewares"
 	"github.com/Darklabel91/API_Names/models"
 	"github.com/gin-gonic/gin"
+	"net/http"
 	"os"
 	"time"
 )
 
 const DOOR = ":8080"
 const FILENAME = "Logs.txt"
-const SECONDS = 10
+const MICROSECONDS = 300
 
 var nameTypesCache []models.NameType
 
@@ -34,7 +35,7 @@ func HandleRequests() {
 
 	//upload the log file from time to time
 	var log models.Log
-	ticker := time.NewTicker(SECONDS * time.Second)
+	ticker := time.NewTicker(MICROSECONDS * time.Microsecond)
 	defer ticker.Stop()
 	log.UploadLog(ticker, FILENAME)
 
@@ -49,16 +50,32 @@ func HandleRequests() {
 	r.POST("/name", middlewares.ValidateName(), middlewares.ValidateNameJSON(), controllers.CreateName)
 	r.GET("/:id", middlewares.ValidateID(), controllers.GetID)
 	r.GET("/name/:name", middlewares.ValidateName(), controllers.GetName)
+	r.GET("/metaphone/:name", middlewares.ValidateName(), cachingNameTypes(nameTypesCache), controllers.GetMetaphoneMatch)
 	r.PATCH("/:id", middlewares.ValidateID(), middlewares.ValidateNameJSON(), controllers.UpdateName)
 	r.DELETE("/:id", middlewares.ValidateID(), controllers.DeleteName)
 
-	//special route to search with metaphone
-	var nameType models.NameType
-	r.GET("/metaphone/:name", middlewares.ValidateName(), nameType.CachingNameTypes(nameTypesCache), controllers.GetMetaphoneMatch)
-
 	// run
 	err = r.Run(DOOR)
 	if err != nil {
 		return
 	}
 }
+
+func cachingNameTypes(nameTypesCache []models.NameType) gin.HandlerFunc {
+	var name models.NameType
+
+	if nameTypesCache == nil {
+		nameTypes, err := name.GetAllNames()
+		if err != nil {
+			return func(c *gin.Context) {
+				c.JSON(http.StatusInternalServerError, gin.H{"Message": "Error on caching all name types"})
+			}
+		}
+		nameTypesCache = nameTypes
+	}
+
+	return func(c *gin.Context) {
+		c.Set("nameTypes", nameTypesCache)
+		c.Next()
+	}
+}