fix: get profile user/staff using token rather than id

internal/utilities/utils/get_or_default.go

@@ -1,34 +0,0 @@
-package utils
-
-import (
-	"os"
-	"reflect"
-	"strconv"
-)
-
-func GetOrDefault[T any](key string, defaultValue T) T {
-	value, exist := os.LookupEnv(key)
-
-	if !exist {
-		return defaultValue
-	}
-
-	var valueInstance T
-	kind := reflect.ValueOf(valueInstance).Kind()
-	switch kind {
-	case reflect.String:
-		return any(value).(T)
-	case reflect.Int:
-		if val, err := strconv.Atoi(value); err == nil {
-			return any(val).(T)
-		}
-		return any(defaultValue).(T)
-	case reflect.Bool:
-		if val, err := strconv.ParseBool(value); err == nil {
-			return any(val).(T)
-		}
-		return any(defaultValue).(T)
-	default:
-		return any(defaultValue).(T)
-	}
-}

internal/utilities/utils/jwt.go

@@ -1,15 +1,18 @@
 package utils
 
 import (
+	"errors"
+	"fmt"
 	"time"
 
+	"legalgo-BE-go/config"
+	authdomain "legalgo-BE-go/internal/domain/auth"
+	jwtclaimenum "legalgo-BE-go/internal/enums/jwt"
 	timeutils "legalgo-BE-go/internal/utilities/time_utils"
 
 	"github.com/golang-jwt/jwt/v5"
 )
 
-var jwtSecret = []byte("secret jwt key") // TODO: change later from env
-
 type ClaimOption func(options jwt.MapClaims)
 
 // func GenerateToken(options ...ClaimOption) (string, error) {
@@ -28,12 +31,60 @@ type ClaimOption func(options jwt.MapClaims)
 // 	return token.SignedString(jwtSecret)
 // }
 
-func GenerateToken(email string) (string, error) {
+func GenerateToken(data authdomain.AuthToken) (string, error) {
 	now := timeutils.Now()
-	token := jwt.New(jwt.SigningMethodHS256)
-	claims := token.Claims.(jwt.MapClaims)
-	claims["email"] = email
-	claims["exp"] = now.Add(time.Hour).Unix()
 
-	return token.SignedString(jwtSecret)
+	claims := jwt.MapClaims{
+		"email":      data.Email,
+		"session_id": data.SessionID,
+		"exp":        now.Add(1 * time.Hour).Unix(),
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+
+	return token.SignedString([]byte(config.SALT_SECURITY))
+}
+
+func parseToken(s string) (*jwt.Token, error) {
+	return jwt.Parse(s, func(t *jwt.Token) (any, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			errMsg := fmt.Sprintf("unexpected signing method: %v", t.Header["alg"])
+			return nil, errors.New(errMsg)
+		}
+
+		return []byte(config.SALT_SECURITY), nil
+	})
+}
+
+func DestructToken(s string) (authdomain.AuthToken, error) {
+	var data authdomain.AuthToken
+
+	token, err := parseToken(s)
+	if err != nil {
+		return data, err
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+
+	if !ok {
+		return data, errors.New("failed to parse token")
+	}
+
+	if !token.Valid {
+		return data, errors.New("invalid token")
+	}
+
+	email, ok := claims[string(jwtclaimenum.EMAIL)].(string)
+	if !ok {
+		return data, errors.New("invalid email")
+	}
+
+	sessionId, ok := claims[string(jwtclaimenum.SESSION_ID)].(string)
+
+	data = authdomain.AuthToken{
+		Email:     email,
+		SessionID: sessionId,
+	}
+
+	return data, nil
 }