feat: add generate token function

model/function.go

@@ -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)
+}

util/build.go

@@ -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
+}

util/build_test.go

@@ -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)
+}