feat: add generate token function

This commit is contained in:
weloe
2023-05-05 22:46:20 +08:00
parent 7355e1c107
commit dc3c0382ba
3 changed files with 171 additions and 0 deletions

52
model/function.go Normal file
View File

@@ -0,0 +1,52 @@
package model
import (
"errors"
"github.com/weloe/token-go/util"
"sync"
)
type GenerateFunc func() (string, error)
type GenerateTokenFunc struct {
fns *sync.Map
}
func (g *GenerateTokenFunc) Exec(tokenForm string) (string, error) {
handlerFunc, err := g.GetFunction(tokenForm)
if err != nil {
return "", err
}
s, err := handlerFunc()
if err != nil {
return "", nil
}
return s, nil
}
func (g *GenerateTokenFunc) GetFunction(tokenForm string) (GenerateFunc, error) {
value, ok := g.fns.Load(tokenForm)
if !ok {
return nil, errors.New("GetFunction() failed: load func error")
}
if value == nil {
return nil, errors.New("GetFunction() failed: func doesn't exist")
}
handlerFunc := value.(GenerateFunc)
return handlerFunc, nil
}
func LoadFunctionMap() GenerateTokenFunc {
fm := &GenerateTokenFunc{fns: &sync.Map{}}
fm.AddFunc("uuid", util.GenerateUUID)
fm.AddFunc("uuid-simple", util.GenerateSimpleUUID)
fm.AddFunc("random-string32", util.GenerateRandomString32)
fm.AddFunc("random-string64", util.GenerateRandomString64)
fm.AddFunc("random-string128", util.GenerateRandomString128)
return *fm
}
func (g *GenerateTokenFunc) AddFunc(key string, f GenerateFunc) {
g.fns.LoadOrStore(key, f)
}

60
util/build.go Normal file
View File

@@ -0,0 +1,60 @@
package util
import (
"crypto/rand"
"encoding/base64"
"fmt"
"strings"
)
func GenerateUUID() (string, error) {
uuid := make([]byte, 16)
_, err := rand.Read(uuid)
if err != nil {
return "", err
}
// set version number (4)
uuid[6] = (uuid[6] & 0x0f) | 0x40
// set variant bits (2)
uuid[8] = (uuid[8] & 0xbf) | 0x80
return fmt.Sprintf("%x-%x-%x-%x-%x", uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:]), nil
}
func GenerateSimpleUUID() (string, error) {
uuid, err := GenerateUUID()
if err != nil {
return "", err
}
return strings.ReplaceAll(uuid, "-", ""), nil
}
func GenerateRandomString32() (string, error) {
data := make([]byte, 24)
_, err := rand.Read(data)
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(data)[:32], nil
}
func GenerateRandomString64() (string, error) {
data := make([]byte, 48)
_, err := rand.Read(data)
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(data)[:64], nil
}
func GenerateRandomString128() (string, error) {
data := make([]byte, 96)
_, err := rand.Read(data)
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(data)[:128], nil
}

59
util/build_test.go Normal file
View File

@@ -0,0 +1,59 @@
package util
import "testing"
func TestGenerateUUID(t *testing.T) {
uuid, err := GenerateUUID()
if err != nil {
t.Errorf("Error generating UUID: %v", err)
}
if len(uuid) != 36 {
t.Errorf("Incorrect UUID length: expected 36, got %d", len(uuid))
}
t.Logf("GenerateUUID() = %s", uuid)
}
func TestGenerateSimpleUUID(t *testing.T) {
uuid, err := GenerateSimpleUUID()
if err != nil {
t.Errorf("Error generating simple UUID: %v", err)
}
if len(uuid) != 32 {
t.Errorf("Incorrect simple UUID length: expected 32, got %d", len(uuid))
}
}
func TestGenerateRandomString32(t *testing.T) {
randomString, err := GenerateRandomString32()
if err != nil {
t.Errorf("Error generating random string: %v", err)
}
if len(randomString) != 32 {
t.Errorf("Incorrect random string length: expected 32, got %d", len(randomString))
}
t.Logf("GenerateRandomString32() = %s", randomString)
}
func TestGenerateRandomString64(t *testing.T) {
randomString, err := GenerateRandomString64()
if err != nil {
t.Errorf("Error generating random string: %v", err)
}
if len(randomString) != 64 {
t.Errorf("Incorrect random string length: expected 64, got %d", len(randomString))
}
t.Logf("GenerateRandomString64() = %s", randomString)
}
func TestGenerateRandomString128(t *testing.T) {
randomString, err := GenerateRandomString128()
if err != nil {
t.Errorf("Error generating random string: %v", err)
}
if len(randomString) != 128 {
t.Errorf("Incorrect random string length: expected 128, got %d", len(randomString))
}
t.Logf("GenerateRandomString128() = %s", randomString)
}