chore: 并入 iotlcm-admin-svr 历史到 admin-svr/（原提交 49818c6）
This commit is contained in:
MiFaZhan
@@ -0,0 +1,175 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/cmd/inithttp"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/mcache"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
"sort"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gogf/gf/v2/database/gdb"
|
||||
"github.com/gogf/gf/v2/errors/gerror"
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
var (
|
||||
db gdb.DB
|
||||
cacheUpdates sync.Mutex
|
||||
)
|
||||
|
||||
type rebuildSourceContextKey struct{}
|
||||
|
||||
func sourceContext(ctx context.Context) context.Context {
|
||||
if source, ok := ctx.Value(rebuildSourceContextKey{}).(context.Context); ok {
|
||||
return source
|
||||
}
|
||||
return ctx
|
||||
}
|
||||
|
||||
type memDB interface {
|
||||
Init(ctx context.Context) error
|
||||
EventHandler(ctx context.Context) error
|
||||
TableName(ctx context.Context) string
|
||||
CreateTable(ctx context.Context) error
|
||||
LoadData(ctx context.Context, pk int64) error
|
||||
DeleteData(ctx context.Context, ids []int64) error
|
||||
}
|
||||
|
||||
var memDBMap = make(map[string]memDB)
|
||||
|
||||
func RegisterMemDB(name string, memDB memDB) {
|
||||
memDBMap[name] = memDB
|
||||
}
|
||||
|
||||
type sMemoryDB struct {
|
||||
rebuildMu sync.Mutex
|
||||
}
|
||||
|
||||
func NewMemoryDB() *sMemoryDB {
|
||||
return &sMemoryDB{}
|
||||
}
|
||||
|
||||
func init() {
|
||||
service.RegisterMemoryDB(NewMemoryDB())
|
||||
inithttp.RegisterHttpInitFunc("memorydb", func(ctx context.Context) error {
|
||||
return service.MemoryDB().Init(ctx)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *sMemoryDB) Init(ctx context.Context) error {
|
||||
target, err := newMemoryDB(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if target == nil {
|
||||
return nil
|
||||
}
|
||||
db = target
|
||||
for _, name := range registeredMemoryDBNames() {
|
||||
if err = memDBMap[name].Init(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemoryDB.Init end.", target.GetConfig())
|
||||
return nil
|
||||
}
|
||||
|
||||
// Rebuild replaces all cached tables in one SQLite transaction. The single
|
||||
// connection keeps readers from observing partially loaded tables, and any
|
||||
// failure rolls the entire rebuild back.
|
||||
func (s *sMemoryDB) Rebuild(ctx context.Context) error {
|
||||
s.rebuildMu.Lock()
|
||||
defer s.rebuildMu.Unlock()
|
||||
cacheUpdates.Lock()
|
||||
defer cacheUpdates.Unlock()
|
||||
|
||||
target := db
|
||||
if target == nil {
|
||||
return errors.New("memory database is unavailable")
|
||||
}
|
||||
if err := target.Transaction(ctx, func(txCtx context.Context, _ gdb.TX) error {
|
||||
txCtx = context.WithValue(txCtx, rebuildSourceContextKey{}, ctx)
|
||||
for _, name := range registeredMemoryDBNames() {
|
||||
if err := memDBMap[name].CreateTable(txCtx); err != nil {
|
||||
return gerror.Wrapf(err, "rebuild memory database table failed: %s", name)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := mcache.Clear(ctx); err != nil {
|
||||
return gerror.Wrap(err, "clear derived memory cache failed")
|
||||
}
|
||||
g.Log().Infof(ctx, "memory database rebuilt, tables: %d", len(memDBMap))
|
||||
return nil
|
||||
}
|
||||
|
||||
func newMemoryDB(ctx context.Context) (gdb.DB, error) {
|
||||
link := g.Cfg().MustGet(ctx, "database.memorydb.link", "").String()
|
||||
debug := g.Cfg().MustGet(ctx, "database.memorydb.debug", "false").Bool()
|
||||
if link == "" {
|
||||
g.Log().Warning(ctx, "memory database link is empty; queries will use the primary database")
|
||||
return nil, nil
|
||||
}
|
||||
g.Log().Debug(ctx, "memory database link", link)
|
||||
target, err := gdb.New(gdb.ConfigNode{
|
||||
Link: link,
|
||||
MaxIdleConnCount: 1,
|
||||
MaxOpenConnCount: 1,
|
||||
MaxConnLifeTime: 24 * 3650 * time.Hour,
|
||||
Debug: debug,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if target == nil {
|
||||
return nil, errors.New("memory database is unavailable")
|
||||
}
|
||||
return target, nil
|
||||
}
|
||||
|
||||
func registeredMemoryDBNames() []string {
|
||||
names := make([]string, 0, len(memDBMap))
|
||||
for name := range memDBMap {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
return names
|
||||
}
|
||||
|
||||
func (s *sMemoryDB) EventHandler(ctx context.Context, chg *model.BroadcastDbChgCache) error {
|
||||
cacheUpdates.Lock()
|
||||
defer cacheUpdates.Unlock()
|
||||
memDB, ok := memDBMap[chg.TableName]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
if chg.Type == "add" || chg.Type == "edit" {
|
||||
for _, pk := range chg.PK {
|
||||
if err := memDB.LoadData(ctx, pk); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
} else if chg.Type == "del" {
|
||||
return memDB.DeleteData(ctx, chg.PK)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemoryDB) DB(ctx context.Context) gdb.DB {
|
||||
link := g.Cfg().MustGet(ctx, "database.memorydb.link", "sqlite::@file(:memory:)").String()
|
||||
if link == "" {
|
||||
return g.DB()
|
||||
}
|
||||
return db
|
||||
}
|
||||
|
||||
func (s *sMemoryDB) Ctx(ctx context.Context) gdb.DB {
|
||||
return s.DB(ctx).Ctx(ctx)
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/mcache"
|
||||
|
||||
_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
|
||||
"github.com/gogf/gf/v2/database/gdb"
|
||||
)
|
||||
|
||||
type rebuildTestTable struct {
|
||||
name string
|
||||
value string
|
||||
fail bool
|
||||
initEvents int
|
||||
}
|
||||
|
||||
func (t *rebuildTestTable) Init(context.Context) error {
|
||||
t.initEvents++
|
||||
return nil
|
||||
}
|
||||
func (t *rebuildTestTable) EventHandler(context.Context) error { return nil }
|
||||
func (t *rebuildTestTable) TableName(context.Context) string { return t.name }
|
||||
func (t *rebuildTestTable) LoadData(context.Context, int64) error {
|
||||
return nil
|
||||
}
|
||||
func (t *rebuildTestTable) DeleteData(context.Context, []int64) error {
|
||||
return nil
|
||||
}
|
||||
func (t *rebuildTestTable) CreateTable(ctx context.Context) error {
|
||||
if _, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+t.name); err != nil {
|
||||
return err
|
||||
}
|
||||
if t.fail {
|
||||
return errors.New("source load failed")
|
||||
}
|
||||
if _, err := db.Exec(ctx, "CREATE TABLE "+t.name+" (value TEXT)"); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Exec(ctx, "INSERT INTO "+t.name+" (value) VALUES (?)", t.value)
|
||||
return err
|
||||
}
|
||||
|
||||
func TestRebuildRollsBackAndDoesNotRegisterEventsAgain(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
previousDB, previousMap := db, memDBMap
|
||||
t.Cleanup(func() { db, memDBMap = previousDB, previousMap })
|
||||
var err error
|
||||
db, err = gdb.New(gdb.ConfigNode{Link: "sqlite::@file(:memory:)", MaxOpenConnCount: 1})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close(ctx) })
|
||||
|
||||
first := &rebuildTestTable{name: "cache_a", value: "new"}
|
||||
second := &rebuildTestTable{name: "cache_b", value: "new", fail: true}
|
||||
memDBMap = map[string]memDB{first.name: first, second.name: second}
|
||||
for _, name := range registeredMemoryDBNames() {
|
||||
if _, err := db.Exec(ctx, "CREATE TABLE "+name+" (value TEXT)"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := db.Exec(ctx, "INSERT INTO "+name+" (value) VALUES ('old')"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
cache := NewMemoryDB()
|
||||
if err := cache.Rebuild(ctx); err == nil {
|
||||
t.Fatal("expected rebuild failure")
|
||||
}
|
||||
for _, name := range registeredMemoryDBNames() {
|
||||
var result struct {
|
||||
Value string `json:"value"`
|
||||
}
|
||||
if err := db.Model(name).Scan(&result); err != nil || result.Value != "old" {
|
||||
t.Fatalf("%s was not rolled back: value=%q err=%v", name, result.Value, err)
|
||||
}
|
||||
}
|
||||
|
||||
second.fail = false
|
||||
if err := mcache.Set(ctx, "rebuild-test-key", "stale", 0); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := cache.Rebuild(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, name := range registeredMemoryDBNames() {
|
||||
var result struct {
|
||||
Value string `json:"value"`
|
||||
}
|
||||
if err := db.Model(name).Scan(&result); err != nil || result.Value != "new" {
|
||||
t.Fatalf("%s was not reloaded: value=%q err=%v", name, result.Value, err)
|
||||
}
|
||||
}
|
||||
if first.initEvents != 0 || second.initEvents != 0 {
|
||||
t.Fatal("rebuild registered event handlers")
|
||||
}
|
||||
if mcache.Instance().MustContains(ctx, "rebuild-test-key") {
|
||||
t.Fatal("derived cache was not cleared")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysConfig struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysConfig *sMemDBSysConfig
|
||||
|
||||
func NewMemDBSysConfig() *sMemDBSysConfig {
|
||||
if instanceMemDBSysConfig != nil {
|
||||
return instanceMemDBSysConfig
|
||||
}
|
||||
instanceMemDBSysConfig = &sMemDBSysConfig{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysConfig.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysConfig
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysConfig()
|
||||
service.RegisterMemDBSysConfig(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysConfigCreate,
|
||||
consts.EventKeyDBSysConfigUpdate,
|
||||
consts.EventKeyDBSysConfigDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "memorydb/sys_config.go event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysConfigDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory config failed: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysConfigCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysConfigDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) TableName(ctx context.Context) string {
|
||||
return dao.SysConfig.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysConfig.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysConfig.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_config" (
|
||||
"config_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"config_name" TEXT DEFAULT '' CHECK(length("config_name") <= 100),
|
||||
"config_key" TEXT DEFAULT '' CHECK(length("config_key") <= 100),
|
||||
"config_value" TEXT DEFAULT '' CHECK(length("config_value") <= 1024),
|
||||
"config_type" TEXT DEFAULT 'N',
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER,
|
||||
"created_at" TEXT,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" TEXT,
|
||||
"remark" TEXT CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysConfig.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxConfigId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysConfig, 0)
|
||||
if err := dao.SysConfig.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysConfig.Columns().ConfigId, maxConfigId).
|
||||
OrderAsc(dao.SysConfig.Columns().ConfigId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysConfig.Table()).Data(dataList).OnConflict(dao.SysConfig.Columns().ConfigId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxConfigId = dataList[len(dataList)-1].ConfigId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysConfig, 0)
|
||||
if err := dao.SysConfig.Ctx(sourceContext(ctx)).Where(dao.SysConfig.Columns().ConfigId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysConfig.Table()).Data(dataList).OnConflict(dao.SysConfig.Columns().ConfigId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
g.Log().Debugf(ctx, "sMemDBSysConfig.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysConfig) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysConfig.Table()).WhereIn(dao.SysConfig.Columns().ConfigId, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysConfig.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysConfig.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysDept struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysDept *sMemDBSysDept
|
||||
|
||||
func NewMemDBSysDept() *sMemDBSysDept {
|
||||
if instanceMemDBSysDept != nil {
|
||||
return instanceMemDBSysDept
|
||||
}
|
||||
instanceMemDBSysDept = &sMemDBSysDept{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysDept.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysDept
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysDept()
|
||||
service.RegisterMemDBSysDept(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysDeptCreate,
|
||||
consts.EventKeyDBSysDeptUpdate,
|
||||
consts.EventKeyDBSysDeptDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDeptDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory dept failed: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDeptCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysDeptDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) TableName(ctx context.Context) string {
|
||||
return dao.SysDept.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysDept.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysDept.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_dept" (
|
||||
"dept_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"parent_id" INTEGER DEFAULT 0,
|
||||
"ancestors" TEXT DEFAULT '' CHECK(length("ancestors") <= 500),
|
||||
"dept_key" TEXT DEFAULT '' CHECK(length("dept_key") == 15 OR "dept_key" == '' OR "dept_key" IS NULL),
|
||||
"dept_name" TEXT DEFAULT '' CHECK(length("dept_name") <= 30),
|
||||
"dept_type" INTEGER DEFAULT 0,
|
||||
"dept_category" TEXT CHECK(length("dept_category") <= 100),
|
||||
"credit_code" TEXT CHECK(length("credit_code") == 18 OR "credit_code" == '' OR "credit_code" IS NULL),
|
||||
"area_code" TEXT CHECK(length("area_code") == 12 OR "area_code" == '' OR "area_code" IS NULL),
|
||||
"address" TEXT CHECK(length("address") <= 200),
|
||||
"order_num" INTEGER DEFAULT 0,
|
||||
"leader" INTEGER,
|
||||
"phone" TEXT CHECK(length("phone") <= 11),
|
||||
"email" TEXT CHECK(length("email") <= 50),
|
||||
"status" TEXT DEFAULT '0' ,
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER NOT NULL,
|
||||
"created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"deleted_by" INTEGER,
|
||||
"deleted_at" DATETIME
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysDept.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxDeptId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 100
|
||||
dataList := make([]*entity.SysDept, 0)
|
||||
if err := dao.SysDept.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysDept.Columns().DeptId, maxDeptId).
|
||||
OrderAsc(dao.SysDept.Columns().DeptId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDept.Table()).Data(dataList).OnConflict(dao.SysDept.Columns().DeptId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxDeptId = dataList[len(dataList)-1].DeptId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysDept, 0)
|
||||
if err := dao.SysDept.Ctx(sourceContext(ctx)).Where(dao.SysDept.Columns().DeptId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDept.Table()).Data(dataList).OnConflict(dao.SysDept.Columns().DeptId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
g.Log().Debugf(ctx, "sMemDBSysDept.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDept) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDept.Table()).WhereIn(dao.SysDept.Columns().DeptId, ids).Unscoped().Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDept.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysDept.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysDictData struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysDictData *sMemDBSysDictData
|
||||
|
||||
func NewMemDBSysDictData() *sMemDBSysDictData {
|
||||
if instanceMemDBSysDictData != nil {
|
||||
return instanceMemDBSysDictData
|
||||
}
|
||||
instanceMemDBSysDictData = &sMemDBSysDictData{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysDictData.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysDictData
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysDictData()
|
||||
service.RegisterMemDBSysDictData(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysDictDataCreate,
|
||||
consts.EventKeyDBSysDictDataUpdate,
|
||||
consts.EventKeyDBSysDictDataDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDictDataDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory dict data failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDictDataCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysDictDataDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) TableName(ctx context.Context) string {
|
||||
return dao.SysDictData.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysDictData.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysDictData.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_dict_data" (
|
||||
"dict_code" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"dict_sort" INTEGER DEFAULT 0,
|
||||
"dict_label" TEXT DEFAULT '' CHECK(length("dict_label") <= 100),
|
||||
"dict_value" TEXT DEFAULT '' CHECK(length("dict_value") <= 100),
|
||||
"dict_type" TEXT DEFAULT '' CHECK(length("dict_type") <= 100),
|
||||
"css_class" TEXT CHECK(length("css_class") <= 100),
|
||||
"list_class" TEXT CHECK(length("list_class") <= 100),
|
||||
"is_default" TEXT DEFAULT 'N' ,
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER,
|
||||
"created_at" TEXT,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" TEXT,
|
||||
"remark" TEXT CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysDictData.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxDictCode := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysDictData, 0)
|
||||
if err := dao.SysDictData.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysDictData.Columns().DictCode, maxDictCode).
|
||||
OrderAsc(dao.SysDictData.Columns().DictCode).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictData.Table()).Data(dataList).OnConflict(dao.SysDictData.Columns().DictCode).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxDictCode = dataList[len(dataList)-1].DictCode
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysDictData, 0)
|
||||
if err := dao.SysDictData.Ctx(sourceContext(ctx)).Where(dao.SysDictData.Columns().DictCode, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictData.Table()).Data(dataList).OnConflict(dao.SysDictData.Columns().DictCode).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
g.Log().Debugf(ctx, "sMemDBSysDictData.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictData) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictData.Table()).WhereIn(dao.SysDictData.Columns().DictCode, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictData.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysDictData.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysDictType struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysDictType *sMemDBSysDictType
|
||||
|
||||
func NewMemDBSysDictType() *sMemDBSysDictType {
|
||||
if instanceMemDBSysDictType != nil {
|
||||
return instanceMemDBSysDictType
|
||||
}
|
||||
instanceMemDBSysDictType = &sMemDBSysDictType{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysDictType.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysDictType
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysDictType()
|
||||
service.RegisterMemDBSysDictType(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysDictTypeCreate,
|
||||
consts.EventKeyDBSysDictTypeUpdate,
|
||||
consts.EventKeyDBSysDictTypeDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDictTypeDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory dict type failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysDictTypeCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysDictTypeDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) TableName(ctx context.Context) string {
|
||||
return dao.SysDictType.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysDictType.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysDictType.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_dict_type" (
|
||||
"dict_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"dict_name" TEXT DEFAULT '' CHECK(length("dict_name") <= 100),
|
||||
"dict_type" TEXT DEFAULT '' CHECK(length("dict_type") <= 100),
|
||||
"is_sys" TEXT DEFAULT '1' ,
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER,
|
||||
"created_at" TEXT,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" TEXT,
|
||||
"remark" TEXT CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysDictType.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxDictId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysDictType, 0)
|
||||
if err := dao.SysDictType.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysDictType.Columns().DictId, maxDictId).
|
||||
OrderAsc(dao.SysDictType.Columns().DictId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictType.Table()).Data(dataList).OnConflict(dao.SysDictType.Columns().DictId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxDictId = dataList[len(dataList)-1].DictId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysDictType, 0)
|
||||
if err := dao.SysDictType.Ctx(sourceContext(ctx)).Where(dao.SysDictType.Columns().DictId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictType.Table()).Data(dataList).OnConflict(dao.SysDictType.Columns().DictId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
g.Log().Debugf(ctx, "sMemDBSysDictType.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysDictType) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysDictType.Table()).WhereIn(dao.SysDictType.Columns().DictId, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysDictType.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysDictType.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysMenu struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysMenu *sMemDBSysMenu
|
||||
|
||||
func NewMemDBSysMenu() *sMemDBSysMenu {
|
||||
if instanceMemDBSysMenu != nil {
|
||||
return instanceMemDBSysMenu
|
||||
}
|
||||
instanceMemDBSysMenu = &sMemDBSysMenu{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysMenu.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysMenu
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysMenu()
|
||||
service.RegisterMemDBSysMenu(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysMenuCreate,
|
||||
consts.EventKeyDBSysMenuUpdate,
|
||||
consts.EventKeyDBSysMenuDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysMenuDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory menu failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysMenuCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysMenuDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) TableName(ctx context.Context) string {
|
||||
return dao.SysMenu.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysMenu.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysMenu.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_menu" (
|
||||
"menu_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"menu_name" TEXT NOT NULL CHECK(length("menu_name") <= 50),
|
||||
"parent_id" INTEGER DEFAULT 0,
|
||||
"level" INTEGER DEFAULT 1,
|
||||
"tree" TEXT CHECK(length("tree") <= 255),
|
||||
"order_num" INTEGER DEFAULT 0,
|
||||
"path" TEXT DEFAULT '' CHECK(length("path") <= 200),
|
||||
"component" TEXT CHECK(length("component") <= 255),
|
||||
"query_param" TEXT CHECK(length("query_param") <= 255),
|
||||
"is_frame" INTEGER DEFAULT 1 ,
|
||||
"is_cache" INTEGER DEFAULT 0 ,
|
||||
"menu_type" TEXT DEFAULT '' ,
|
||||
"visible" TEXT DEFAULT '0',
|
||||
"status" TEXT DEFAULT '0' ,
|
||||
"perms" TEXT CHECK(length("perms") <= 100),
|
||||
"icon" TEXT DEFAULT '#' CHECK(length("icon") <= 100),
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER,
|
||||
"created_at" TEXT,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" TEXT,
|
||||
"remark" TEXT DEFAULT '' CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysMenu.CreateTable create table success", res)
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxMenuId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysMenu, 0)
|
||||
if err := dao.SysMenu.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysMenu.Columns().MenuId, maxMenuId).
|
||||
OrderAsc(dao.SysMenu.Columns().MenuId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysMenu.Table()).Data(dataList).OnConflict(dao.SysMenu.Columns().MenuId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxMenuId = dataList[len(dataList)-1].MenuId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysMenu, 0)
|
||||
if err := dao.SysMenu.Ctx(sourceContext(ctx)).Where(dao.SysMenu.Columns().MenuId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysMenu.Table()).Data(dataList).OnConflict(dao.SysMenu.Columns().MenuId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysMenu.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysMenu) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysMenu.Table()).WhereIn(dao.SysMenu.Columns().MenuId, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysMenu.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysMenu.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysPost struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysPost *sMemDBSysPost
|
||||
|
||||
func NewMemDBSysPost() *sMemDBSysPost {
|
||||
if instanceMemDBSysPost != nil {
|
||||
return instanceMemDBSysPost
|
||||
}
|
||||
instanceMemDBSysPost = &sMemDBSysPost{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysPost.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysPost
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysPost()
|
||||
service.RegisterMemDBSysPost(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysPostCreate,
|
||||
consts.EventKeyDBSysPostUpdate,
|
||||
consts.EventKeyDBSysPostDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysPostDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory post failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysPostCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysPostDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) TableName(ctx context.Context) string {
|
||||
return dao.SysPost.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysPost.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysPost.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_post" (
|
||||
"post_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"dept_id" INTEGER NOT NULL,
|
||||
"post_code" TEXT NOT NULL CHECK(length("post_code") <= 64),
|
||||
"post_category" TEXT CHECK(length("post_category") <= 100),
|
||||
"post_name" TEXT NOT NULL CHECK(length("post_name") <= 50),
|
||||
"post_sort" INTEGER NOT NULL,
|
||||
"status" TEXT NOT NULL ,
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER NOT NULL,
|
||||
"created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"deleted_by" INTEGER,
|
||||
"deleted_at" DATETIME,
|
||||
"remark" TEXT CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysPost.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxPostId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysPost, 0)
|
||||
if err := dao.SysPost.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysPost.Columns().PostId, maxPostId).
|
||||
OrderAsc(dao.SysPost.Columns().PostId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysPost.Table()).Data(dataList).OnConflict(dao.SysPost.Columns().PostId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxPostId = dataList[len(dataList)-1].PostId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysPost, 0)
|
||||
if err := dao.SysPost.Ctx(sourceContext(ctx)).Where(dao.SysPost.Columns().PostId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysPost.Table()).Data(dataList).OnConflict(dao.SysPost.Columns().PostId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysPost.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysPost) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysPost.Table()).WhereIn(dao.SysPost.Columns().PostId, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysPost.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysPost.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysRole struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysRole *sMemDBSysRole
|
||||
|
||||
func NewMemDBSysRole() *sMemDBSysRole {
|
||||
if instanceMemDBSysRole != nil {
|
||||
return instanceMemDBSysRole
|
||||
}
|
||||
instanceMemDBSysRole = &sMemDBSysRole{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysRole.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysRole
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysRole()
|
||||
service.RegisterMemDBSysRole(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysRoleCreate,
|
||||
consts.EventKeyDBSysRoleUpdate,
|
||||
consts.EventKeyDBSysRoleDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysRoleDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory role failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysRoleCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysRoleDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) TableName(ctx context.Context) string {
|
||||
return dao.SysRole.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysRole.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysRole.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_role" (
|
||||
"role_id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT DEFAULT '000000' CHECK(length("tenant_id") <= 20),
|
||||
"dept_id" INTEGER DEFAULT 0,
|
||||
"role_name" TEXT NOT NULL CHECK(length("role_name") <= 30),
|
||||
"role_key" TEXT NOT NULL CHECK(length("role_key") <= 100),
|
||||
"role_sort" INTEGER NOT NULL,
|
||||
"data_scope" TEXT DEFAULT '1',
|
||||
"menu_check_strictly" INTEGER DEFAULT 1,
|
||||
"dept_check_strictly" INTEGER DEFAULT 1,
|
||||
"is_pass" INTEGER NOT NULL DEFAULT 0,
|
||||
"source_role_id" INTEGER NOT NULL DEFAULT 0,
|
||||
"source_dept_id" INTEGER NOT NULL DEFAULT 0,
|
||||
"status" TEXT NOT NULL ,
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER NOT NULL,
|
||||
"created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"deleted_by" INTEGER,
|
||||
"deleted_at" DATETIME,
|
||||
"remark" TEXT CHECK(length("remark") <= 500)
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysRole.CreateTable create table success", res)
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxRoleId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysRole, 0)
|
||||
if err := dao.SysRole.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysRole.Columns().RoleId, maxRoleId).
|
||||
OrderAsc(dao.SysRole.Columns().RoleId).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysRole.Table()).Data(dataList).OnConflict(dao.SysRole.Columns().RoleId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
maxRoleId = dataList[len(dataList)-1].RoleId
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysRole, 0)
|
||||
if err := dao.SysRole.Ctx(sourceContext(ctx)).Where(dao.SysRole.Columns().RoleId, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysRole.Table()).Data(dataList).OnConflict(dao.SysRole.Columns().RoleId).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysRole.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysRole) DeleteData(ctx context.Context, ids []int64) error {
|
||||
g.Log().Debugf(ctx, "sMemDBSysRole.DeleteData called with ids: %+v, len: %d", ids, len(ids))
|
||||
|
||||
if len(ids) == 0 {
|
||||
g.Log().Warningf(ctx, "sMemDBSysRole.DeleteData called with empty ids")
|
||||
return nil
|
||||
}
|
||||
|
||||
// 使用 Unscoped() 来确保删除操作被执行
|
||||
_, err := db.Ctx(ctx).Model(dao.SysRole.Table()).WhereIn(dao.SysRole.Columns().RoleId, ids).Unscoped().Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysRole.DeleteData err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysRole.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
package memorydb
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/dao"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/event"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model/entity"
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/service"
|
||||
|
||||
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/utility/queue"
|
||||
|
||||
"github.com/gogf/gf/v2/database/gdb"
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
)
|
||||
|
||||
type sMemDBSysTenant struct {
|
||||
}
|
||||
|
||||
var instanceMemDBSysTenant *sMemDBSysTenant
|
||||
|
||||
func NewMemDBSysTenant() *sMemDBSysTenant {
|
||||
if instanceMemDBSysTenant != nil {
|
||||
return instanceMemDBSysTenant
|
||||
}
|
||||
instanceMemDBSysTenant = &sMemDBSysTenant{}
|
||||
initLoadMemoryDB := g.Cfg().MustGet(context.TODO(), "server.initLoadMemoryDB").Bool()
|
||||
if initLoadMemoryDB {
|
||||
instanceMemDBSysTenant.Init(context.TODO())
|
||||
}
|
||||
return instanceMemDBSysTenant
|
||||
}
|
||||
|
||||
func init() {
|
||||
s := NewMemDBSysTenant()
|
||||
service.RegisterMemDBSysTenant(s)
|
||||
RegisterMemDB(s.TableName(context.TODO()), s)
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) Init(ctx context.Context) error {
|
||||
err := s.CreateTable(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = s.EventHandler(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) EventHandler(ctx context.Context) error {
|
||||
eventList := []string{
|
||||
consts.EventKeyDBSysTenantCreate,
|
||||
consts.EventKeyDBSysTenantUpdate,
|
||||
consts.EventKeyDBSysTenantDelete,
|
||||
}
|
||||
event.EventsInstance().Register(eventList, func(ctx context.Context, eventKey string, args ...interface{}) {
|
||||
if len(args) < 1 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList, ok := args[0].([]int64)
|
||||
if !ok {
|
||||
pk, ok := args[0].(int64)
|
||||
if !ok {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
pkList = []int64{pk}
|
||||
}
|
||||
if len(pkList) == 0 {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.EventHandler event args error. eventKey: %s, args: %+v", eventKey, args)
|
||||
return
|
||||
}
|
||||
changeType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysTenantDelete {
|
||||
changeType = "del"
|
||||
}
|
||||
if err := service.MemoryDB().EventHandler(ctx, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx), PK: pkList, Type: changeType,
|
||||
}); err != nil {
|
||||
g.Log().Errorf(ctx, "refresh memory tenant failed: %v", err)
|
||||
return
|
||||
}
|
||||
dbType := "edit"
|
||||
if eventKey == consts.EventKeyDBSysTenantCreate {
|
||||
dbType = "add"
|
||||
} else if eventKey == consts.EventKeyDBSysTenantDelete {
|
||||
dbType = "del"
|
||||
} else {
|
||||
dbType = "edit"
|
||||
}
|
||||
queue.Push(ctx, consts.BroadcastDbChg, &model.BroadcastDbChgCache{
|
||||
TableName: s.TableName(ctx),
|
||||
PK: pkList,
|
||||
Type: dbType,
|
||||
Data: nil,
|
||||
})
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) DB(ctx context.Context) gdb.DB {
|
||||
return db
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) TableName(ctx context.Context) string {
|
||||
return dao.SysTenant.Table()
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) CreateTable(ctx context.Context) error {
|
||||
_, err := db.Exec(ctx, "DROP TABLE IF EXISTS "+s.TableName(ctx))
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.CreateTable delete table err: %v", err)
|
||||
return err
|
||||
}
|
||||
|
||||
total, err := db.Ctx(ctx).Model("sqlite_master").Where("type", "table").Where("name", dao.SysTenant.Table()).Count()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.CreateTable count err: %v", err)
|
||||
return err
|
||||
}
|
||||
if total == 0 {
|
||||
g.Log().Debug(ctx, "sMemDBSysTenant.List create table ", s.TableName(ctx))
|
||||
res, err := db.Exec(ctx, `
|
||||
CREATE TABLE "sys_tenant" (
|
||||
"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
|
||||
"tenant_id" TEXT NOT NULL CHECK(length("tenant_id") <= 20),
|
||||
"contact_user_name" TEXT CHECK(length("contact_user_name") <= 20),
|
||||
"contact_phone" TEXT CHECK(length("contact_phone") <= 20),
|
||||
"company_name" TEXT CHECK(length("company_name") <= 50),
|
||||
"license_number" TEXT CHECK(length("license_number") <= 30),
|
||||
"address" TEXT CHECK(length("address") <= 200),
|
||||
"intro" TEXT CHECK(length("intro") <= 200),
|
||||
"domain" TEXT CHECK(length("domain") <= 200),
|
||||
"remark" TEXT CHECK(length("remark") <= 200),
|
||||
"package_id" INTEGER,
|
||||
"expire_time" TEXT,
|
||||
"account_count" INTEGER DEFAULT -1,
|
||||
"status" TEXT DEFAULT '0',
|
||||
"created_dept" INTEGER,
|
||||
"created_by" INTEGER NOT NULL,
|
||||
"created_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updated_by" INTEGER,
|
||||
"updated_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"deleted_by" INTEGER,
|
||||
"deleted_at" DATETIME,
|
||||
CONSTRAINT "sys_tenant_tenant_id_unique" UNIQUE ("tenant_id")
|
||||
);
|
||||
`)
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.CreateTable create table err: %v", err)
|
||||
return err
|
||||
}
|
||||
g.Log().Debug(ctx, "sMemDBSysTenant.CreateTable create table success", res)
|
||||
// 加载数据
|
||||
return s.LoadData(ctx, 0)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) LoadData(ctx context.Context, pk int64) error {
|
||||
count := 0
|
||||
if pk == 0 {
|
||||
maxId := int64(0)
|
||||
for {
|
||||
page := 1
|
||||
pageSize := 500
|
||||
dataList := make([]*entity.SysTenant, 0)
|
||||
if err := dao.SysTenant.Ctx(sourceContext(ctx)).Page(page, pageSize).WhereGT(dao.SysTenant.Columns().Id, maxId).
|
||||
OrderAsc(dao.SysTenant.Columns().Id).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(dataList) == 0 {
|
||||
break
|
||||
}
|
||||
count += len(dataList)
|
||||
_, err := db.Ctx(ctx).Model(dao.SysTenant.Table()).Data(dataList).OnConflict(dao.SysTenant.Columns().Id).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.Load data insert err: %v, dataList: %+v", err, dataList)
|
||||
return err
|
||||
}
|
||||
maxId = dataList[len(dataList)-1].Id
|
||||
if len(dataList) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dataList := make([]*entity.SysTenant, 0)
|
||||
if err := dao.SysTenant.Ctx(sourceContext(ctx)).Where(dao.SysTenant.Columns().Id, pk).Scan(&dataList); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := db.Ctx(ctx).Model(dao.SysTenant.Table()).Data(dataList).OnConflict(dao.SysTenant.Columns().Id).Save()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.Load data insert err: %v", err)
|
||||
return err
|
||||
}
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysTenant.LoadData load data success, total: %d, pk: %d", count, pk)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *sMemDBSysTenant) DeleteData(ctx context.Context, ids []int64) error {
|
||||
_, err := db.Ctx(ctx).Model(dao.SysTenant.Table()).WhereIn(dao.SysTenant.Columns().Id, ids).Delete()
|
||||
if err != nil {
|
||||
g.Log().Errorf(ctx, "sMemDBSysTenant.DeleteData err: %v, ids: %+v", err, ids)
|
||||
return err
|
||||
}
|
||||
g.Log().Debugf(ctx, "sMemDBSysTenant.DeleteData delete data success, total: %d, ids: %+v", len(ids), ids)
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user