init project

internal/repository/crypto/crypto.go

@@ -0,0 +1,4 @@
+//go:generate mockery --name Crypto --filename crypto.go --output ./mock --with-expecter
+
+package crypto
+

internal/repository/crypto/init.go

@@ -0,0 +1,90 @@
+package crypto
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/golang-jwt/jwt"
+	"golang.org/x/crypto/bcrypt"
+
+	"furtuna-be/internal/common/errors"
+	"furtuna-be/internal/entity"
+)
+
+func NewCrypto(config CryptoConfig) *CryptoImpl {
+	return &CryptoImpl{
+		Config: config,
+	}
+}
+
+type CryptoConfig interface {
+	AccessTokenSecret() string
+	AccessTokenExpiresDate() time.Time
+}
+
+type CryptoImpl struct {
+	Config CryptoConfig
+}
+
+func (c *CryptoImpl) CompareHashAndPassword(hash string, password string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+	return err == nil
+}
+
+func (c *CryptoImpl) ValidateWT(tokenString string) (*jwt.Token, error) {
+	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+		}
+		return []byte(c.Config.AccessTokenSecret()), nil
+	})
+
+	return token, err
+}
+
+func (c *CryptoImpl) GenerateJWT(user *entity.User) (string, error) {
+	branchID := int64(0)
+	if user.PartnerID != nil {
+		branchID = *user.PartnerID
+	}
+
+	claims := &entity.JWTAuthClaims{
+		StandardClaims: jwt.StandardClaims{
+			Subject:   strconv.FormatInt(user.ID, 10),
+			ExpiresAt: c.Config.AccessTokenExpiresDate().Unix(),
+			IssuedAt:  time.Now().Unix(),
+			NotBefore: time.Now().Unix(),
+		},
+		UserID:   user.ID,
+		Name:     user.Name,
+		Email:    user.Email,
+		Role:     int(user.RoleID),
+		BranchID: branchID,
+	}
+
+	token, err := jwt.
+		NewWithClaims(jwt.SigningMethodHS256, claims).
+		SignedString([]byte(c.Config.AccessTokenSecret()))
+
+	if err != nil {
+		return "", err
+	}
+
+	return token, nil
+}
+
+func (c *CryptoImpl) ParseAndValidateJWT(tokenString string) (*entity.JWTAuthClaims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &entity.JWTAuthClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte(c.Config.AccessTokenSecret()), nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if claims, ok := token.Claims.(*entity.JWTAuthClaims); ok && token.Valid {
+		return claims, nil
+	} else {
+		return nil, errors.ErrorUnauthorized
+	}
+}