新增系统设置接口

This commit is contained in:
wxb committed 2020-08-07 10:22:52 +08:00
commit 389d2970c0
150 files changed
+21555

No files matched your search

+16
View File
@@ -0,0 +1,16 @@
package models
//casbin_rule
type CasbinRule struct {
PType string `json:"p_type" gorm:"size:100;"`
V0 string `json:"v0" gorm:"size:100;"`
V1 string `json:"v1" gorm:"size:100;"`
V2 string `json:"v2" gorm:"size:100;"`
V3 string `json:"v3" gorm:"size:100;"`
V4 string `json:"v4" gorm:"size:100;"`
V5 string `json:"v5" gorm:"size:100;"`
}
func (CasbinRule) TableName() string {
return "casbin_rule"
}
+138
View File
@@ -0,0 +1,138 @@
package models
import (
"errors"
orm "go-admin/global"
"go-admin/tools"
_ "time"
)
type SysConfig struct {
ConfigId int `json:"configId" gorm:"primary_key;auto_increment;"` //编码
ConfigName string `json:"configName" gorm:"size:128;"` //参数名称
ConfigKey string `json:"configKey" gorm:"size:128;"` //参数键名
ConfigValue string `json:"configValue" gorm:"size:255;"` //参数键值
ConfigType string `json:"configType" gorm:"size:64;"` //是否系统内置
Remark string `json:"remark" gorm:"size:128;"` //备注
CreateBy string `json:"createBy" gorm:"size:128;"`
UpdateBy string `json:"updateBy" gorm:"size:128;"`
DataScope string `json:"dataScope" gorm:"-"`
Params string `json:"params" gorm:"-"`
BaseModel
}
func DataInit() {
//config1:=SysConfig{1, "主框架页-默认皮肤样式名称", "sys_index_skinName", "skin-blue", "Y", "蓝色 skin-blue、绿色 skin-green、紫色 skin-purple、红色 skin-red、黄色 skin-yellow", "1", "1", "","",BaseModel{time.Now(), time.Now(), nil}}
//
//orm.Eloquent.Create(&config1)
}
func (SysConfig) TableName() string {
return "sys_config"
}
// Config 创建
func (e *SysConfig) Create() (SysConfig, error) {
var doc SysConfig
i := 0
orm.Eloquent.Table(e.TableName()).Where("config_name=? or config_key = ?", e.ConfigName, e.ConfigKey).Count(&i)
if i > 0 {
return doc, errors.New("参数名称或者参数键名已经存在!")
}
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
// 获取 Config
func (e *SysConfig) Get() (SysConfig, error) {
var doc SysConfig
table := orm.Eloquent.Table(e.TableName())
if e.ConfigId != 0 {
table = table.Where("config_id = ?", e.ConfigId)
}
if e.ConfigKey != "" {
table = table.Where("config_key = ?", e.ConfigKey)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *SysConfig) GetPage(pageSize int, pageIndex int) ([]SysConfig, int, error) {
var doc []SysConfig
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.ConfigName != "" {
table = table.Where("config_name = ?", e.ConfigName)
}
if e.ConfigKey != "" {
table = table.Where("config_key = ?", e.ConfigKey)
}
if e.ConfigType != "" {
table = table.Where("config_type = ?", e.ConfigType)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope("sys_config", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *SysConfig) Update(id int) (update SysConfig, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("config_id = ?", id).First(&update).Error; err != nil {
return
}
if e.ConfigName != "" && e.ConfigName != update.ConfigName {
return update, errors.New("参数名称不允许修改!")
}
if e.ConfigKey != "" && e.ConfigKey != update.ConfigKey {
return update, errors.New("参数键名不允许修改!")
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *SysConfig) Delete() (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("config_id = ?", e.ConfigId).Delete(&SysConfig{}).Error; err != nil {
success = false
return
}
success = true
return
}
func (e *SysConfig) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("config_id in (?)", id).Delete(&SysConfig{}).Error; err != nil {
return
}
Result = true
return
}
+51
View File
@@ -0,0 +1,51 @@
package models
import (
"errors"
"fmt"
"github.com/jinzhu/gorm"
"go-admin/tools"
"go-admin/tools/config"
)
type DataPermission struct {
DataScope string
UserId int
DeptId int
RoleId int
}
func (e *DataPermission) GetDataScope(tbname string, table *gorm.DB) (*gorm.DB, error) {
if !config.ApplicationConfig.EnableDP {
usageStr := `数据权限已经为您` + tools.Green(`关闭`) + `,如需开启请参考配置文件字段说明`
fmt.Printf("%s\n", usageStr)
return table, nil
}
SysUser := new(SysUser)
SysRole := new(SysRole)
SysUser.UserId = e.UserId
user, err := SysUser.Get()
if err != nil {
return nil, errors.New("获取用户数据出错 msg:" + err.Error())
}
SysRole.RoleId = user.RoleId
role, err := SysRole.Get()
if err != nil {
return nil, errors.New("获取用户数据出错 msg:" + err.Error())
}
if role.DataScope == "2" {
table = table.Where(tbname+".create_by in (select sys_user.user_id from sys_role_dept left join sys_user on sys_user.dept_id=sys_role_dept.dept_id where sys_role_dept.role_id = ?)", user.RoleId)
}
if role.DataScope == "3" {
table = table.Where(tbname+".create_by in (SELECT user_id from sys_user where dept_id = ? )", user.DeptId)
}
if role.DataScope == "4" {
table = table.Where(tbname+".create_by in (SELECT user_id from sys_user where sys_user.dept_id in(select dept_id from sys_dept where dept_path like ? ))", "%"+tools.IntToString(user.DeptId)+"%")
}
if role.DataScope == "5" || role.DataScope == "" {
table = table.Where(tbname+".create_by = ?", e.UserId)
}
return table, nil
}
+274
View File
@@ -0,0 +1,274 @@
package models
import (
"errors"
orm "go-admin/global"
"go-admin/tools"
_ "time"
)
type SysDept struct {
DeptId int `json:"deptId" gorm:"primary_key;AUTO_INCREMENT"` //部门编码
ParentId int `json:"parentId" gorm:""` //上级部门
DeptPath string `json:"deptPath" gorm:"size:255;"` //
DeptName string `json:"deptName" gorm:"size:128;"` //部门名称
Sort int `json:"sort" gorm:""` //排序
Leader string `json:"leader" gorm:"size:128;"` //负责人
Phone string `json:"phone" gorm:"size:11;"` //手机
Email string `json:"email" gorm:"size:64;"` //邮箱
Status string `json:"status" gorm:"size:4;"` //状态
CreateBy string `json:"createBy" gorm:"size:64;"`
UpdateBy string `json:"updateBy" gorm:"size:64;"`
DataScope string `json:"dataScope" gorm:"-"`
Params string `json:"params" gorm:"-"`
Children []SysDept `json:"children" gorm:"-"`
BaseModel
}
func (SysDept) TableName() string {
return "sys_dept"
}
type DeptLable struct {
Id int `gorm:"-" json:"id"`
Label string `gorm:"-" json:"label"`
Children []DeptLable `gorm:"-" json:"children"`
}
func (e *SysDept) Create() (SysDept, error) {
var doc SysDept
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
deptPath := "/" + tools.IntToString(e.DeptId)
if int(e.ParentId) != 0 {
var deptP SysDept
orm.Eloquent.Table(e.TableName()).Where("dept_id = ?", e.ParentId).First(&deptP)
deptPath = deptP.DeptPath + deptPath
} else {
deptPath = "/0" + deptPath
}
var mp = map[string]string{}
mp["deptPath"] = deptPath
if err := orm.Eloquent.Table(e.TableName()).Where("dept_id = ?", e.DeptId).Update(mp).Error; err != nil {
err := result.Error
return doc, err
}
doc = *e
doc.DeptPath = deptPath
return doc, nil
}
func (e *SysDept) Get() (SysDept, error) {
var doc SysDept
table := orm.Eloquent.Table(e.TableName())
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.DeptName != "" {
table = table.Where("dept_name = ?", e.DeptName)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *SysDept) GetList() ([]SysDept, error) {
var doc []SysDept
table := orm.Eloquent.Table(e.TableName())
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.DeptName != "" {
table = table.Where("dept_name = ?", e.DeptName)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if err := table.Order("sort").Find(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *SysDept) GetPage(bl bool) ([]SysDept, error) {
var doc []SysDept
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.DeptName != "" {
table = table.Where("dept_name = ?", e.DeptName)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if e.DeptPath != "" {
table = table.Where("deptPath like %?%", e.DeptPath)
}
if bl {
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
tableper, err := dataPermission.GetDataScope("sys_dept", table)
if err != nil {
return nil, err
}
table = tableper
}
if err := table.Order("sort").Find(&doc).Error; err != nil {
return nil, err
}
return doc, nil
}
func (e *SysDept) SetDept(bl bool) ([]SysDept, error) {
list, err := e.GetPage(bl)
m := make([]SysDept, 0)
for i := 0; i < len(list); i++ {
if list[i].ParentId != 0 {
continue
}
info := Digui(&list, list[i])
m = append(m, info)
}
return m, err
}
func Digui(deptlist *[]SysDept, menu SysDept) SysDept {
list := *deptlist
min := make([]SysDept, 0)
for j := 0; j < len(list); j++ {
if menu.DeptId != list[j].ParentId {
continue
}
mi := SysDept{}
mi.DeptId = list[j].DeptId
mi.ParentId = list[j].ParentId
mi.DeptPath = list[j].DeptPath
mi.DeptName = list[j].DeptName
mi.Sort = list[j].Sort
mi.Leader = list[j].Leader
mi.Phone = list[j].Phone
mi.Email = list[j].Email
mi.Status = list[j].Status
mi.Children = []SysDept{}
ms := Digui(deptlist, mi)
min = append(min, ms)
}
menu.Children = min
return menu
}
func (e *SysDept) Update(id int) (update SysDept, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dept_id = ?", id).First(&update).Error; err != nil {
return
}
deptPath := "/" + tools.IntToString(e.DeptId)
if int(e.ParentId) != 0 {
var deptP SysDept
orm.Eloquent.Table(e.TableName()).Where("dept_id = ?", e.ParentId).First(&deptP)
deptPath = deptP.DeptPath + deptPath
} else {
deptPath = "/0" + deptPath
}
e.DeptPath = deptPath
if e.DeptPath != "" && e.DeptPath != update.DeptPath {
return update, errors.New("上级部门不允许修改!")
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *SysDept) Delete(id int) (success bool, err error) {
user := SysUser{}
user.DeptId = id
userlist, err := user.GetList()
tools.HasError(err, "", 500)
tools.Assert(len(userlist) <= 0, "当前部门存在用户,不能删除!", 500)
tx := orm.Eloquent.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
if err = tx.Error; err != nil {
success = false
return
}
if err = tx.Table(e.TableName()).Where("dept_id = ?", id).Delete(&SysDept{}).Error; err != nil {
success = false
tx.Rollback()
return
}
if err = tx.Commit().Error; err != nil {
success = false
return
}
success = true
return
}
func (dept *SysDept) SetDeptLable() (m []DeptLable, err error) {
deptlist, err := dept.GetList()
m = make([]DeptLable, 0)
for i := 0; i < len(deptlist); i++ {
if deptlist[i].ParentId != 0 {
continue
}
e := DeptLable{}
e.Id = deptlist[i].DeptId
e.Label = deptlist[i].DeptName
deptsInfo := DiguiDeptLable(&deptlist, e)
m = append(m, deptsInfo)
}
return
}
func DiguiDeptLable(deptlist *[]SysDept, dept DeptLable) DeptLable {
list := *deptlist
min := make([]DeptLable, 0)
for j := 0; j < len(list); j++ {
if dept.Id != list[j].ParentId {
continue
}
mi := DeptLable{list[j].DeptId, list[j].DeptName, []DeptLable{}}
ms := DiguiDeptLable(deptlist, mi)
min = append(min, ms)
}
dept.Children = min
return dept
}
+159
View File
@@ -0,0 +1,159 @@
package models
import (
"errors"
orm "go-admin/global"
"go-admin/tools"
)
type DictData struct {
DictCode int `gorm:"primary_key;AUTO_INCREMENT" json:"dictCode" example:"1"` //字典编码
DictSort int `gorm:"" json:"dictSort"` //显示顺序
DictLabel string `gorm:"size:128;" json:"dictLabel"` //数据标签
DictValue string `gorm:"size:255;" json:"dictValue"` //数据键值
DictType string `gorm:"size:64;" json:"dictType"` //字典类型
CssClass string `gorm:"size:128;" json:"cssClass"` //
ListClass string `gorm:"size:128;" json:"listClass"` //
IsDefault string `gorm:"size:8;" json:"isDefault"` //
Status string `gorm:"size:4;" json:"status"` //状态
Default string `gorm:"size:8;" json:"default"` //
CreateBy string `gorm:"size:64;" json:"createBy"` //
UpdateBy string `gorm:"size:64;" json:"updateBy"` //
Remark string `gorm:"size:255;" json:"remark"` //备注
Params string `gorm:"-" json:"params"`
DataScope string `gorm:"-" json:"dataScope"`
BaseModel
}
func (DictData) TableName() string {
return "sys_dict_data"
}
func (e *DictData) Create() (DictData, error) {
var doc DictData
i := 0
orm.Eloquent.Table(e.TableName()).Where("dict_label=? or (dict_label=? and dict_value = ?)", e.DictLabel, e.DictValue).Count(&i)
if i > 0 {
return doc, errors.New("字典标签或者字典键值已经存在!")
}
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *DictData) GetByCode() (DictData, error) {
var doc DictData
table := orm.Eloquent.Table(e.TableName())
if e.DictCode != 0 {
table = table.Where("dict_code = ?", e.DictCode)
}
if e.DictLabel != "" {
table = table.Where("dict_label = ?", e.DictLabel)
}
if e.DictType != "" {
table = table.Where("dict_type = ?", e.DictType)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *DictData) Get() ([]DictData, error) {
var doc []DictData
table := orm.Eloquent.Table(e.TableName())
if e.DictCode != 0 {
table = table.Where("dict_code = ?", e.DictCode)
}
if e.DictLabel != "" {
table = table.Where("dict_label = ?", e.DictLabel)
}
if e.DictType != "" {
table = table.Where("dict_type = ?", e.DictType)
}
if err := table.Order("dict_sort").Find(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *DictData) GetPage(pageSize int, pageIndex int) ([]DictData, int, error) {
var doc []DictData
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.DictCode != 0 {
table = table.Where("dict_code = ?", e.DictCode)
}
if e.DictType != "" {
table = table.Where("dict_type = ?", e.DictType)
}
if e.DictLabel != "" {
table = table.Where("dict_label = ?", e.DictLabel)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope("sys_dict_data", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Order("dict_sort").Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *DictData) Update(id int) (update DictData, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dict_code = ?", id).First(&update).Error; err != nil {
return
}
if e.DictLabel != "" && e.DictLabel != update.DictLabel {
return update, errors.New("标签不允许修改!")
}
if e.DictValue != "" && e.DictValue != update.DictValue {
return update, errors.New("键值不允许修改!")
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *DictData) Delete(id int) (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dict_code = ?", id).Delete(&DictData{}).Error; err != nil {
success = false
return
}
success = true
return
}
func (e *DictData) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dict_code in (?)", id).Delete(&DictData{}).Error; err != nil {
return
}
Result = true
return
}
+147
View File
@@ -0,0 +1,147 @@
package models
import (
"errors"
orm "go-admin/global"
"go-admin/tools"
)
type DictType struct {
DictId int `gorm:"primary_key;AUTO_INCREMENT" json:"dictId"`
DictName string `gorm:"size:128;" json:"dictName"` //字典名称
DictType string `gorm:"size:128;" json:"dictType"` //字典类型
Status string `gorm:"size:4;" json:"status"` //状态
DataScope string `gorm:"-" json:"dataScope"` //
Params string `gorm:"-" json:"params"` //
CreateBy string `gorm:"size:11;" json:"createBy"` //创建者
UpdateBy string `gorm:"size:11;" json:"updateBy"` //更新者
Remark string `gorm:"size:255;" json:"remark"` //备注
BaseModel
}
func (DictType) TableName() string {
return "sys_dict_type"
}
func (e *DictType) Create() (DictType, error) {
var doc DictType
i := 0
orm.Eloquent.Table(e.TableName()).Where("dict_name=? or dict_type = ?", e.DictName, e.DictType).Count(&i)
if i > 0 {
return doc, errors.New("字典名称或者字典类型已经存在!")
}
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *DictType) Get() (DictType, error) {
var doc DictType
table := orm.Eloquent.Table(e.TableName())
if e.DictId != 0 {
table = table.Where("dict_id = ?", e.DictId)
}
if e.DictName != "" {
table = table.Where("dict_name = ?", e.DictName)
}
if e.DictType != "" {
table = table.Where("dict_type = ?", e.DictType)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *DictType) GetList() ([]DictType, error) {
var doc []DictType
table := orm.Eloquent.Table(e.TableName())
if e.DictId != 0 {
table = table.Where("dict_id = ?", e.DictId)
}
if e.DictName != "" {
table = table.Where("dict_name = ?", e.DictName)
}
if e.DictType != "" {
table = table.Where("dict_type = ?", e.DictType)
}
if err := table.Find(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *DictType) GetPage(pageSize int, pageIndex int) ([]DictType, int, error) {
var doc []DictType
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.DictId != 0 {
table = table.Where("dict_id = ?", e.DictId)
}
if e.DictName != "" {
table = table.Where("dict_name = ?", e.DictName)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope("sys_dict_type", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *DictType) Update(id int) (update DictType, err error) {
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
if e.DictName != "" && e.DictName != update.DictName {
return update, errors.New("名称不允许修改!")
}
if e.DictType != "" && e.DictType != update.DictType {
return update, errors.New("类型不允许修改!")
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *DictType) Delete(id int) (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dict_id = ?", id).Delete(&DictData{}).Error; err != nil {
success = false
return
}
success = true
return
}
func (e *DictType) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("dict_id in (?)", id).Delete(&DictType{}).Error; err != nil {
return
}
Result = true
return
}
+79
View File
@@ -0,0 +1,79 @@
package gorm
import (
"github.com/jinzhu/gorm"
"go-admin/models"
"go-admin/models/tools"
)
func AutoMigrate(db *gorm.DB) error {
db.SingularTable(true)
err := db.AutoMigrate(new(models.CasbinRule)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysDept)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysConfig)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(tools.SysTables)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(tools.SysColumns)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.Menu)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.LoginLog)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysOperLog)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.RoleMenu)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysRoleDept)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysUser)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.SysRole)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.Post)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.DictData)).Error
if err != nil {
return err
}
err = db.AutoMigrate(new(models.DictType)).Error
if err != nil {
return err
}
models.DataInit()
return err
}
func CustomMigrate(db *gorm.DB, table interface{}) error {
db.SingularTable(true)
return db.AutoMigrate(&table).Error
}
+52
View File
@@ -0,0 +1,52 @@
package models
import (
"fmt"
"go-admin/global"
"io/ioutil"
"strings"
)
func InitDb() error {
filePath := "config/db.sql"
err := ExecSql(filePath)
if global.Driver == "postgres" {
filePath = "config/pg.sql"
err = ExecSql(filePath)
}
return err
}
func ExecSql(filePath string) error {
sql, err := Ioutil(filePath)
if err != nil {
fmt.Println("数据库基础数据初始化脚本读取失败!原因:", err.Error())
return err
}
sqlList := strings.Split(sql, ";")
for i := 0; i < len(sqlList)-1; i++ {
if strings.Contains(sqlList[i], "--") {
fmt.Println(sqlList[i])
continue
}
sql := strings.Replace(sqlList[i]+";", "\n", "", 0)
sql = strings.TrimSpace(sql)
if err = global.Eloquent.Exec(sql).Error; err != nil {
if !strings.Contains(err.Error(), "Query was empty") {
return err
}
}
}
return nil
}
func Ioutil(filePath string) (string, error) {
if contents, err := ioutil.ReadFile(filePath); err == nil {
//因为contents是[]byte类型,直接转换成string类型后会多一行空格,需要使用strings.Replace替换换行符
result := strings.Replace(string(contents), "\n", "", 1)
fmt.Println("Use ioutil.ReadFile to read a file:", result)
return result, nil
} else {
return "", err
}
}
+30
View File
@@ -0,0 +1,30 @@
package models
import (
orm "go-admin/global"
"go-admin/tools"
)
type Login struct {
Username string `form:"UserName" json:"username" binding:"required"`
Password string `form:"Password" json:"password" binding:"required"`
Code string `form:"Code" json:"code" binding:"required"`
UUID string `form:"UUID" json:"uuid" binding:"required"`
}
func (u *Login) GetUser() (user SysUser, role SysRole, e error) {
e = orm.Eloquent.Table("sys_user").Where("username = ? ", u.Username).Find(&user).Error
if e != nil {
return
}
_, e = tools.CompareHashAndPassword(user.Password, u.Password)
if e != nil {
return
}
e = orm.Eloquent.Table("sys_role").Where("role_id = ? ", user.RoleId).First(&role).Error
if e != nil {
return
}
return
}
+104
View File
@@ -0,0 +1,104 @@
package models
import (
orm "go-admin/global"
"time"
)
type LoginLog struct {
InfoId int `json:"infoId" gorm:"primary_key;AUTO_INCREMENT"` //主键
Username string `json:"username" gorm:"size:128;"` //用户名
Status string `json:"status" gorm:"size:4;"` //状态
Ipaddr string `json:"ipaddr" gorm:"size:255;"` //ip地址
LoginLocation string `json:"loginLocation" gorm:"size:255;"` //归属地
Browser string `json:"browser" gorm:"size:255;"` //浏览器
Os string `json:"os" gorm:"size:255;"` //系统
Platform string `json:"platform" gorm:"size:255;"` // 固件
LoginTime time.Time `json:"loginTime" gorm:"type:timestamp;"` //登录时间
CreateBy string `json:"createBy" gorm:"size:128;"` //创建人
UpdateBy string `json:"updateBy" gorm:"size:128;"` //更新者
DataScope string `json:"dataScope" gorm:"-"` //数据
Params string `json:"params" gorm:"-"` //
Remark string `json:"remark" gorm:"size:255;"` //备注
Msg string `json:"msg" gorm:"size:255;"`
BaseModel
}
func (LoginLog) TableName() string {
return "sys_loginlog"
}
func (e *LoginLog) Get() (LoginLog, error) {
var doc LoginLog
table := orm.Eloquent.Table(e.TableName())
if e.Ipaddr != "" {
table = table.Where("ipaddr = ?", e.Ipaddr)
}
if e.InfoId != 0 {
table = table.Where("info_id = ?", e.InfoId)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *LoginLog) GetPage(pageSize int, pageIndex int) ([]LoginLog, int, error) {
var doc []LoginLog
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.Ipaddr != "" {
table = table.Where("ipaddr = ?", e.Ipaddr)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if e.Username != "" {
table = table.Where("userName = ?", e.Username)
}
var count int
if err := table.Order("info_id desc").Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *LoginLog) Create() (LoginLog, error) {
var doc LoginLog
e.CreateBy = "0"
e.UpdateBy = "0"
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *LoginLog) Update(id int) (update LoginLog, err error) {
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *LoginLog) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("info_id in (?)", id).Delete(&LoginLog{}).Error; err != nil {
return
}
Result = true
return
}
+329
View File
@@ -0,0 +1,329 @@
package models
import (
"errors"
orm "go-admin/global"
"go-admin/tools"
)
type Menu struct {
MenuId int `json:"menuId" gorm:"primary_key;AUTO_INCREMENT"`
MenuName string `json:"menuName" gorm:"size:128;"`
Title string `json:"title" gorm:"size:128;"`
Icon string `json:"icon" gorm:"size:128;"`
Path string `json:"path" gorm:"size:128;"`
Paths string `json:"paths" gorm:"size:128;"`
MenuType string `json:"menuType" gorm:"size:1;"`
Action string `json:"action" gorm:"size:16;"`
Permission string `json:"permission" gorm:"size:255;"`
ParentId int `json:"parentId" gorm:"size:11;"`
NoCache bool `json:"noCache" gorm:"size:8;"`
Breadcrumb string `json:"breadcrumb" gorm:"size:255;"`
Component string `json:"component" gorm:"size:255;"`
Sort int `json:"sort" gorm:"size:4;"`
Visible string `json:"visible" gorm:"size:1;"`
CreateBy string `json:"createBy" gorm:"size:128;"`
UpdateBy string `json:"updateBy" gorm:"size:128;"`
IsFrame string `json:"isFrame" gorm:"size:1;DEFAULT:0;"`
DataScope string `json:"dataScope" gorm:"-"`
Params string `json:"params" gorm:"-"`
RoleId int `gorm:"-"`
Children []Menu `json:"children" gorm:"-"`
IsSelect bool `json:"is_select" gorm:"-"`
BaseModel
}
func (Menu) TableName() string {
return "sys_menu"
}
type MenuLable struct {
Id int `json:"id" gorm:"-"`
Label string `json:"label" gorm:"-"`
Children []MenuLable `json:"children" gorm:"-"`
}
type Menus struct {
MenuId int `json:"menuId" gorm:"column:menu_id;primary_key"`
MenuName string `json:"menuName" gorm:"column:menu_name"`
Title string `json:"title" gorm:"column:title"`
Icon string `json:"icon" gorm:"column:icon"`
Path string `json:"path" gorm:"column:path"`
MenuType string `json:"menuType" gorm:"column:menu_type"`
Action string `json:"action" gorm:"column:action"`
Permission string `json:"permission" gorm:"column:permission"`
ParentId int `json:"parentId" gorm:"column:parent_id"`
NoCache bool `json:"noCache" gorm:"column:no_cache"`
Breadcrumb string `json:"breadcrumb" gorm:"column:breadcrumb"`
Component string `json:"component" gorm:"column:component"`
Sort int `json:"sort" gorm:"column:sort"`
Visible string `json:"visible" gorm:"column:visible"`
Children []Menu `json:"children" gorm:"-"`
CreateBy string `json:"createBy" gorm:"column:create_by"`
UpdateBy string `json:"updateBy" gorm:"column:update_by"`
DataScope string `json:"dataScope" gorm:"-"`
Params string `json:"params" gorm:"-"`
BaseModel
}
func (Menus) TableName() string {
return "sys_menu"
}
type MenuRole struct {
Menus
IsSelect bool `json:"is_select" gorm:"-"`
}
type MS []Menu
func (e *Menu) GetByMenuId() (Menu Menu, err error) {
table := orm.Eloquent.Table(e.TableName())
table = table.Where("menu_id = ?", e.MenuId)
if err = table.Find(&Menu).Error; err != nil {
return
}
return
}
func (e *Menu) SetMenu() (m []Menu, err error) {
menulist, err := e.GetPage()
m = make([]Menu, 0)
for i := 0; i < len(menulist); i++ {
if menulist[i].ParentId != 0 {
continue
}
menusInfo := DiguiMenu(&menulist, menulist[i])
m = append(m, menusInfo)
}
return
}
func DiguiMenu(menulist *[]Menu, menu Menu) Menu {
list := *menulist
min := make([]Menu, 0)
for j := 0; j < len(list); j++ {
if menu.MenuId != list[j].ParentId {
continue
}
mi := Menu{}
mi.MenuId = list[j].MenuId
mi.MenuName = list[j].MenuName
mi.Title = list[j].Title
mi.Icon = list[j].Icon
mi.Path = list[j].Path
mi.MenuType = list[j].MenuType
mi.Action = list[j].Action
mi.Permission = list[j].Permission
mi.ParentId = list[j].ParentId
mi.NoCache = list[j].NoCache
mi.Breadcrumb = list[j].Breadcrumb
mi.Component = list[j].Component
mi.Sort = list[j].Sort
mi.Visible = list[j].Visible
mi.CreatedAt = list[j].CreatedAt
mi.Children = []Menu{}
if mi.MenuType != "F" {
ms := DiguiMenu(menulist, mi)
min = append(min, ms)
} else {
min = append(min, mi)
}
}
menu.Children = min
return menu
}
func (e *Menu) SetMenuLable() (m []MenuLable, err error) {
menulist, err := e.Get()
m = make([]MenuLable, 0)
for i := 0; i < len(menulist); i++ {
if menulist[i].ParentId != 0 {
continue
}
e := MenuLable{}
e.Id = menulist[i].MenuId
e.Label = menulist[i].Title
menusInfo := DiguiMenuLable(&menulist, e)
m = append(m, menusInfo)
}
return
}
func DiguiMenuLable(menulist *[]Menu, menu MenuLable) MenuLable {
list := *menulist
min := make([]MenuLable, 0)
for j := 0; j < len(list); j++ {
if menu.Id != list[j].ParentId {
continue
}
mi := MenuLable{}
mi.Id = list[j].MenuId
mi.Label = list[j].Title
mi.Children = []MenuLable{}
if list[j].MenuType != "F" {
ms := DiguiMenuLable(menulist, mi)
min = append(min, ms)
} else {
min = append(min, mi)
}
}
menu.Children = min
return menu
}
func (e *Menu) SetMenuRole(rolename string) (m []Menu, err error) {
menulist, err := e.GetByRoleName(rolename)
m = make([]Menu, 0)
for i := 0; i < len(menulist); i++ {
if menulist[i].ParentId != 0 {
continue
}
menusInfo := DiguiMenu(&menulist, menulist[i])
m = append(m, menusInfo)
}
return
}
func (e *MenuRole) Get() (Menus []MenuRole, err error) {
table := orm.Eloquent.Table(e.TableName())
if e.MenuName != "" {
table = table.Where("menu_name = ?", e.MenuName)
}
if err = table.Order("sort").Find(&Menus).Error; err != nil {
return
}
return
}
func (e *Menu) GetByRoleName(rolename string) (Menus []Menu, err error) {
table := orm.Eloquent.Table(e.TableName()).Select("sys_menu.*").Joins("left join sys_role_menu on sys_role_menu.menu_id=sys_menu.menu_id")
table = table.Where("sys_role_menu.role_name=? and menu_type in ('M','C')", rolename)
if err = table.Order("sort").Find(&Menus).Error; err != nil {
return
}
return
}
func (e *Menu) Get() (Menus []Menu, err error) {
table := orm.Eloquent.Table(e.TableName())
if e.MenuName != "" {
table = table.Where("menu_name = ?", e.MenuName)
}
if e.Path != "" {
table = table.Where("path = ?", e.Path)
}
if e.Action != "" {
table = table.Where("action = ?", e.Action)
}
if e.MenuType != "" {
table = table.Where("menu_type = ?", e.MenuType)
}
if err = table.Order("sort").Find(&Menus).Error; err != nil {
return
}
return
}
func (e *Menu) GetPage() (Menus []Menu, err error) {
table := orm.Eloquent.Table(e.TableName())
if e.MenuName != "" {
table = table.Where("menu_name = ?", e.MenuName)
}
if e.Title != "" {
table = table.Where("title = ?", e.Title)
}
if e.Visible != "" {
table = table.Where("visible = ?", e.Visible)
}
if e.MenuType != "" {
table = table.Where("menu_type = ?", e.MenuType)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err = dataPermission.GetDataScope("sys_menu", table)
if err != nil {
return nil, err
}
if err = table.Order("sort").Find(&Menus).Error; err != nil {
return
}
return
}
func (e *Menu) Create() (id int, err error) {
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err = result.Error
return
}
err = InitPaths(e)
if err != nil {
return
}
id = e.MenuId
return
}
func InitPaths(menu *Menu) (err error) {
parentMenu := new(Menu)
if int(menu.ParentId) != 0 {
orm.Eloquent.Table("sys_menu").Where("menu_id = ?", menu.ParentId).First(parentMenu)
if parentMenu.Paths == "" {
err = errors.New("父级paths异常,请尝试对当前节点父级菜单进行更新操作!")
return
}
menu.Paths = parentMenu.Paths + "/" + tools.IntToString(menu.MenuId)
} else {
menu.Paths = "/0/" + tools.IntToString(menu.MenuId)
}
orm.Eloquent.Table("sys_menu").Where("menu_id = ?", menu.MenuId).Update("paths", menu.Paths)
return
}
func (e *Menu) Update(id int) (update Menu, err error) {
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
err = InitPaths(e)
if err != nil {
return
}
return
}
func (e *Menu) Delete(id int) (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("menu_id = ?", id).Delete(&Menu{}).Error; err != nil {
success = false
return
}
success = true
return
}
+11
View File
@@ -0,0 +1,11 @@
package models
import (
"time"
)
type BaseModel struct {
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
DeletedAt *time.Time `json:"deletedAt"`
}
+115
View File
@@ -0,0 +1,115 @@
package models
import (
orm "go-admin/global"
"time"
)
//sys_operlog
type SysOperLog struct {
OperId int `json:"operId" gorm:"primary_key;AUTO_INCREMENT"` //日志编码
Title string `json:"title" gorm:"size:255;"` //操作模块
BusinessType string `json:"businessType" gorm:"size:128;"` //操作类型
BusinessTypes string `json:"businessTypes" gorm:"size:128;"`
Method string `json:"method" gorm:"size:128;"` //函数
RequestMethod string `json:"requestMethod" gorm:"size:128;"` //请求方式
OperatorType string `json:"operatorType" gorm:"size:128;"` //操作类型
OperName string `json:"operName" gorm:"size:128;"` //操作者
DeptName string `json:"deptName" gorm:"size:128;"` //部门名称
OperUrl string `json:"operUrl" gorm:"size:255;"` //访问地址
OperIp string `json:"operIp" gorm:"size:128;"` //客户端ip
OperLocation string `json:"operLocation" gorm:"size:128;"` //访问位置
OperParam string `json:"operParam" gorm:"size:255;"` //请求参数
Status string `json:"status" gorm:"size:4;"` //操作状态
OperTime time.Time `json:"operTime" gorm:"type:timestamp;"` //操作时间
JsonResult string `json:"jsonResult" gorm:"size:255;"` //返回数据
CreateBy string `json:"createBy" gorm:"size:128;"` //创建人
UpdateBy string `json:"updateBy" gorm:"size:128;"` //更新者
DataScope string `json:"dataScope" gorm:"-"` //数据
Params string `json:"params" gorm:"-"` //参数
Remark string `json:"remark" gorm:"size:255;"` //备注
LatencyTime string `json:"latencyime" gorm:"size:128;"` //耗时
UserAgent string `json:"userAgent" gorm:"size:255;"` //ua
BaseModel
}
func (SysOperLog) TableName() string {
return "sys_operlog"
}
func (e *SysOperLog) Get() (SysOperLog, error) {
var doc SysOperLog
table := orm.Eloquent.Table(e.TableName())
if e.OperIp != "" {
table = table.Where("oper_ip = ?", e.OperIp)
}
if e.OperId != 0 {
table = table.Where("oper_id = ?", e.OperId)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *SysOperLog) GetPage(pageSize int, pageIndex int) ([]SysOperLog, int, error) {
var doc []SysOperLog
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.OperIp != "" {
table = table.Where("oper_ip = ?", e.OperIp)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if e.OperName != "" {
table = table.Where("oper_name = ?", e.OperName)
}
if e.BusinessType != "" {
table = table.Where("business_type = ?", e.BusinessType)
}
var count int
if err := table.Order("oper_id desc").Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *SysOperLog) Create() (SysOperLog, error) {
var doc SysOperLog
e.CreateBy = "0"
e.UpdateBy = "0"
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *SysOperLog) Update(id int) (update SysOperLog, err error) {
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *SysOperLog) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where(" oper_id in (?)", id).Delete(&SysOperLog{}).Error; err != nil {
return
}
Result = true
return
}
+144
View File
@@ -0,0 +1,144 @@
package models
import (
orm "go-admin/global"
"go-admin/tools"
)
type Post struct {
PostId int `gorm:"primary_key;AUTO_INCREMENT" json:"postId"` //岗位编号
PostName string `gorm:"size:128;" json:"postName"` //岗位名称
PostCode string `gorm:"size:128;" json:"postCode"` //岗位代码
Sort int `gorm:"" json:"sort"` //岗位排序
Status string `gorm:"size:4;" json:"status"` //状态
Remark string `gorm:"size:255;" json:"remark"` //描述
CreateBy string `gorm:"size:128;" json:"createBy"`
UpdateBy string `gorm:"size:128;" json:"updateBy"`
DataScope string `gorm:"-" json:"dataScope"`
Params string `gorm:"-" json:"params"`
BaseModel
}
func (Post) TableName() string {
return "sys_post"
}
func (e *Post) Create() (Post, error) {
var doc Post
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *Post) Get() (Post, error) {
var doc Post
table := orm.Eloquent.Table(e.TableName())
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if e.PostName != "" {
table = table.Where("post_name = ?", e.PostName)
}
if e.PostCode != "" {
table = table.Where("post_code = ?", e.PostCode)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *Post) GetList() ([]Post, error) {
var doc []Post
table := orm.Eloquent.Table(e.TableName())
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if e.PostName != "" {
table = table.Where("post_name = ?", e.PostName)
}
if e.PostCode != "" {
table = table.Where("post_code = ?", e.PostCode)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
if err := table.Find(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
func (e *Post) GetPage(pageSize int, pageIndex int) ([]Post, int, error) {
var doc []Post
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if e.PostName != "" {
table = table.Where("post_name = ?", e.PostName)
}
if e.PostCode != "" {
table = table.Where("post_code = ?", e.PostCode)
}
if e.Status != "" {
table = table.Where("status = ?", e.Status)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope("sys_post", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Order("sort").Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *Post) Update(id int) (update Post, err error) {
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *Post) Delete(id int) (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("post_id = ?", id).Delete(&Post{}).Error; err != nil {
success = false
return
}
success = true
return
}
func (e *Post) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("post_id in (?)", id).Delete(&Post{}).Error; err != nil {
return
}
Result = true
return
}
+175
View File
@@ -0,0 +1,175 @@
package models
import (
"github.com/pkg/errors"
orm "go-admin/global"
"go-admin/tools"
)
type SysRole struct {
RoleId int `json:"roleId" gorm:"primary_key;AUTO_INCREMENT"` // 角色编码
RoleName string `json:"roleName" gorm:"size:128;"` // 角色名称
Status string `json:"status" gorm:"size:4;"` //
RoleKey string `json:"roleKey" gorm:"size:128;"` //角色代码
RoleSort int `json:"roleSort" gorm:""` //角色排序
Flag string `json:"flag" gorm:"size:128;"` //
CreateBy string `json:"createBy" gorm:"size:128;"` //
UpdateBy string `json:"updateBy" gorm:"size:128;"` //
Remark string `json:"remark" gorm:"size:255;"` //备注
Admin bool `json:"admin" gorm:"size:4;"`
DataScope string `json:"dataScope" gorm:"size:128;"`
Params string `json:"params" gorm:"-"`
MenuIds []int `json:"menuIds" gorm:"-"`
DeptIds []int `json:"deptIds" gorm:"-"`
BaseModel
}
func (SysRole) TableName() string {
return "sys_role"
}
type MenuIdList struct {
MenuId int `json:"menuId"`
}
func (role *SysRole) GetPage(pageSize int, pageIndex int) ([]SysRole, int, error) {
var doc []SysRole
table := orm.Eloquent.Select("*").Table("sys_role")
if role.RoleId != 0 {
table = table.Where("role_id = ?", role.RoleId)
}
if role.RoleName != "" {
table = table.Where("role_name = ?", role.RoleName)
}
if role.Status != "" {
table = table.Where("status = ?", role.Status)
}
if role.RoleKey != "" {
table = table.Where("role_key = ?", role.RoleKey)
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(role.DataScope)
table, err := dataPermission.GetDataScope("sys_role", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Order("role_sort").Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (role *SysRole) Get() (SysRole SysRole, err error) {
table := orm.Eloquent.Table("sys_role")
if role.RoleId != 0 {
table = table.Where("role_id = ?", role.RoleId)
}
if role.RoleName != "" {
table = table.Where("role_name = ?", role.RoleName)
}
if err = table.First(&SysRole).Error; err != nil {
return
}
return
}
func (role *SysRole) GetList() (SysRole []SysRole, err error) {
table := orm.Eloquent.Table("sys_role")
if role.RoleId != 0 {
table = table.Where("role_id = ?", role.RoleId)
}
if role.RoleName != "" {
table = table.Where("role_name = ?", role.RoleName)
}
if err = table.Order("role_sort").Find(&SysRole).Error; err != nil {
return
}
return
}
// 获取角色对应的菜单ids
func (role *SysRole) GetRoleMeunId() ([]int, error) {
menuIds := make([]int, 0)
menuList := make([]MenuIdList, 0)
if err := orm.Eloquent.Table("sys_role_menu").Select("sys_role_menu.menu_id").Where("role_id = ? ", role.RoleId).Where(" sys_role_menu.menu_id not in(select sys_menu.parent_id from sys_role_menu LEFT JOIN sys_menu on sys_menu.menu_id=sys_role_menu.menu_id where role_id =? and parent_id is not null)", role.RoleId).Find(&menuList).Error; err != nil {
return nil, err
}
for i := 0; i < len(menuList); i++ {
menuIds = append(menuIds, menuList[i].MenuId)
}
return menuIds, nil
}
func (role *SysRole) Insert() (id int, err error) {
i := 0
orm.Eloquent.Table(role.TableName()).Where("role_name=? or role_key = ?", role.RoleName, role.RoleKey).Count(&i)
if i > 0 {
return 0, errors.New("角色名称或者角色标识已经存在!")
}
role.UpdateBy = ""
result := orm.Eloquent.Table(role.TableName()).Create(&role)
if result.Error != nil {
err = result.Error
return
}
id = role.RoleId
return
}
type DeptIdList struct {
DeptId int `json:"DeptId"`
}
func (role *SysRole) GetRoleDeptId() ([]int, error) {
deptIds := make([]int, 0)
deptList := make([]DeptIdList, 0)
if err := orm.Eloquent.Table("sys_role_dept").Select("sys_role_dept.dept_id").Joins("LEFT JOIN sys_dept on sys_dept.dept_id=sys_role_dept.dept_id").Where("role_id = ? ", role.RoleId).Where(" sys_role_dept.dept_id not in(select sys_dept.parent_id from sys_role_dept LEFT JOIN sys_dept on sys_dept.dept_id=sys_role_dept.dept_id where role_id =? )", role.RoleId).Find(&deptList).Error; err != nil {
return nil, err
}
for i := 0; i < len(deptList); i++ {
deptIds = append(deptIds, deptList[i].DeptId)
}
return deptIds, nil
}
//修改
func (role *SysRole) Update(id int) (update SysRole, err error) {
if err = orm.Eloquent.Table(role.TableName()).First(&update, id).Error; err != nil {
return
}
if role.RoleName != "" && role.RoleName != update.RoleName {
return update, errors.New("角色名称不允许修改!")
}
if role.RoleKey != "" && role.RoleKey != update.RoleKey {
return update, errors.New("角色标识不允许修改!")
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(role.TableName()).Model(&update).Updates(&role).Error; err != nil {
return
}
return
}
//批量删除
func (role *SysRole) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(role.TableName()).Where("role_id in (?)", id).Delete(SysRole{}).Error; err != nil {
return
}
Result = true
return
}
+46
View File
@@ -0,0 +1,46 @@
package models
import (
"fmt"
orm "go-admin/global"
)
//sys_role_dept
type SysRoleDept struct {
RoleId int `gorm:""`
DeptId int `gorm:""`
}
func (SysRoleDept) TableName() string {
return "sys_role_dept"
}
func (rm *SysRoleDept) Insert(roleId int, deptIds []int) (bool, error) {
//ORM不支持批量插入所以需要拼接 sql 串
sql := "INSERT INTO `sys_role_dept` (`role_id`,`dept_id`) VALUES "
for i := 0; i < len(deptIds); i++ {
if len(deptIds)-1 == i {
//最后一条数据 以分号结尾
sql += fmt.Sprintf("(%d,%d);", roleId, deptIds[i])
} else {
sql += fmt.Sprintf("(%d,%d),", roleId, deptIds[i])
}
}
orm.Eloquent.Exec(sql)
return true, nil
}
func (rm *SysRoleDept) DeleteRoleDept(roleId int) (bool, error) {
if err := orm.Eloquent.Table("sys_role_dept").Where("role_id = ?", roleId).Delete(&rm).Error; err != nil {
return false, err
}
var role SysRole
if err := orm.Eloquent.Table("sys_role").Where("role_id = ?", roleId).First(&role).Error; err != nil {
return false, err
}
return true, nil
}
+206
View File
@@ -0,0 +1,206 @@
package models
import (
"fmt"
orm "go-admin/global"
"go-admin/tools"
)
type RoleMenu struct {
RoleId int `gorm:""`
MenuId int `gorm:""`
RoleName string `gorm:"size:128)"`
CreateBy string `gorm:"size:128)"`
UpdateBy string `gorm:"size:128)"`
}
func (RoleMenu) TableName() string {
return "sys_role_menu"
}
type MenuPath struct {
Path string `json:"path"`
}
func (rm *RoleMenu) Get() ([]RoleMenu, error) {
var r []RoleMenu
table := orm.Eloquent.Table("sys_role_menu")
if rm.RoleId != 0 {
table = table.Where("role_id = ?", rm.RoleId)
}
if err := table.Find(&r).Error; err != nil {
return nil, err
}
return r, nil
}
func (rm *RoleMenu) GetPermis() ([]string, error) {
var r []Menu
table := orm.Eloquent.Select("sys_menu.permission").Table("sys_menu").Joins("left join sys_role_menu on sys_menu.menu_id = sys_role_menu.menu_id")
table = table.Where("role_id = ?", rm.RoleId)
table = table.Where("sys_menu.menu_type in('F','C')")
if err := table.Find(&r).Error; err != nil {
return nil, err
}
var list []string
for i := 0; i < len(r); i++ {
list = append(list, r[i].Permission)
}
return list, nil
}
func (rm *RoleMenu) GetIDS() ([]MenuPath, error) {
var r []MenuPath
table := orm.Eloquent.Select("sys_menu.path").Table("sys_role_menu")
table = table.Joins("left join sys_role on sys_role.role_id=sys_role_menu.role_id")
table = table.Joins("left join sys_menu on sys_menu.id=sys_role_menu.menu_id")
table = table.Where("sys_role.role_name = ? and sys_menu.type=1", rm.RoleName)
if err := table.Find(&r).Error; err != nil {
return nil, err
}
return r, nil
}
func (rm *RoleMenu) DeleteRoleMenu(roleId int) (bool, error) {
tx := orm.Eloquent.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
if err := tx.Error; err != nil {
return false, err
}
if err := tx.Table("sys_role_dept").Where("role_id = ?", roleId).Delete(&rm).Error; err != nil {
tx.Rollback()
return false, err
}
if err := tx.Table("sys_role_menu").Where("role_id = ?", roleId).Delete(&rm).Error; err != nil {
tx.Rollback()
return false, err
}
var role SysRole
if err := tx.Table("sys_role").Where("role_id = ?", roleId).First(&role).Error; err != nil {
tx.Rollback()
return false, err
}
sql3 := "delete from casbin_rule where v0= '" + role.RoleKey + "';"
if err := tx.Exec(sql3).Error; err != nil {
tx.Rollback()
return false, err
}
if err := tx.Commit().Error; err != nil {
return false, err
}
return true, nil
}
func (rm *RoleMenu) BatchDeleteRoleMenu(roleIds []int) (bool, error) {
tx := orm.Eloquent.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
if err := tx.Error; err != nil {
return false, err
}
if err := tx.Table("sys_role_menu").Where("role_id in (?)", roleIds).Delete(&rm).Error; err != nil {
tx.Rollback()
return false, err
}
var role []SysRole
if err := tx.Table("sys_role").Where("role_id in (?)", roleIds).Find(&role).Error; err != nil {
tx.Rollback()
return false, err
}
sql := ""
for i := 0; i < len(role); i++ {
sql += "delete from casbin_rule where v0= '" + role[i].RoleName + "';"
}
if err := tx.Exec(sql).Error; err != nil {
tx.Rollback()
return false, err
}
if err := tx.Commit().Error; err != nil {
return false, err
}
return true, nil
}
func (rm *RoleMenu) Insert(roleId int, menuId []int) (bool, error) {
var role SysRole
tx := orm.Eloquent.Begin()
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
if err := tx.Error; err != nil {
return false, err
}
if err := tx.Table("sys_role").Where("role_id = ?", roleId).First(&role).Error; err != nil {
tx.Rollback()
return false, err
}
var menu []Menu
if err := tx.Table("sys_menu").Where("menu_id in (?)", menuId).Find(&menu).Error; err != nil {
tx.Rollback()
return false, err
}
//ORM不支持批量插入所以需要拼接 sql 串
sql := "INSERT INTO `sys_role_menu` (`role_id`,`menu_id`,`role_name`) VALUES "
sql2 := "INSERT INTO casbin_rule (`p_type`,`v0`,`v1`,`v2`) VALUES "
for i := 0; i < len(menu); i++ {
if len(menu)-1 == i {
//最后一条数据 以分号结尾
sql += fmt.Sprintf("(%d,%d,'%s');", role.RoleId, menu[i].MenuId, role.RoleKey)
if menu[i].MenuType == "A" {
sql2 += fmt.Sprintf("('p','%s','%s','%s');", role.RoleKey, menu[i].Path, menu[i].Action)
}
} else {
sql += fmt.Sprintf("(%d,%d,'%s'),", role.RoleId, menu[i].MenuId, role.RoleKey)
if menu[i].MenuType == "A" {
sql2 += fmt.Sprintf("('p','%s','%s','%s'),", role.RoleKey, menu[i].Path, menu[i].Action)
}
}
}
if err := tx.Exec(sql).Error; err != nil {
tx.Rollback()
return false, err
}
sql2 = sql2[0:len(sql2)-1] + ";"
if err := tx.Exec(sql2).Error; err != nil {
tx.Rollback()
return false, err
}
if err := tx.Commit().Error; err != nil {
return false, err
}
return true, nil
}
func (rm *RoleMenu) Delete(RoleId string, MenuID string) (bool, error) {
rm.RoleId, _ = tools.StringToInt(RoleId)
table := orm.Eloquent.Table("sys_role_menu").Where("role_id = ?", RoleId)
if MenuID != "" {
table = table.Where("menu_id = ?", MenuID)
}
if err := table.Delete(&rm).Error; err != nil {
return false, err
}
return true, nil
}
+185
View File
@@ -0,0 +1,185 @@
package models
import (
orm "go-admin/global"
"go-admin/tools"
)
type SysJob struct {
JobId int `json:"jobId" gorm:"type:int(11);primary_key"` // 编码
JobName string `json:"jobName" gorm:"type:varchar(255);"` // 名称
JobGroup string `json:"jobGroup" gorm:"type:varchar(255);"` // 任务分组
CronExpression string `json:"cronExpression" gorm:"type:varchar(255);"` // cron表达式
InvokeTarget string `json:"invokeTarget" gorm:"type:varchar(255);"` // 调用目标
MisfirePolicy int `json:"misfirePolicy" gorm:"type:varchar(255);"` // 执行策略
Concurrent int `json:"concurrent" gorm:"type:int(1);"` // 是否并发
Status int `json:"status" gorm:"type:int(1);"` // 状态
EntryId int `json:"entry_id" gorm:"type:int(11);"` // job启动时返回的id
CreateBy string `json:"createBy" gorm:"type:varchar(128);"` //
UpdateBy string `json:"updateBy" gorm:"type:varchar(128);"` //
DataScope string `json:"dataScope" gorm:"-"`
BaseModel
}
func (SysJob) TableName() string {
return "sys_job"
}
// 创建SysJob
func (e *SysJob) Create() (SysJob, error) {
var doc SysJob
result := orm.Eloquent.Table(e.TableName()).Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
// 获取SysJob
func (e *SysJob) Get() (SysJob, error) {
var doc SysJob
table := orm.Eloquent.Table(e.TableName())
if e.JobId != 0 {
table = table.Where("job_id = ?", e.JobId)
}
if e.JobName != "" {
table = table.Where("job_name like ?", "%"+e.JobName+"%")
}
if e.JobGroup != "" {
table = table.Where("job_group = ?", e.JobGroup)
}
if e.CronExpression != "" {
table = table.Where("cron_expression = ?", e.CronExpression)
}
if e.InvokeTarget != "" {
table = table.Where("invoke_target = ?", e.InvokeTarget)
}
if e.Status != -1 {
table = table.Where("status = ?", e.Status)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
// 获取SysJob带分页
func (e *SysJob) GetPage(pageSize int, pageIndex int) ([]SysJob, int, error) {
var doc []SysJob
table := orm.Eloquent.Select("*").Table(e.TableName())
if e.JobId != 0 {
table = table.Where("job_id = ?", e.JobId)
}
if e.JobName != "" {
table = table.Where("job_name like ?", "%"+e.JobName+"%")
}
if e.JobGroup != "" {
table = table.Where("job_group = ?", e.JobGroup)
}
if e.CronExpression != "" {
table = table.Where("cron_expression = ?", e.CronExpression)
}
if e.InvokeTarget != "" {
table = table.Where("invoke_target = ?", e.InvokeTarget)
}
if e.Status != -1 {
table = table.Where("status = ?", e.Status)
}
// 数据权限控制(如果不需要数据权限请将此处去掉)
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope(e.TableName(), table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *SysJob) GetList() ([]SysJob, error) {
var doc []SysJob
table := orm.Eloquent.Select("*").Table(e.TableName())
table = table.Where("status = ?", 0)
if err := table.Find(&doc).Error; err != nil {
return nil, err
}
return doc, nil
}
// 更新SysJob
func (e *SysJob) Update(id int) (update SysJob, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("job_id = ?", id).First(&update).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *SysJob) RemoveAllEntryID() (update SysJob, err error) {
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Updates(map[string]interface{}{"entry_id": 0}).Error; err != nil {
return
}
return
}
func (e *SysJob) RemoveEntryID(entryID int) (update SysJob, err error) {
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Where("entry_id = ?", entryID).Updates(map[string]interface{}{"entry_id": 0}).Error; err != nil {
return
}
return
}
// 删除SysJob
func (e *SysJob) Delete(id int) (success bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("job_id = ?", id).Delete(&SysJob{}).Error; err != nil {
success = false
return
}
success = true
return
}
//批量删除
func (e *SysJob) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("job_id in (?)", id).Delete(&SysJob{}).Error; err != nil {
return
}
Result = true
return
}
+39
View File
@@ -0,0 +1,39 @@
package models
import (
orm "go-admin/global"
)
type SysSetting struct {
SettingsId int `json:"settings_id" gorm:"primary_key;AUTO_INCREMENT"`
Name string `json:"name" gorm:"type:varchar(256);"`
Logo string `json:"logo" gorm:"type:varchar(256);"`
BaseModel
}
func (SysSetting) TableName() string {
return "sys_setting"
}
//查询
func (s *SysSetting) Query() (create SysSetting, err error) {
result := orm.Eloquent.Table("sys_setting").First(&create)
if result.Error != nil {
err = result.Error
return
}
return create,nil
}
//修改
func (s *SysSetting) Update() (update SysSetting, err error) {
if err = orm.Eloquent.Table("sys_setting").Model(&update).Updates(&s).Error; err != nil {
return
}
return
}
type ResponseSystemConfig struct {
Name string `json:"name" binding:"required"` // 名称
Logo string `json:"logo" binding:"required"` // 头像
}
+316
View File
@@ -0,0 +1,316 @@
package models
import (
"errors"
"log"
orm "go-admin/global"
"go-admin/tools"
"golang.org/x/crypto/bcrypt"
"strings"
)
// User
type User struct {
// key
IdentityKey string
// 用户名
UserName string
FirstName string
LastName string
// 角色
Role string
}
type UserName struct {
Username string `gorm:"size:64" json:"username"`
}
type PassWord struct {
// 密码
Password string `gorm:"size:128" json:"password"`
}
type LoginM struct {
UserName
PassWord
}
type SysUserId struct {
UserId int `gorm:"primary_key;AUTO_INCREMENT" json:"userId"` // 编码
}
type SysUserB struct {
NickName string `gorm:"size:128" json:"nickName"` // 昵称
Phone string `gorm:"size:11" json:"phone"` // 手机号
RoleId int `gorm:"" json:"roleId"` // 角色编码
Salt string `gorm:"size:255" json:"salt"` //盐
Avatar string `gorm:"size:255" json:"avatar"` //头像
Sex string `gorm:"size:255" json:"sex"` //性别
Email string `gorm:"size:128" json:"email"` //邮箱
DeptId int `gorm:"" json:"deptId"` //部门编码
PostId int `gorm:"" json:"postId"` //职位编码
CreateBy string `gorm:"size:128" json:"createBy"` //
UpdateBy string `gorm:"size:128" json:"updateBy"` //
Remark string `gorm:"size:255" json:"remark"` //备注
Status string `gorm:"size:4;" json:"status"`
DataScope string `gorm:"-" json:"dataScope"`
Params string `gorm:"-" json:"params"`
BaseModel
}
type SysUser struct {
SysUserId
SysUserB
LoginM
}
func (SysUser) TableName() string {
return "sys_user"
}
type SysUserPwd struct {
OldPassword string `json:"oldPassword"`
NewPassword string `json:"newPassword"`
}
type SysUserPage struct {
SysUserId
SysUserB
LoginM
DeptName string `gorm:"-" json:"deptName"`
}
type SysUserView struct {
SysUserId
SysUserB
LoginM
RoleName string `gorm:"column:role_name" json:"role_name"`
}
// 获取用户数据
func (e *SysUser) Get() (SysUserView SysUserView, err error) {
table := orm.Eloquent.Table(e.TableName()).Select([]string{"sys_user.*", "sys_role.role_name"})
table = table.Joins("left join sys_role on sys_user.role_id=sys_role.role_id")
if e.UserId != 0 {
table = table.Where("user_id = ?", e.UserId)
}
if e.Username != "" {
table = table.Where("username = ?", e.Username)
}
if e.Password != "" {
table = table.Where("password = ?", e.Password)
}
if e.RoleId != 0 {
table = table.Where("role_id = ?", e.RoleId)
}
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if err = table.First(&SysUserView).Error; err != nil {
return
}
SysUserView.Password = ""
return
}
func (e *SysUser) GetUserInfo() (SysUserView SysUserView, err error) {
table := orm.Eloquent.Table(e.TableName()).Select([]string{"sys_user.*", "sys_role.role_name"})
table = table.Joins("left join sys_role on sys_user.role_id=sys_role.role_id")
if e.UserId != 0 {
table = table.Where("user_id = ?", e.UserId)
}
if e.Username != "" {
table = table.Where("username = ?", e.Username)
}
if e.Password != "" {
table = table.Where("password = ?", e.Password)
}
if e.RoleId != 0 {
table = table.Where("role_id = ?", e.RoleId)
}
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if err = table.First(&SysUserView).Error; err != nil {
return
}
return
}
func (e *SysUser) GetList() (SysUserView []SysUserView, err error) {
table := orm.Eloquent.Table(e.TableName()).Select([]string{"sys_user.*", "sys_role.role_name"})
table = table.Joins("left join sys_role on sys_user.role_id=sys_role.role_id")
if e.UserId != 0 {
table = table.Where("user_id = ?", e.UserId)
}
if e.Username != "" {
table = table.Where("username = ?", e.Username)
}
if e.Password != "" {
table = table.Where("password = ?", e.Password)
}
if e.RoleId != 0 {
table = table.Where("role_id = ?", e.RoleId)
}
if e.DeptId != 0 {
table = table.Where("dept_id = ?", e.DeptId)
}
if e.PostId != 0 {
table = table.Where("post_id = ?", e.PostId)
}
if err = table.Find(&SysUserView).Error; err != nil {
return
}
return
}
func (e *SysUser) GetPage(pageSize int, pageIndex int) ([]SysUserPage, int, error) {
var doc []SysUserPage
table := orm.Eloquent.Select("sys_user.*,sys_dept.dept_name").Table(e.TableName())
table = table.Joins("left join sys_dept on sys_dept.dept_id = sys_user.dept_id")
if e.Username != "" {
table = table.Where("username = ?", e.Username)
}
if e.Status != "" {
table = table.Where("sys_user.status = ?", e.Status)
}
if e.Phone != "" {
table = table.Where("sys_user.phone = ?", e.Phone)
}
if e.DeptId != 0 {
table = table.Where("sys_user.dept_id in (select dept_id from sys_dept where dept_path like ? )", "%"+tools.IntToString(e.DeptId)+"%")
}
// 数据权限控制
dataPermission := new(DataPermission)
dataPermission.UserId, _ = tools.StringToInt(e.DataScope)
table, err := dataPermission.GetDataScope("sys_user", table)
if err != nil {
return nil, 0, err
}
var count int
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("sys_user.deleted_at IS NULL").Count(&count)
return doc, count, nil
}
//加密
func (e *SysUser) Encrypt() (err error) {
if e.Password == "" {
return
}
var hash []byte
if hash, err = bcrypt.GenerateFromPassword([]byte(e.Password), bcrypt.DefaultCost); err != nil {
return
} else {
e.Password = string(hash)
return
}
}
//添加
func (e SysUser) Insert() (id int, err error) {
if err = e.Encrypt(); err != nil {
return
}
// check 用户名
var count int
orm.Eloquent.Table(e.TableName()).Where("username = ?", e.Username).Count(&count)
if count > 0 {
err = errors.New("账户已存在!")
return
}
//添加数据
if err = orm.Eloquent.Table(e.TableName()).Create(&e).Error; err != nil {
return
}
id = e.UserId
return
}
//修改
func (e *SysUser) Update(id int) (update SysUser, err error) {
if e.Password != "" {
if err = e.Encrypt(); err != nil {
return
}
}
if err = orm.Eloquent.Table(e.TableName()).First(&update, id).Error; err != nil {
return
}
if e.RoleId == 0 {
e.RoleId = update.RoleId
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table(e.TableName()).Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
func (e *SysUser) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Table(e.TableName()).Where("user_id in (?)", id).Delete(&SysUser{}).Error; err != nil {
return
}
Result = true
return
}
func (e *SysUser) SetPwd(pwd SysUserPwd) (Result bool, err error) {
user, err := e.GetUserInfo()
if err != nil {
tools.HasError(err, "获取用户数据失败(代码202)", 500)
}
_, err = tools.CompareHashAndPassword(user.Password, pwd.OldPassword)
if err != nil {
if strings.Contains(err.Error(), "hashedPassword is not the hash of the given password") {
tools.HasError(err, "密码错误(代码202)", 500)
}
log.Print(err)
return
}
e.Password = pwd.NewPassword
_, err = e.Update(e.UserId)
tools.HasError(err, "更新密码失败(代码202)", 500)
return
}
+70
View File
@@ -0,0 +1,70 @@
package tools
import (
"errors"
"github.com/jinzhu/gorm"
orm "go-admin/global"
"go-admin/tools"
config2 "go-admin/tools/config"
)
type DBColumns struct {
TableSchema string `gorm:"column:TABLE_SCHEMA" json:"tableSchema"`
TableName string `gorm:"column:TABLE_NAME" json:"tableName"`
ColumnName string `gorm:"column:COLUMN_NAME" json:"columnName"`
ColumnDefault string `gorm:"column:COLUMN_DEFAULT" json:"columnDefault"`
IsNullable string `gorm:"column:IS_NULLABLE" json:"isNullable"`
DataType string `gorm:"column:DATA_TYPE" json:"dataType"`
CharacterMaximumLength string `gorm:"column:CHARACTER_MAXIMUM_LENGTH" json:"characterMaximumLength"`
CharacterSetName string `gorm:"column:CHARACTER_SET_NAME" json:"characterSetName"`
ColumnType string `gorm:"column:COLUMN_TYPE" json:"columnType"`
ColumnKey string `gorm:"column:COLUMN_KEY" json:"columnKey"`
Extra string `gorm:"column:EXTRA" json:"extra"`
ColumnComment string `gorm:"column:COLUMN_COMMENT" json:"columnComment"`
}
func (e *DBColumns) GetPage(pageSize int, pageIndex int) ([]DBColumns, int, error) {
var doc []DBColumns
var count int
table := new(gorm.DB)
if config2.DatabaseConfig.Driver == "mysql" {
table = orm.Eloquent.Select("*").Table("information_schema.`COLUMNS`")
table = table.Where("table_schema= ? ", config2.GenConfig.DBName)
if e.TableName != "" {
return nil, 0, errors.New("table name cannot be empty!")
}
table = table.Where("TABLE_NAME = ?", e.TableName)
}
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Count(&count)
return doc, count, nil
}
func (e *DBColumns) GetList() ([]DBColumns, error) {
var doc []DBColumns
table := new(gorm.DB)
if e.TableName == "" {
return nil, errors.New("table name cannot be empty!")
}
if config2.DatabaseConfig.Driver == "mysql" {
table = orm.Eloquent.Select("*").Table("information_schema.columns")
table = table.Where("table_schema= ? ", config2.GenConfig.DBName)
table = table.Where("TABLE_NAME = ?", e.TableName)
} else {
tools.Assert(true, "目前只支持mysql数据库", 500)
}
if err := table.Find(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
+62
View File
@@ -0,0 +1,62 @@
package tools
import (
"errors"
"github.com/jinzhu/gorm"
orm "go-admin/global"
"go-admin/tools"
config2 "go-admin/tools/config"
)
type DBTables struct {
TableName string `gorm:"column:TABLE_NAME" json:"tableName"`
Engine string `gorm:"column:ENGINE" json:"engine"`
TableRows string `gorm:"column:TABLE_ROWS" json:"tableRows"`
TableCollation string `gorm:"column:TABLE_COLLATION" json:"tableCollation"`
CreateTime string `gorm:"column:CREATE_TIME" json:"createTime"`
UpdateTime string `gorm:"column:UPDATE_TIME" json:"updateTime"`
TableComment string `gorm:"column:TABLE_COMMENT" json:"tableComment"`
}
func (e *DBTables) GetPage(pageSize int, pageIndex int) ([]DBTables, int, error) {
var doc []DBTables
table := new(gorm.DB)
var count int
if config2.DatabaseConfig.Driver == "mysql" {
table = orm.Eloquent.Select("*").Table("information_schema.tables")
table = table.Where("TABLE_NAME not in (select table_name from " + config2.GenConfig.DBName + ".sys_tables) ")
table = table.Where("table_schema= ? ", config2.GenConfig.DBName)
if e.TableName != "" {
table = table.Where("TABLE_NAME = ?", e.TableName)
}
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
} else {
tools.Assert(true, "目前只支持mysql数据库", 500)
}
table.Count(&count)
return doc, count, nil
}
func (e *DBTables) Get() (DBTables, error) {
var doc DBTables
table := new(gorm.DB)
if config2.DatabaseConfig.Driver == "mysql" {
table = orm.Eloquent.Select("*").Table("information_schema.tables")
table = table.Where("table_schema= ? ", config2.GenConfig.DBName)
if e.TableName == "" {
return doc, errors.New("table name cannot be empty!")
}
table = table.Where("TABLE_NAME = ?", e.TableName)
} else {
tools.Assert(true, "目前只支持mysql数据库", 500)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
return doc, nil
}
+84
View File
@@ -0,0 +1,84 @@
package tools
import (
orm "go-admin/global"
"go-admin/models"
)
type SysColumns struct {
ColumnId int `gorm:"primary_key;auto_increment" json:"columnId"`
TableId int `gorm:"" json:"tableId"`
ColumnName string `gorm:"size:128;" json:"columnName"`
ColumnComment string `gorm:"column:column_comment;size:128;" json:"columnComment"`
ColumnType string `gorm:"column:column_type;size:128;" json:"columnType"`
GoType string `gorm:"column:go_type;size:128;" json:"goType"`
GoField string `gorm:"column:go_field;size:128;" json:"goField"`
JsonField string `gorm:"column:json_field;size:128;" json:"jsonField"`
IsPk string `gorm:"column:is_pk;size:4;" json:"isPk"`
IsIncrement string `gorm:"column:is_increment;size:4;" json:"isIncrement"`
IsRequired string `gorm:"column:is_required;size:4;" json:"isRequired"`
IsInsert string `gorm:"column:is_insert;size:4;" json:"isInsert"`
IsEdit string `gorm:"column:is_edit;size:4;" json:"isEdit"`
IsList string `gorm:"column:is_list;size:4;" json:"isList"`
IsQuery string `gorm:"column:is_query;size:4;" json:"isQuery"`
QueryType string `gorm:"column:query_type;size:128;" json:"queryType"`
HtmlType string `gorm:"column:html_type;size:128;" json:"htmlType"`
DictType string `gorm:"column:dict_type;size:128;" json:"dictType"`
Sort int `gorm:"column:sort;" json:"sort"`
List string `gorm:"column:list;size:1;" json:"list"`
Pk bool `gorm:"column:pk;size:1;" json:"pk"`
Required bool `gorm:"column:required;size:1;" json:"required"`
SuperColumn bool `gorm:"column:super_column;size:1;" json:"superColumn"`
UsableColumn bool `gorm:"column:usable_column;size:1;" json:"usableColumn"`
Increment bool `gorm:"column:increment;size:1;" json:"increment"`
Insert bool `gorm:"column:insert;size:1;" json:"insert"`
Edit bool `gorm:"column:edit;size:1;" json:"edit"`
Query bool `gorm:"column:query;size:1;" json:"query"`
Remark string `gorm:"column:remark;size:255;" json:"remark"`
CreateBy string `gorm:"column:create_by;size:128;" json:"createBy"`
UpdateBy string `gorm:"column:update_By;size:128;" json:"updateBy"`
models.BaseModel
}
func (SysColumns) TableName() string {
return "sys_columns"
}
func (e *SysColumns) GetList() ([]SysColumns, error) {
var doc []SysColumns
table := orm.Eloquent.Select("*").Table("sys_columns")
table = table.Where("table_id = ?", e.TableId)
if err := table.Find(&doc).Error; err != nil {
return nil, err
}
return doc, nil
}
func (e *SysColumns) Create() (SysColumns, error) {
var doc SysColumns
result := orm.Eloquent.Table("sys_columns").Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
return doc, nil
}
func (e *SysColumns) Update() (update SysColumns, err error) {
if err = orm.Eloquent.Table("sys_columns").First(&update, e.ColumnId).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table("sys_columns").Model(&update).Updates(&e).Error; err != nil {
return
}
return
}
+152
View File
@@ -0,0 +1,152 @@
package tools
import (
orm "go-admin/global"
"go-admin/models"
)
type SysTables struct {
TableId int `gorm:"primary_key;auto_increment" json:"tableId"` //表编码
TBName string `gorm:"column:table_name;size:255;" json:"tableName"` //表名称
TableComment string `gorm:"size:255;" json:"tableComment"` //表备注
ClassName string `gorm:"size:255;" json:"className"` //类名
TplCategory string `gorm:"size:255;" json:"tplCategory"`
PackageName string `gorm:"size:255;" json:"packageName"` //包名
ModuleName string `gorm:"size:255;" json:"moduleName"` //模块名
BusinessName string `gorm:"size:255;" json:"businessName"`
FunctionName string `gorm:"size:255;" json:"functionName"` //功能名称
FunctionAuthor string `gorm:"size:255;" json:"functionAuthor"` //功能作者
PkColumn string `gorm:"size:255;" json:"pkColumn"`
PkGoField string `gorm:"size:255;" json:"pkGoField"`
PkJsonField string `gorm:"size:255;" json:"pkJsonField"`
Options string `gorm:"size:255;" json:"options"`
TreeCode string `gorm:"size:255;" json:"treeCode"`
TreeParentCode string `gorm:"size:255;" json:"treeParentCode"`
TreeName string `gorm:"size:255;" json:"treeName"`
Tree bool `gorm:"size:1;" json:"tree"`
Crud bool `gorm:"size:1;" json:"crud"`
Remark string `gorm:"size:255;" json:"remark"`
IsLogicalDelete string `gorm:"size:1;" json:"isLogicalDelete"`
LogicalDelete bool `gorm:"size:1;" json:"logicalDelete"`
LogicalDeleteColumn string `gorm:"size:128;" json:"logicalDeleteColumn"`
CreateBy string `gorm:"size:128;" json:"createBy"`
UpdateBy string `gorm:"size:128;" json:"updateBy"`
DataScope string `gorm:"-" json:"dataScope"`
Params Params `gorm:"-" json:"params"`
Columns []SysColumns `gorm:"-" json:"columns"`
models.BaseModel
}
func (SysTables) TableName() string {
return "sys_tables"
}
type Params struct {
TreeCode string `gorm:"-" json:"treeCode"`
TreeParentCode string `gorm:"-" json:"treeParentCode"`
TreeName string `gorm:"-" json:"treeName"`
}
func (e *SysTables) GetPage(pageSize int, pageIndex int) ([]SysTables, int, error) {
var doc []SysTables
table := orm.Eloquent.Select("*").Table("sys_tables")
if e.TBName != "" {
table = table.Where("table_name = ?", e.TBName)
}
if e.TableComment != "" {
table = table.Where("table_comment = ?", e.TableComment)
}
var count int
if err := table.Offset((pageIndex - 1) * pageSize).Limit(pageSize).Find(&doc).Error; err != nil {
return nil, 0, err
}
table.Where("`deleted_at` IS NULL").Count(&count)
return doc, count, nil
}
func (e *SysTables) Get() (SysTables, error) {
var doc SysTables
var err error
table := orm.Eloquent.Select("*").Table("sys_tables")
if e.TBName != "" {
table = table.Where("table_name = ?", e.TBName)
}
if e.TableId != 0 {
table = table.Where("table_id = ?", e.TableId)
}
if e.TableComment != "" {
table = table.Where("table_comment = ?", e.TableComment)
}
if err := table.First(&doc).Error; err != nil {
return doc, err
}
var col SysColumns
col.TableId = doc.TableId
if doc.Columns, err = col.GetList(); err != nil {
return doc, err
}
return doc, nil
}
func (e *SysTables) Create() (SysTables, error) {
var doc SysTables
result := orm.Eloquent.Table("sys_tables").Create(&e)
if result.Error != nil {
err := result.Error
return doc, err
}
doc = *e
for i := 0; i < len(e.Columns); i++ {
e.Columns[i].TableId = doc.TableId
e.Columns[i].Create()
}
return doc, nil
}
func (e *SysTables) Update() (update SysTables, err error) {
if err = orm.Eloquent.Table("sys_tables").First(&update, e.TableId).Error; err != nil {
return
}
//参数1:是要修改的数据
//参数2:是修改的数据
if err = orm.Eloquent.Table("sys_tables").Model(&update).Updates(&e).Error; err != nil {
return
}
for i := 0; i < len(e.Columns); i++ {
_, _ = e.Columns[i].Update()
}
return
}
func (e *SysTables) Delete() (success bool, err error) {
if err = orm.Eloquent.Table("sys_tables").Delete(SysTables{}, "table_id = ?", e.TableId).Error; err != nil {
success = false
return
}
if err = orm.Eloquent.Table("sys_columns").Delete(SysColumns{}, "table_id = ?", e.TableId).Error; err != nil {
success = false
return
}
success = true
return
}
func (e *SysTables) BatchDelete(id []int) (Result bool, err error) {
if err = orm.Eloquent.Unscoped().Table(e.TableName()).Where(" table_id in (?)", id).Delete(&SysColumns{}).Error; err != nil {
return
}
Result = true
return
}