From c85d2c4047a7be569d6651bea4d4d2caa95b82e4 Mon Sep 17 00:00:00 2001
From: weloe <1345895607@qq.com>
Date: Thu, 2 Nov 2023 05:11:03 +0800
Subject: [PATCH] feat: add synced enforcer

---
 enforcer_synced.go         | 422 +++++++++++++++++++++++++++++++++++++
 persist/default_adapter.go |   4 +
 2 files changed, 426 insertions(+)
 create mode 100644 enforcer_synced.go

diff --git a/enforcer_synced.go b/enforcer_synced.go
new file mode 100644
index 0000000..de6eaf6
--- /dev/null
+++ b/enforcer_synced.go
@@ -0,0 +1,422 @@
+package token_go
+
+import (
+	"github.com/weloe/token-go/config"
+	"github.com/weloe/token-go/ctx"
+	"github.com/weloe/token-go/log"
+	"github.com/weloe/token-go/model"
+	"github.com/weloe/token-go/persist"
+	"sync"
+)
+
+// SyncedEnforcer wraps Enforcer and provides synchronized access
+type SyncedEnforcer struct {
+	*Enforcer
+	m sync.RWMutex
+}
+
+// NewSyncedEnforcer creates a synchronized enforcer
+func NewSyncedEnforcer(adapter persist.Adapter, params ...interface{}) (*SyncedEnforcer, error) {
+	e := &SyncedEnforcer{}
+	var err error
+	e.Enforcer, err = NewEnforcer(adapter, params...)
+	if err != nil {
+		return nil, err
+	}
+	return e, nil
+}
+
+// GetLock return the private RWMutex lock
+func (e *SyncedEnforcer) GetLock() *sync.RWMutex {
+	return &e.m
+}
+
+func (e *SyncedEnforcer) SetType(t string) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.SetType(t)
+}
+
+func (e *SyncedEnforcer) GetType() string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetType()
+}
+
+func (e *SyncedEnforcer) GetAdapter() persist.Adapter {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetAdapter()
+}
+
+func (e *SyncedEnforcer) SetAdapter(adapter persist.Adapter) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.SetAdapter(adapter)
+}
+
+func (e *SyncedEnforcer) SetWatcher(watcher persist.Watcher) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.SetWatcher(watcher)
+}
+
+func (e *SyncedEnforcer) GetWatcher() persist.Watcher {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetWatcher()
+}
+
+func (e *SyncedEnforcer) SetLogger(logger log.Logger) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.SetLogger(logger)
+}
+
+func (e *SyncedEnforcer) GetLogger() log.Logger {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLogger()
+}
+
+func (e *SyncedEnforcer) EnableLog() {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.EnableLog()
+}
+
+func (e *SyncedEnforcer) IsLogEnable() bool {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsLogEnable()
+}
+
+func (e *SyncedEnforcer) GetTokenConfig() config.TokenConfig {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetTokenConfig()
+}
+
+func (e *SyncedEnforcer) Login(id string, ctx ctx.Context) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Login(id, ctx)
+}
+
+func (e *SyncedEnforcer) LoginById(id string, device ...string) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.LoginById(id, device...)
+}
+
+func (e *SyncedEnforcer) LoginByModel(id string, loginModel *model.Login, ctx ctx.Context) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.LoginByModel(id, loginModel, ctx)
+}
+
+func (e *SyncedEnforcer) Logout(ctx ctx.Context) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Logout(ctx)
+}
+
+func (e *SyncedEnforcer) LogoutById(id string, device ...string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.LogoutById(id, device...)
+}
+
+func (e *SyncedEnforcer) LogoutByToken(token string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.LogoutByToken(token)
+}
+
+func (e *SyncedEnforcer) IsLogin(ctx ctx.Context) (bool, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsLogin(ctx)
+}
+
+func (e *SyncedEnforcer) IsLoginByToken(token string) (bool, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsLoginByToken(token)
+}
+
+func (e *SyncedEnforcer) IsLoginById(id string, device ...string) (bool, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsLoginById(id, device...)
+}
+
+func (e *SyncedEnforcer) CheckLogin(ctx ctx.Context) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CheckLogin(ctx)
+}
+
+func (e *SyncedEnforcer) CheckLoginByToken(token string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CheckLoginByToken(token)
+}
+
+func (e *SyncedEnforcer) GetLoginId(ctx ctx.Context) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLoginId(ctx)
+}
+
+func (e *SyncedEnforcer) GetLoginIdByToken(token string) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLoginIdByToken(token)
+}
+
+func (e *SyncedEnforcer) GetId(ctx ctx.Context) string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetId(ctx)
+}
+
+func (e *SyncedEnforcer) GetIdByToken(token string) string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetIdByToken(token)
+}
+
+func (e *SyncedEnforcer) GetLoginCount(id string, device ...string) int {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLoginCount(id, device...)
+}
+
+func (e *SyncedEnforcer) GetRefreshToken(tokenValue string) string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetRefreshToken(tokenValue)
+}
+
+func (e *SyncedEnforcer) RefreshToken(refreshToken string, refreshModel ...*model.Refresh) (*model.RefreshRes, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.RefreshToken(refreshToken, refreshModel...)
+}
+
+func (e *SyncedEnforcer) RefreshTokenByModel(refreshToken string, refreshModel *model.Refresh, ctx ctx.Context) (*model.RefreshRes, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.RefreshTokenByModel(refreshToken, refreshModel, ctx)
+}
+
+func (e *SyncedEnforcer) GetLoginCounts() (int, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLoginCounts()
+}
+
+func (e *SyncedEnforcer) GetLoginTokenCounts() (int, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetLoginTokenCounts()
+}
+
+func (e *SyncedEnforcer) Kickout(id string, device ...string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Kickout(id, device...)
+}
+
+func (e *SyncedEnforcer) Replaced(id string, device ...string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Replaced(id, device...)
+}
+
+func (e *SyncedEnforcer) Banned(id string, service string, level int, time int64) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Banned(id, service, level, time)
+}
+
+func (e *SyncedEnforcer) UnBanned(id string, services ...string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.UnBanned(id, services...)
+}
+
+func (e *SyncedEnforcer) IsBanned(id string, service string) bool {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsBanned(id, service)
+}
+
+func (e *SyncedEnforcer) GetBannedLevel(id string, service string) (int64, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetBannedLevel(id, service)
+}
+
+func (e *SyncedEnforcer) GetBannedTime(id string, service string) int64 {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.getBannedTime(id, service)
+}
+
+func (e *SyncedEnforcer) OpenSafe(token string, service string, time int64) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.OpenSafe(token, service, time)
+}
+
+func (e *SyncedEnforcer) IsSafe(token string, service string) bool {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.IsSafe(token, service)
+}
+
+func (e *SyncedEnforcer) GetSafeTime(token string, service string) int64 {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetSafeTime(token, service)
+}
+
+func (e *SyncedEnforcer) CloseSafe(token string, service string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CloseSafe(token, service)
+}
+
+func (e *SyncedEnforcer) CreateTempToken(token string, service string, value string, timeout int64) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CreateTempToken(token, service, value, timeout)
+}
+
+func (e *SyncedEnforcer) CreateTempTokenByStyle(style string, service string, value string, timeout int64) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CreateTempTokenByStyle(style, service, value, timeout)
+}
+
+func (e *SyncedEnforcer) GetTempTokenTimeout(service string, tempToken string) int64 {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetTempTokenTimeout(service, tempToken)
+}
+
+func (e *SyncedEnforcer) ParseTempToken(service string, tempToken string) string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.ParseTempToken(service, tempToken)
+}
+
+func (e *SyncedEnforcer) DeleteTempToken(service string, tempToken string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.DeleteTempToken(service, tempToken)
+}
+
+func (e *SyncedEnforcer) GetRequestToken(ctx ctx.Context) string {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetRequestToken(ctx)
+}
+
+func (e *SyncedEnforcer) AddTokenGenerateFun(tokenStyle string, f model.HandlerFunc) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.AddTokenGenerateFun(tokenStyle, f)
+}
+
+func (e *SyncedEnforcer) CreateQRCodeState(QRCodeId string, timeout int64) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CreateQRCodeState(QRCodeId, timeout)
+}
+
+func (e *SyncedEnforcer) GetQRCode(QRCodeId string) *model.QRCode {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetQRCode(QRCodeId)
+}
+
+func (e *SyncedEnforcer) GetQRCodeState(QRCodeId string) model.QRCodeState {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetQRCodeState(QRCodeId)
+}
+
+func (e *SyncedEnforcer) GetQRCodeTimeout(QRCodeId string) int64 {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetQRCodeTimeout(QRCodeId)
+}
+
+func (e *SyncedEnforcer) DeleteQRCode(QRCodeId string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.DeleteQRCode(QRCodeId)
+}
+
+func (e *SyncedEnforcer) Scanned(QRCodeId string, loginId string) (string, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.Scanned(QRCodeId, loginId)
+}
+
+func (e *SyncedEnforcer) ConfirmAuth(QRCodeTempToken string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.ConfirmAuth(QRCodeTempToken)
+}
+
+func (e *SyncedEnforcer) CancelAuth(QRCodeTempToken string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CancelAuth(QRCodeTempToken)
+}
+
+func (e *SyncedEnforcer) SetAuth(manager interface{}) {
+	e.m.Lock()
+	defer e.m.Unlock()
+	e.Enforcer.SetAuth(manager)
+}
+
+func (e *SyncedEnforcer) CheckRole(ctx ctx.Context, role string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CheckRole(ctx, role)
+}
+
+func (e *SyncedEnforcer) CheckPermission(ctx ctx.Context, permission string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.CheckPermission(ctx, permission)
+}
+
+func (e *SyncedEnforcer) GetSession(id string) *model.Session {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.GetSession(id)
+}
+
+func (e *SyncedEnforcer) DeleteSession(id string) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.DeleteSession(id)
+}
+
+func (e *SyncedEnforcer) UpdateSession(id string, session *model.Session) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.UpdateSession(id, session)
+}
+
+func (e *SyncedEnforcer) SetSession(id string, session *model.Session, timeout int64) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+	return e.Enforcer.SetSession(id, session, timeout)
+}
diff --git a/persist/default_adapter.go b/persist/default_adapter.go
index 0dfbeaa..e256cf1 100644
--- a/persist/default_adapter.go
+++ b/persist/default_adapter.go
@@ -25,6 +25,10 @@ func NewDefaultAdapter() *DefaultAdapter {
 	}
 }
 
+func (d *DefaultAdapter) SetCache(cache cache.Cache) {
+	d.cache = cache
+}
+
 func (d *DefaultAdapter) SetSerializer(serializer Serializer) {
 	d.serializer = serializer
 }