wlw/ai-agent
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Init

Browse Source
This commit is contained in:
mlogclub
2026-04-09 10:01:23 +08:00
commit efe801b8bf
707 changed files with 110595 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/migration/000001_init_schema.go
+7
View File
@@ -0,0 +1,7 @@
package migration
func init() {
register(1, "init schema migration", func() error {
return nil
})
}
internal/migration/000002_init_auth_data.go
+256
View File
@@ -0,0 +1,256 @@
package migration
import (
"cs-agent/internal/models"
"cs-agent/internal/pkg/constants"
"cs-agent/internal/pkg/enums"
"cs-agent/internal/repositories"
"errors"
"log/slog"
"strings"
"time"
"github.com/mlogclub/simple/sqls"
"golang.org/x/crypto/bcrypt"
"gorm.io/gorm"
)
func init() {
register(2, "init auth builtin data", func() error {
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
permissions, err := ensurePermissions(ctx.Tx)
if err != nil {
return err
}
roles, err := ensureRoles(ctx.Tx)
if err != nil {
return err
}
if err = ensureRolePermissions(ctx.Tx, roles, permissions); err != nil {
return err
}
return ensureBootstrapAdmin(ctx.Tx, roles[constants.RoleCodeSuperAdmin])
})
})
}
func ensurePermissions(tx *gorm.DB) (map[string]*models.Permission, error) {
permissions := make(map[string]*models.Permission, len(constants.Permissions))
now := time.Now()
for _, spec := range constants.Permissions {
permission := repositories.PermissionRepository.FindOne(tx, sqls.NewCnd().Eq("code", spec.Code))
if permission == nil {
permission = &models.Permission{
Name: spec.Name,
Code: spec.Code,
Type: spec.Type,
GroupName: spec.GroupName,
Method: spec.Method,
APIPath: spec.APIPath,
SortNo: spec.SortNo,
Status: enums.StatusOk,
IsBuiltin: true,
AuditFields: models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
},
}
if err := repositories.PermissionRepository.Create(tx, permission); err != nil {
return nil, err
}
// slog.Info("initialized builtin permission", "code", spec.Code)
} else {
if err := repositories.PermissionRepository.Updates(tx, permission.ID, map[string]any{
"name": spec.Name,
"type": spec.Type,
"group_name": spec.GroupName,
"method": spec.Method,
"api_path": spec.APIPath,
"sort_no": spec.SortNo,
"status": enums.StatusOk,
"is_builtin": true,
"update_user_id": constants.SystemAuditUserID,
"update_user_name": constants.SystemAuditUserName,
"updated_at": now,
}); err != nil {
return nil, err
}
permission = repositories.PermissionRepository.Get(tx, permission.ID)
}
permissions[spec.Code] = permission
}
return permissions, nil
}
func ensureRoles(tx *gorm.DB) (map[string]*models.Role, error) {
roles := make(map[string]*models.Role, len(constants.Roles))
now := time.Now()
for _, spec := range constants.Roles {
role := repositories.RoleRepository.FindOne(tx, sqls.NewCnd().Eq("code", spec.Code))
if role == nil {
role = &models.Role{
Name: spec.Name,
Code: spec.Code,
Status: enums.StatusOk,
IsSystem: true,
SortNo: spec.SortNo,
AuditFields: models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
},
}
if err := repositories.RoleRepository.Create(tx, role); err != nil {
return nil, err
}
// slog.Info("initialized builtin role", "code", spec.Code)
} else {
if err := repositories.RoleRepository.Updates(tx, role.ID, map[string]any{
"name": spec.Name,
"sort_no": spec.SortNo,
"status": enums.StatusOk,
"is_system": true,
"update_user_id": constants.SystemAuditUserID,
"update_user_name": constants.SystemAuditUserName,
"updated_at": now,
}); err != nil {
return nil, err
}
role = repositories.RoleRepository.Get(tx, role.ID)
}
roles[spec.Code] = role
}
return roles, nil
}
func ensureRolePermissions(tx *gorm.DB, roles map[string]*models.Role, permissions map[string]*models.Permission) error {
now := time.Now()
for roleCode, rolePermissions := range constants.RolePermissions {
role := roles[roleCode]
if role == nil {
return errors.New("builtin role not found: " + roleCode)
}
for _, permissionSpec := range rolePermissions {
permission := permissions[permissionSpec.Code]
if permission == nil {
return errors.New("builtin permission not found: " + permissionSpec.Code)
}
exists := repositories.RolePermissionRepository.FindOne(tx, sqls.NewCnd().
Eq("role_id", role.ID).
Eq("permission_id", permission.ID))
if exists != nil {
continue
}
if err := repositories.RolePermissionRepository.Create(tx, &models.RolePermission{
RoleID: role.ID,
PermissionID: permission.ID,
AuditFields: models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
},
}); err != nil {
return err
}
}
}
return nil
}
func ensureBootstrapAdmin(tx *gorm.DB, superAdminRole *models.Role) error {
if superAdminRole == nil {
return errors.New("super admin role not found")
}
username := constants.BootstrapAdminUsername
nickname := constants.BootstrapAdminNickname
password := constants.BootstrapAdminPassword
if strings.TrimSpace(password) == "" {
password = "ChangeMe123!"
slog.Warn("bootstrap admin password is empty, using default password", "username", username)
}
user := repositories.UserRepository.FindOne(tx, sqls.NewCnd().Eq("username", username))
now := time.Now()
if user == nil {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
return err
}
user = &models.User{
Username: username,
Nickname: nickname,
Password: string(hashedPassword),
Status: enums.StatusOk,
Remark: "bootstrap super admin",
AuditFields: models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
},
}
if err := repositories.UserRepository.Create(tx, user); err != nil {
return err
}
slog.Warn("initialized bootstrap admin user", "username", username)
} else {
if err := repositories.UserRepository.Updates(tx, user.ID, map[string]any{
"nickname": nickname,
"status": enums.StatusOk,
"is_system": true,
"update_user_id": constants.SystemAuditUserID,
"update_user_name": constants.SystemAuditUserName,
"updated_at": now,
}); err != nil {
return err
}
user = repositories.UserRepository.Get(tx, user.ID)
}
exists := repositories.UserRoleRepository.FindOne(tx, sqls.NewCnd().
Eq("user_id", user.ID).
Eq("role_id", superAdminRole.ID))
if exists != nil {
return nil
}
return repositories.UserRoleRepository.Create(tx, &models.UserRole{
UserID: user.ID,
RoleID: superAdminRole.ID,
AuditFields: models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
},
})
}
internal/migration/000003_init_ticket_priority_configs.go
+44
View File
@@ -0,0 +1,44 @@
package migration
import (
"time"
"cs-agent/internal/models"
"cs-agent/internal/pkg/constants"
"cs-agent/internal/pkg/enums"
"github.com/mlogclub/simple/sqls"
)
func init() {
register(3, "init ticket priority configs", func() error {
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
var total int64
if err := ctx.Tx.Model(&models.TicketPriorityConfig{}).Where("status <> ?", enums.StatusDeleted).Count(&total).Error; err != nil {
return err
}
if total == 0 {
now := time.Now()
items := []*models.TicketPriorityConfig{
{Name: "普通", SortNo: 10, FirstResponseMinutes: 30, ResolutionMinutes: 1440, Status: enums.StatusOk},
{Name: "高", SortNo: 20, FirstResponseMinutes: 10, ResolutionMinutes: 240, Status: enums.StatusOk},
{Name: "紧急", SortNo: 30, FirstResponseMinutes: 5, ResolutionMinutes: 120, Status: enums.StatusOk},
}
for _, item := range items {
item.AuditFields = models.AuditFields{
CreatedAt: now,
CreateUserID: constants.SystemAuditUserID,
CreateUserName: constants.SystemAuditUserName,
UpdatedAt: now,
UpdateUserID: constants.SystemAuditUserID,
UpdateUserName: constants.SystemAuditUserName,
}
if err := ctx.Tx.Create(item).Error; err != nil {
return err
}
}
}
return nil
})
})
}
internal/migration/README.md
+3
View File
@@ -0,0 +1,3 @@
# data migration
data migration only, DLL are prohibited.
internal/migration/migration.go
+101
View File
@@ -0,0 +1,101 @@
package migration
import (
"cs-agent/internal/models"
"cs-agent/internal/services"
"errors"
"log/slog"
"sync"
"time"
"github.com/mlogclub/simple/sqls"
"github.com/spf13/cast"
)
var migrationFuncs = make(map[int64]MigrationFunc)
var versions = make([]int64, 0)
var migrations = make(map[int64]models.Migration, 0)
var mu sync.Mutex
type MigrationFunc struct {
Version int64
Remark string
Fn func() error
}
func Migrate() error {
mu.Lock()
defer mu.Unlock()
if list := services.MigrationService.Find(sqls.NewCnd().Asc("version")); len(list) > 0 {
for _, element := range list {
migrations[element.Version] = element
}
}
for _, version := range versions {
if err := runMigration(version); err != nil {
slog.Error("migrate failed", "version", version, "error", err)
return err
}
}
return nil
}
func register(version int64, remark string, fn func() error) {
if len(versions) == 0 || version > versions[len(versions)-1] {
versions = append(versions, version)
migrationFuncs[version] = MigrationFunc{
Version: version,
Remark: remark,
Fn: fn,
}
} else {
slog.Error("register migration failed, version is less than latest version", slog.Any("version", version))
panic(errors.New("register migration failed, version is less than latest version. version: " + cast.ToString(version)))
}
}
func runMigration(version int64) error {
migration, found := migrations[version]
if found && migration.Success {
return nil
}
f, ok := migrationFuncs[version]
if !ok {
return errors.New("migration function not found")
}
err := f.Fn()
if !found {
migration = models.Migration{
Version: f.Version,
Remark: f.Remark,
Success: false,
RetryCount: 0,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
}
if err == nil {
migration.Success = true
} else {
migration.Success = false
migration.ErrorInfo = err.Error()
}
migration.RetryCount++
migration.UpdatedAt = time.Now()
if found {
if e := services.MigrationService.Update(&migration); e != nil {
slog.Error("update migration failed", "version", version, "error", err)
}
} else {
if e := services.MigrationService.Create(&migration); e != nil {
slog.Error("create migration failed", "version", version, "error", err)
}
}
return err
}