118 lines
3.6 KiB
Go
118 lines
3.6 KiB
Go
package version_local
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
|
|
"go-admin/app/goauto/access"
|
|
"go-admin/cmd/migrate/migration"
|
|
migrationmodels "go-admin/cmd/migrate/migration/models"
|
|
common "go-admin/common/models"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func init() {
|
|
_, fileName, _, _ := runtime.Caller(0)
|
|
migration.Migrate.SetVersion(migration.GetFilename(fileName), migrateGoAutoMenuGroups)
|
|
}
|
|
|
|
func migrateGoAutoMenuGroups(db *gorm.DB, version string) error {
|
|
return db.Transaction(func(tx *gorm.DB) error {
|
|
if err := ensureGoAutoMenuGroups(tx); err != nil {
|
|
return err
|
|
}
|
|
return tx.Create(&common.Migration{Version: version}).Error
|
|
})
|
|
}
|
|
|
|
func ensureGoAutoMenuGroups(db *gorm.DB) error {
|
|
modules := make(map[string]access.ModuleDefinition)
|
|
for _, module := range access.GoAutoModules() {
|
|
modules[module.Key] = module
|
|
}
|
|
|
|
var purchaser migrationmodels.SysRole
|
|
if err := db.Where("role_key = ?", access.RolePurchaser).First(&purchaser).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
allowedPurchaserMenus := make([]migrationmodels.SysMenu, 0, len(access.GoAutoModules())+len(access.GoAutoMenuGroups()))
|
|
for _, group := range access.GoAutoMenuGroups() {
|
|
groupMenu, _, err := upsertGoAutoMenu(db, migrationmodels.SysMenu{
|
|
MenuName: group.MenuName,
|
|
Title: group.Title,
|
|
Icon: group.Icon,
|
|
Path: group.Path,
|
|
MenuType: "M",
|
|
Action: "无",
|
|
ParentId: 0,
|
|
Component: "Layout",
|
|
Sort: group.Sort,
|
|
Visible: "0",
|
|
IsFrame: "1",
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := db.Model(&groupMenu).Update("paths", fmt.Sprintf("/0/%d", groupMenu.MenuId)).Error; err != nil {
|
|
return err
|
|
}
|
|
allowedPurchaserMenus = append(allowedPurchaserMenus, groupMenu)
|
|
|
|
for childIndex, moduleKey := range group.ModuleKeys {
|
|
module, ok := modules[moduleKey]
|
|
if !ok {
|
|
return fmt.Errorf("GoAuto menu group %s references unknown module %s", group.Key, moduleKey)
|
|
}
|
|
var child migrationmodels.SysMenu
|
|
if err := db.Unscoped().Where("menu_name = ?", module.RouteName).First(&child).Error; err != nil {
|
|
return fmt.Errorf("find GoAuto child menu %s: %w", module.RouteName, err)
|
|
}
|
|
updates := map[string]any{
|
|
"parent_id": groupMenu.MenuId,
|
|
"paths": fmt.Sprintf("/0/%d/%d", groupMenu.MenuId, child.MenuId),
|
|
"sort": childIndex + 1,
|
|
"deleted_at": nil,
|
|
}
|
|
if err := db.Unscoped().Model(&child).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
if module.PurchaserHardHidden {
|
|
if err := db.Model(&purchaser).Association("SysMenu").Delete(&child); err != nil {
|
|
return err
|
|
}
|
|
} else if module.PurchaserDefault {
|
|
allowedPurchaserMenus = append(allowedPurchaserMenus, child)
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := db.Model(&purchaser).Association("SysMenu").Append(allowedPurchaserMenus); err != nil {
|
|
return err
|
|
}
|
|
|
|
oldRootNames := make([]string, 0, len(access.GoAutoModules()))
|
|
for _, module := range access.GoAutoModules() {
|
|
oldRootNames = append(oldRootNames, module.RouteName+"Root")
|
|
}
|
|
var oldRoots []migrationmodels.SysMenu
|
|
if err := db.Unscoped().Where("menu_name IN ?", oldRootNames).Find(&oldRoots).Error; err != nil {
|
|
return err
|
|
}
|
|
if len(oldRoots) == 0 {
|
|
return nil
|
|
}
|
|
oldRootIDs := make([]int, 0, len(oldRoots))
|
|
for _, root := range oldRoots {
|
|
oldRootIDs = append(oldRootIDs, root.MenuId)
|
|
}
|
|
if err := db.Table("sys_role_menu").Where("menu_id IN ?", oldRootIDs).Delete(nil).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := db.Table("sys_menu_api_rule").Where("sys_menu_menu_id IN ?", oldRootIDs).Delete(nil).Error; err != nil {
|
|
return err
|
|
}
|
|
return db.Unscoped().Where("menu_id IN ?", oldRootIDs).Delete(&migrationmodels.SysMenu{}).Error
|
|
}
|