add core/error/util files

pkg/core/context.go

@@ -0,0 +1,82 @@
+package core
+
+import (
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/mayswind/lab/pkg/errs"
+)
+
+const FIELD_REQUEST_ID_KEY = "REQUEST_ID"
+const FIELD_TOKEN_CLAIMS_KEY = "TOKEN_CLAIMS"
+const FIELD_RESPONSE_ERROR = "RESPONSE_ERROR"
+
+type Context struct {
+	*gin.Context
+	// DO NOT ADD ANY FIELD IN THIS CONTEXT, THIS CONTEXT IS JUST A WRAPPER
+}
+
+func (c *Context) SetRequestId(requestId string) {
+	c.Set(FIELD_REQUEST_ID_KEY, requestId)
+}
+
+func (c *Context) GetRequestId() string {
+	requestId, exists := c.Get(FIELD_REQUEST_ID_KEY)
+
+	if !exists {
+		return ""
+	}
+
+	return requestId.(string)
+}
+
+func (c *Context) SetTokenClaims(claims *UserTokenClaims) {
+	c.Set(FIELD_TOKEN_CLAIMS_KEY, claims)
+}
+
+func (c *Context) GetTokenClaims() *UserTokenClaims {
+	claims, exists := c.Get(FIELD_TOKEN_CLAIMS_KEY)
+
+	if !exists {
+		return nil
+	}
+
+	return claims.(*UserTokenClaims)
+}
+
+func (c *Context) GetCurrentUid() int64 {
+	claims := c.GetTokenClaims()
+
+	if claims == nil {
+		return 0
+	}
+
+	uid, err := strconv.ParseInt(claims.Id, 10, 64)
+
+	if err != nil {
+		return 0
+	}
+
+	return uid
+}
+
+func (c *Context) SetResponseError(error *errs.Error) {
+	c.Set(FIELD_RESPONSE_ERROR, error)
+}
+
+func (c *Context) GetResponseError() *errs.Error {
+	err, exists := c.Get(FIELD_RESPONSE_ERROR)
+
+	if !exists {
+		return nil
+	}
+
+	return err.(*errs.Error)
+}
+
+func WrapContext(ginCtx *gin.Context) *Context {
+	return &Context{
+		Context: ginCtx,
+	}
+}

pkg/core/handler.go

@@ -0,0 +1,7 @@
+package core
+
+import "github.com/mayswind/lab/pkg/errs"
+
+type MiddlewareHandlerFunc func(*Context)
+
+type ApiHandlerFunc func(*Context) (interface{}, *errs.Error)

pkg/core/token_claims.go

@@ -0,0 +1,19 @@
+package core
+
+import (
+	"github.com/dgrijalva/jwt-go"
+)
+
+type TokenType byte
+
+const (
+	USER_TOKEN_TYPE_NORMAL      TokenType = 1
+	USER_TOKEN_TYPE_REQUIRE_2FA TokenType = 2
+)
+
+type UserTokenClaims struct {
+	UserTokenId string    `json:"userTokenId"`
+	Username    string    `json:"username,omitempty"`
+	Type        TokenType `json:"type"`
+	jwt.StandardClaims
+}

pkg/errs/database.go

@@ -0,0 +1,11 @@
+package errs
+
+import (
+	"net/http"
+)
+
+var (
+	ErrDatabaseTypeInvalid = NewSystemError(SYSTEM_SUBCATEGORY_DATABASE, 0, http.StatusInternalServerError, "database type is invalid")
+	ErrDatabaseHostInvalid = NewSystemError(SYSTEM_SUBCATEGORY_DATABASE, 1, http.StatusInternalServerError, "database host is invalid")
+	ErrDatabaseIsNull      = NewSystemError(SYSTEM_SUBCATEGORY_DATABASE, 2, http.StatusInternalServerError, "database cannot be null")
+)

pkg/errs/error.go

@@ -0,0 +1,73 @@
+package errs
+
+type ErrorCategory int
+
+const (
+	CATEGORY_SYSTEM ErrorCategory = 1
+	CATEGORY_NORMAL ErrorCategory = 2
+
+	SYSTEM_SUBCATEGORY_DEFAULT  = 0
+	SYSTEM_SUBCATEGORY_SETTING  = 1
+	SYSTEM_SUBCATEGORY_DATABASE = 2
+
+	NORMAL_SUBCATEGORY_GLOBAL    = 0
+	NORMAL_SUBCATEGORY_USER      = 1
+	NORMAL_SUBCATEGORY_TOKEN     = 2
+	NORMAL_SUBCATEGORY_TWOFACTOR = 3
+	NORMAL_SUBCATEGORY_ACCOUNT   = 4
+	NORMAL_SUBCATEGORY_JOURNAL   = 5
+	NORMAL_SUBCATEGORY_CATEGORY  = 6
+	NORMAL_SUBCATEGORY_TAG       = 7
+)
+
+type Error struct {
+	Category       ErrorCategory
+	SubCategory    int
+	Index          int
+	HttpStatusCode int
+	Message        string
+	BaseError      []error
+}
+
+func (err *Error) Error() string {
+	return err.Message
+}
+
+func (err *Error) Code() int {
+	return int(err.Category)*100000 + err.SubCategory*1000 + err.Index
+}
+
+func New(category ErrorCategory, subCategory int, index int, httpStatusCode int, message string, baseError ...error) *Error {
+	return &Error{
+		Category:       category,
+		SubCategory:    subCategory,
+		Index:          index,
+		HttpStatusCode: httpStatusCode,
+		Message:        message,
+		BaseError:      baseError,
+	}
+}
+
+func NewSystemError(subCategory int, index int, httpStatusCode int, message string) *Error {
+	return New(CATEGORY_SYSTEM, subCategory, index, httpStatusCode, message)
+}
+
+func NewNormalError(subCategory int, index int, httpStatusCode int, message string) *Error {
+	return New(CATEGORY_NORMAL, subCategory, index, httpStatusCode, message)
+}
+
+func NewIncompleteOrIncorrectSubmissionError(err error) *Error {
+	return New(ErrIncompleteOrIncorrectSubmission.Category,
+		ErrIncompleteOrIncorrectSubmission.SubCategory,
+		ErrIncompleteOrIncorrectSubmission.Index,
+		ErrIncompleteOrIncorrectSubmission.HttpStatusCode,
+		ErrIncompleteOrIncorrectSubmission.Message, err)
+}
+
+func Or(err error, defaultErr *Error) *Error {
+	if finalError, ok := err.(*Error); ok {
+		return finalError
+	} else {
+		return defaultErr
+	}
+}

pkg/errs/global.go

@@ -0,0 +1,46 @@
+package errs
+
+import (
+	"fmt"
+	"net/http"
+)
+
+var (
+	ErrIncompleteOrIncorrectSubmission = NewNormalError(NORMAL_SUBCATEGORY_GLOBAL, 0, http.StatusBadRequest, "incomplete or incorrect submission")
+	ErrOperationFailed                 = NewNormalError(NORMAL_SUBCATEGORY_GLOBAL, 1, http.StatusInternalServerError, "operation failed")
+	ErrRequestIdInvalid                = NewNormalError(NORMAL_SUBCATEGORY_GLOBAL, 2, http.StatusInternalServerError, "request id is invalid")
+	ErrCiphertextInvalid               = NewNormalError(NORMAL_SUBCATEGORY_GLOBAL, 3, http.StatusInternalServerError, "ciphertext is invalid")
+	ErrNothingWillBeUpdated            = NewNormalError(NORMAL_SUBCATEGORY_GLOBAL, 4, http.StatusBadRequest, "nothing will be updated")
+)
+
+func GetParameterInvalidMessage(field string) string {
+	return fmt.Sprintf("parameter \"%s\" is invalid", field)
+}
+
+func GetParameterIsRequiredMessage(field string) string {
+	return fmt.Sprintf("parameter \"%s\" is required", field)
+}
+
+func GetParameterMustLessThanMessage(field string, param string) string {
+	return fmt.Sprintf("parameter \"%s\" must be less than %s", field, param)
+}
+
+func GetParameterMustMoreThanMessage(field string, param string) string {
+	return fmt.Sprintf("parameter \"%s\" must be more than %s", field, param)
+}
+
+func GetParameterLengthNotEqualMessage(field string, param string) string {
+	return fmt.Sprintf("parameter \"%s\" length is not equal to %s", field, param)
+}
+
+func GetParameterNotBeBlankMessage(field string) string {
+	return fmt.Sprintf("parameter \"%s\" cannot be blank", field)
+}
+
+func GetParameterInvalidUsernameMessage(field string) string {
+	return fmt.Sprintf("parameter \"%s\" is invalid username format", field)
+}
+
+func GetParameterInvalidEmailMessage(field string) string {
+	return fmt.Sprintf("parameter \"%s\" is invalid email format", field)
+}

pkg/errs/setting.go

@@ -0,0 +1,10 @@
+package errs
+
+import "net/http"
+
+var (
+	ErrInvalidProtocol     = NewSystemError(SYSTEM_SUBCATEGORY_SETTING, 0, http.StatusInternalServerError, "invalid server protocol")
+	ErrInvalidLogMode      = NewSystemError(SYSTEM_SUBCATEGORY_SETTING, 1, http.StatusInternalServerError, "invalid log mode")
+	ErrGettingLocalAddress = NewSystemError(SYSTEM_SUBCATEGORY_SETTING, 2, http.StatusInternalServerError, "failed to get local address")
+	ErrInvalidUuidMode     = NewSystemError(SYSTEM_SUBCATEGORY_SETTING, 3, http.StatusInternalServerError, "invalid uuid mode")
+)

pkg/errs/system.go

@@ -0,0 +1,9 @@
+package errs
+
+import "net/http"
+
+var (
+	ErrSystemError      = NewSystemError(SYSTEM_SUBCATEGORY_DEFAULT, 0, http.StatusInternalServerError, "system error")
+	ErrApiNotFound      = NewSystemError(SYSTEM_SUBCATEGORY_DEFAULT, 1, http.StatusNotFound, "api not found")
+	ErrMethodNotAllowed = NewSystemError(SYSTEM_SUBCATEGORY_DEFAULT, 2, http.StatusMethodNotAllowed, "method not allowed")
+)

pkg/errs/token.go

@@ -0,0 +1,18 @@
+package errs
+
+import (
+	"net/http"
+)
+
+var (
+	ErrTokenGenerating     = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 0, http.StatusInternalServerError, "failed to generate token")
+	ErrUnauthorizedAccess  = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 1, http.StatusUnauthorized, "unauthorized access")
+	ErrTokenExpired        = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 2, http.StatusUnauthorized, "token is expired")
+	ErrInvalidToken        = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 3, http.StatusUnauthorized, "token is invalid")
+	ErrInvalidUserTokenId  = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 4, http.StatusUnauthorized, "user token id is invalid")
+	ErrInvalidTokenId      = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 5, http.StatusUnauthorized, "token id is invalid")
+	ErrTokenRecordNotFound = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 6, http.StatusUnauthorized, "token is not found")
+	ErrInvalidTokenType    = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 7, http.StatusUnauthorized, "token type is invalid")
+	ErrTokenRequire2FA     = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 8, http.StatusUnauthorized, "token requires two factor authorization")
+	ErrTokenNotRequire2FA  = NewNormalError(NORMAL_SUBCATEGORY_TOKEN, 9, http.StatusUnauthorized, "token does not require two factor authorization")
+)

pkg/errs/twofactor_authorization.go

@@ -0,0 +1,11 @@
+package errs
+
+import "net/http"
+
+var (
+	ErrPasscodeInvalid               = NewNormalError(NORMAL_SUBCATEGORY_TWOFACTOR, 0, http.StatusUnauthorized, "passcode is invalid")
+	ErrTwoFactorRecoveryCodeInvalid  = NewNormalError(NORMAL_SUBCATEGORY_TWOFACTOR, 1, http.StatusUnauthorized, "two factor recovery code is invalid")
+	ErrTwoFactorKeyIsNotEnabled      = NewNormalError(NORMAL_SUBCATEGORY_TWOFACTOR, 2, http.StatusBadRequest, "two factor key is not enabled")
+	ErrTwoFactorKeyAlreadyEnabled    = NewNormalError(NORMAL_SUBCATEGORY_TWOFACTOR, 3, http.StatusBadRequest, "two factor key has already been enabled")
+	ErrTwoFactorRecoveryCodeNotExist = NewNormalError(NORMAL_SUBCATEGORY_TWOFACTOR, 4, http.StatusUnauthorized, "two factor recovery code does not exist")
+)

pkg/errs/user.go

@@ -0,0 +1,18 @@
+package errs
+
+import (
+	"net/http"
+)
+
+var (
+	ErrUserIdInvalid              = NewNormalError(NORMAL_SUBCATEGORY_USER, 0, http.StatusBadRequest, "user id is invalid")
+	ErrUsernameIsEmpty            = NewNormalError(NORMAL_SUBCATEGORY_USER, 1, http.StatusBadRequest, "username is empty")
+	ErrEmailIsEmpty               = NewNormalError(NORMAL_SUBCATEGORY_USER, 2, http.StatusBadRequest, "email is empty")
+	ErrPasswordIsEmpty            = NewNormalError(NORMAL_SUBCATEGORY_USER, 3, http.StatusBadRequest, "password is empty")
+	ErrUserNotFound               = NewNormalError(NORMAL_SUBCATEGORY_USER, 4, http.StatusBadRequest, "user not found")
+	ErrUserPasswordWrong          = NewNormalError(NORMAL_SUBCATEGORY_USER, 5, http.StatusBadRequest, "password is wrong")
+	ErrUsernameAlreadyExists      = NewNormalError(NORMAL_SUBCATEGORY_USER, 6, http.StatusBadRequest, "username already exists")
+	ErrUserEmailAlreadyExists     = NewNormalError(NORMAL_SUBCATEGORY_USER, 7, http.StatusBadRequest, "email already exists")
+	ErrLoginNameOrPasswordInvalid = NewNormalError(NORMAL_SUBCATEGORY_USER, 8, http.StatusUnauthorized, "login name or password is invalid")
+	ErrLoginNameOrPasswordWrong   = NewNormalError(NORMAL_SUBCATEGORY_USER, 9, http.StatusUnauthorized, "login name or password is wrong")
+)

pkg/utils/api.go

@@ -0,0 +1,64 @@
+package utils
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+
+	"github.com/mayswind/lab/pkg/core"
+	"github.com/mayswind/lab/pkg/errs"
+)
+
+func PrintSuccessResult(c *core.Context, result interface{}) {
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"result": result,
+	})
+}
+
+func PrintErrorResult(c *core.Context, err *errs.Error) {
+	c.SetResponseError(err)
+
+	errorMessage := err.Error()
+
+	if err.Code() == errs.ErrIncompleteOrIncorrectSubmission.Code() && len(err.BaseError) > 0 {
+		validationErrors, ok := err.BaseError[0].(validator.ValidationErrors)
+
+		if ok {
+			for _, err := range validationErrors {
+				errorMessage = getValidationErrorText(err)
+				break
+			}
+		}
+	}
+
+	c.AbortWithStatusJSON(err.HttpStatusCode, gin.H{
+		"success": false,
+		"errorCode": err.Code(),
+		"errorMessage": errorMessage,
+	})
+}
+
+func getValidationErrorText(err validator.FieldError) string {
+	fieldName := GetFirstLowerCharString(err.Field())
+
+	switch err.Tag() {
+	case "required":
+		return errs.GetParameterIsRequiredMessage(fieldName)
+	case "max":
+		return errs.GetParameterMustLessThanMessage(fieldName, err.Param())
+	case "min":
+		return errs.GetParameterMustMoreThanMessage(fieldName, err.Param())
+	case "len":
+		return errs.GetParameterLengthNotEqualMessage(fieldName, err.Param())
+	case "notBlank":
+		return errs.GetParameterNotBeBlankMessage(fieldName)
+	case "validUsername":
+		return errs.GetParameterInvalidUsernameMessage(fieldName)
+	case "validEmail":
+		return errs.GetParameterInvalidEmailMessage(fieldName)
+	}
+
+	return errs.GetParameterInvalidMessage(fieldName)
+}

pkg/utils/converter.go

@@ -0,0 +1,39 @@
+package utils
+
+import "strconv"
+
+func Int32ToString(num int) string {
+	return strconv.Itoa(num)
+}
+
+func StringToInt32(str string) (int, error) {
+	return strconv.Atoi(str)
+}
+
+func StringTryToInt32(str string,  defaultValue int) int {
+	num, err := StringToInt32(str)
+
+	if err != nil {
+		return defaultValue
+	}
+
+	return num
+}
+
+func Int64ToString(num int64) string {
+	return strconv.FormatInt(num, 10)
+}
+
+func StringToInt64(str string) (int64, error) {
+	return strconv.ParseInt(str, 10, 64)
+}
+
+func StringTryToInt64(str string, defaultValue int64) int64 {
+	num, err := StringToInt64(str)
+
+	if err != nil {
+		return defaultValue
+	}
+
+	return num
+}

pkg/utils/datetimes.go

@@ -0,0 +1,7 @@
+package utils
+
+import "time"
+
+func FormatToLongDateTime(t time.Time) string {
+	return t.Format("2006-01-02 15:04:05")
+}

pkg/utils/network.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"bytes"
+	"net"
+
+	"github.com/mayswind/lab/pkg/errs"
+)
+
+func GetLocalIPAddressesString() (string, error) {
+	localAddrs, err := GetLocalIPAddresses()
+
+	if err != nil {
+		return "", err
+	}
+
+	if len(localAddrs) < 1 {
+		return "", errs.ErrGettingLocalAddress
+	}
+
+	buff := &bytes.Buffer{}
+
+	for i := 0; i < len(localAddrs); i++ {
+		if i > 0 {
+			buff.WriteString(",")
+		}
+
+		buff.WriteString(localAddrs[i].String())
+	}
+
+	return string(buff.Bytes()), nil
+}
+
+func GetLocalIPAddresses() ([]net.IP, error) {
+	addrs, err := net.InterfaceAddrs()
+
+	if err != nil {
+		return nil, err
+	}
+
+	var localAddrs []net.IP
+
+	for _, addr := range addrs {
+		if ipnet, ok := addr.(*net.IPNet); ok {
+			if ipnet.IP.IsLoopback() {
+				continue
+			}
+
+			if ipnet.IP.IsLinkLocalUnicast() {
+				continue
+			}
+
+			ip := ipnet.IP.To16()
+
+			if ip != nil {
+				localAddrs = append(localAddrs, ip)
+			}
+		}
+	}
+
+	return localAddrs, nil
+}

pkg/utils/numbers.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"crypto/rand"
+	"math/big"
+)
+
+func GetRandomInteger(max int) (int, error) {
+	result, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
+
+	if err != nil {
+		return 0, err
+	}
+
+	return int(result.Int64()), nil
+}

pkg/utils/regexps.go

@@ -0,0 +1,16 @@
+package utils
+
+import "regexp"
+
+var (
+	UsernamePattern = regexp.MustCompile("^(?i)[a-z0-9_-]+$")
+	EmailPattern = regexp.MustCompile("^(?i)(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$")
+)
+
+func IsValidUsername(username string) bool {
+	return UsernamePattern.MatchString(username)
+}
+
+func IsValidEmail(email string) bool {
+	return EmailPattern.MatchString(email)
+}

pkg/utils/regexps_test.go

@@ -0,0 +1,65 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsValidUsername_ValidUserName(t *testing.T) {
+	username := "foobar"
+	expectedValue := true
+	actualValue := IsValidUsername(username)
+	assert.Equal(t, expectedValue, actualValue)
+
+	username = "--foo_bar--"
+	expectedValue = true
+	actualValue = IsValidUsername(username)
+	assert.Equal(t, expectedValue, actualValue)
+}
+
+func TestIsValidUsername_InvalidUserName(t *testing.T) {
+	username := "foo~bar~"
+	expectedValue := false
+	actualValue := IsValidUsername(username)
+	assert.Equal(t, expectedValue, actualValue)
+}
+
+func TestIsValidEmail_ValidEmail(t *testing.T) {
+	email := "foo@bar.com"
+	expectedValue := true
+	actualValue := IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+
+	email = "foo@1.2.3.4"
+	expectedValue = true
+	actualValue = IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+
+	email = "foo_bar@foo.bar"
+	expectedValue = true
+	actualValue = IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+}
+
+func TestIsValidEmail_InvalidEmail(t *testing.T) {
+	email := "foo"
+	expectedValue := false
+	actualValue := IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+
+	email = "@bar"
+	expectedValue = false
+	actualValue = IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+
+	email = "foo@bar"
+	expectedValue = false
+	actualValue = IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+
+	email = "foo@bar."
+	expectedValue = false
+	actualValue = IsValidEmail(email)
+	assert.Equal(t, expectedValue, actualValue)
+}

pkg/utils/slices.go

@@ -0,0 +1,19 @@
+package utils
+
+func IsStringSliceEuqals(s1, s2 []string) bool {
+	if (s1 == nil) != (s2 == nil) {
+		return false
+	}
+
+	if len(s1) != len(s2) {
+		return false
+	}
+
+	for i := 0; i < len(s1); i++ {
+		if s1[i] != s2[i] {
+			return false
+		}
+	}
+
+	return true
+}

pkg/utils/strings.go

@@ -0,0 +1,196 @@
+package utils
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"strings"
+	"unicode"
+
+	"golang.org/x/crypto/pbkdf2"
+
+	"github.com/mayswind/lab/pkg/errs"
+)
+
+const (
+	CHARACTERS                = "!#$&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_abcdefghijklmnopqrstuvwxyz{|}~"
+	NUMBER_AND_LETTERS        = "0123456789abcdefghijklmnopqrstuvwxyz"
+	CHARACTERS_LENGTH         = len(CHARACTERS)
+	NUMBER_AND_LETTERS_LENGTH = len(NUMBER_AND_LETTERS)
+)
+
+func SubString(str string, start int, length int) string {
+	chars := []rune(str)
+	realLength := len(chars)
+	end := 0
+
+	if start < 0 {
+		start = realLength - 1 + start
+	}
+	end = start + length
+
+	if start > end {
+		start, end = end, start
+	}
+
+	if start < 0 {
+		start = 0
+	}
+
+	if start > realLength {
+		start = realLength
+	}
+
+	if end < 0 {
+		end = 0
+	}
+
+	if end > realLength {
+		end = realLength
+	}
+
+	return string(chars[start:end])
+}
+
+func GetFirstLowerCharString(s string) string {
+	if s == "" {
+		return s
+	}
+
+	chars := []rune(s)
+
+	if unicode.IsLower(chars[0]) {
+		return s
+	}
+
+	chars[0] = unicode.ToLower(chars[0])
+	return string(chars)
+}
+
+func GetRandomString(n int) (string, error) {
+	var result = make([]byte, n)
+
+	for i := 0; i < n; i++ {
+		index, err := GetRandomInteger(CHARACTERS_LENGTH)
+
+		if err != nil {
+			return "", err
+		}
+
+		result[i] = CHARACTERS[index]
+	}
+
+	return string(result), nil
+}
+
+func GetRandomNumberOrLetter(n int) (string, error) {
+	var result = make([]byte, n)
+
+	for i := 0; i < n; i++ {
+		index, err := GetRandomInteger(NUMBER_AND_LETTERS_LENGTH)
+
+		if err != nil {
+			return "", err
+		}
+
+		result[i] = NUMBER_AND_LETTERS[index]
+	}
+
+	return string(result), nil
+}
+
+func MD5Encode(data []byte) []byte {
+	m := md5.New()
+	m.Write(data)
+	return m.Sum(nil)
+}
+
+func AESGCMEncrypt(key []byte, plainText []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+
+	if err != nil {
+		return nil, err
+	}
+
+	aesgcm, err := cipher.NewGCM(block)
+
+	if err != nil {
+		return nil, err
+	}
+
+	nonce := make([]byte, aesgcm.NonceSize())
+
+	if _, err := rand.Read(nonce); err != nil {
+		return nil, err
+	}
+
+	ciphertext := aesgcm.Seal(nil, nonce, plainText, nil)
+	result := append(nonce, ciphertext...)
+
+	return result, nil
+}
+
+func AESGCMDecrypt(key []byte, ciphertext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+
+	if err != nil {
+		return nil, err
+	}
+
+	aesgcm, err := cipher.NewGCM(block)
+
+	if err != nil {
+		return nil, err
+	}
+
+	nonceSize := aesgcm.NonceSize()
+
+	if len(ciphertext) - nonceSize <= 0 {
+		return nil, errs.ErrCiphertextInvalid
+	}
+
+	nonce := ciphertext[:nonceSize]
+	ciphertext = ciphertext[nonceSize:]
+
+	plainText, err := aesgcm.Open(nil, nonce, ciphertext, nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return plainText, nil
+}
+
+func EncodePassword(password string, salt string) string {
+	encodedPassword := pbkdf2.Key([]byte(password), []byte(salt), 10000, 48, sha256.New) // 256^48 = 64^64
+	return strings.TrimRight(base64.StdEncoding.EncodeToString(encodedPassword), "=")
+}
+
+func EncyptSecret(secret string, key string) (string, error) {
+	encyptedSecret, err := AESGCMEncrypt(MD5Encode([]byte(key)), []byte(secret)) // md5encode make the aes key's length to 16
+
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(encyptedSecret), nil
+}
+
+func DecryptSecret(encyptedSecret string, key string) (string, error) {
+	encyptedData, err := base64.StdEncoding.DecodeString(encyptedSecret)
+
+	if err != nil {
+		return "", err
+	}
+
+	secret, err := AESGCMDecrypt(MD5Encode([]byte(key)), []byte(encyptedData))
+
+	if err != nil {
+		return "", err
+	}
+
+	return string(secret), nil
+}

pkg/validators/email.go

@@ -0,0 +1,17 @@
+package validators
+
+import (
+	"github.com/go-playground/validator/v10"
+
+	"github.com/mayswind/lab/pkg/utils"
+)
+
+func ValidEmail(fl validator.FieldLevel) bool {
+	if value, ok := fl.Field().Interface().(string); ok {
+		if utils.IsValidEmail(value) {
+			return true
+		}
+	}
+
+	return false
+}

pkg/validators/not_blank.go

@@ -0,0 +1,17 @@
+package validators
+
+import (
+	"strings"
+
+	"github.com/go-playground/validator/v10"
+)
+
+func NotBlank(fl validator.FieldLevel) bool {
+	if value, ok := fl.Field().Interface().(string); ok {
+		if value != "" && strings.Trim(value, " ") != "" {
+			return true
+		}
+	}
+
+	return false
+}

pkg/validators/username.go

@@ -0,0 +1,17 @@
+package validators
+
+import (
+	"github.com/go-playground/validator/v10"
+
+	"github.com/mayswind/lab/pkg/utils"
+)
+
+func ValidUsername(fl validator.FieldLevel) bool {
+	if value, ok := fl.Field().Interface().(string); ok {
+		if utils.IsValidUsername(value) {
+			return true
+		}
+	}
+
+	return false
+}