baize-scaffold/utm/data_loader/data_loader.go

package data_loader

import (
	"os"
	"path/filepath"

	"git.sxidc.com/go-tools/utils/fileutils"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
	"gopkg.in/yaml.v3"
)

var dataLoaderInstance *DataLoader

func GetDataLoader() *DataLoader {
	return dataLoaderInstance
}

func Init() {
	dataDir := os.Getenv("DATA_LOADER_DATA_DIR")
	if strutils.IsStringEmpty(dataDir) {
		panic("DATA_LOADER_DATA_DIR环境变量未设置")
	}

	dataDirAbs, err := filepath.Abs(dataDir)
	if err != nil {
		panic(err)
	}

	if !fileutils.PathExists(dataDirAbs) {
		panic("数据目录不存在")
	}

	tenantsDataFilePath := filepath.Join(dataDirAbs, "tenants.yaml")
	if !fileutils.PathExists(tenantsDataFilePath) {
		panic("租户数据不存在")
	}

	usersDataFilePath := filepath.Join(dataDirAbs, "users.yaml")
	if !fileutils.PathExists(usersDataFilePath) {
		panic("用户数据不存在")
	}

	rolesDataFilePath := filepath.Join(dataDirAbs, "roles.yaml")
	if !fileutils.PathExists(rolesDataFilePath) {
		panic("角色数据不存在")
	}

	d, err := LoadData(tenantsDataFilePath, usersDataFilePath, rolesDataFilePath)
	if err != nil {
		panic(err)
	}

	dataLoaderInstance = d
}

type Tenant struct {
	ID   string `yaml:"id"`
	Name string `yaml:"name"`
}

type User struct {
	ID              string   `yaml:"id"`
	UserName        string   `yaml:"username"`
	Password        string   `yaml:"password"`
	RoleIDs         []string `yaml:"role_ids"`
	CurrentTenantID string   `yaml:"current_tenant_id"`
}

type Role struct {
	ID          string       `yaml:"id"`
	Name        string       `yaml:"name"`
	Permissions []Permission `yaml:"permissions"`
}

type Permission struct {
	Resource string `yaml:"resource"`
	Action   string `yaml:"action"`
}

type DataLoader struct {
	Tenants []Tenant `yaml:"tenants"`
	Users   []User   `yaml:"users"`
	Roles   []Role   `yaml:"roles"`
}

func LoadData(tenantsDataFilePath string, usersDataFilePath string, rolesDataFilePath string) (*DataLoader, error) {
	dataLoader := new(DataLoader)

	tenantsData, err := os.ReadFile(tenantsDataFilePath)
	if err != nil {
		return nil, err
	}

	err = yaml.Unmarshal(tenantsData, &dataLoader.Tenants)
	if err != nil {
		return nil, err
	}

	usersData, err := os.ReadFile(usersDataFilePath)
	if err != nil {
		return nil, err
	}

	err = yaml.Unmarshal(usersData, &dataLoader.Users)
	if err != nil {
		return nil, err
	}

	rolesData, err := os.ReadFile(rolesDataFilePath)
	if err != nil {
		return nil, err
	}

	err = yaml.Unmarshal(rolesData, &dataLoader.Roles)
	if err != nil {
		return nil, err
	}

	return dataLoader, nil
}

func (d *DataLoader) GetUserByUserNameAndPassword(userName string, password string) (User, error) {
	for _, user := range d.Users {
		if user.UserName == userName && user.Password == password {
			return user, nil
		}
	}

	return User{}, errors.New("用户名或密码错误")
}

func (d *DataLoader) GetUserByID(userID string) (User, error) {
	for _, user := range d.Users {
		if user.ID == userID {
			return user, nil
		}
	}

	return User{}, errors.New("用户不存在")
}

func (d *DataLoader) GetTenantByID(tenantID string) (Tenant, error) {
	for _, tenant := range d.Tenants {
		if tenant.ID == tenantID {
			return tenant, nil
		}
	}

	return Tenant{}, nil
}

func (d *DataLoader) GetRolesByIDs(roleIDs []string) ([]Role, error) {
	roles := make([]Role, 0)

	if roleIDs == nil || len(roleIDs) == 0 {
		return roles, nil
	}

	for _, roleID := range roleIDs {
		for _, role := range d.Roles {
			if role.ID == roleID {
				roles = append(roles, role)
			}
		}
	}

	return roles, nil
}