后端重构

internal/data/data.go

@@ -2,7 +2,9 @@ package data
 
 import (
 	"fmt"
+	"kra/internal/biz/example"
 	"kra/internal/conf"
+	dataexample "kra/internal/data/example"
 	datasystem "kra/internal/data/system"
 	pkgcasbin "kra/pkg/casbin"
 
@@ -19,6 +21,9 @@ var ProviderSet = wire.NewSet(
 	NewDB,
 	NewData,
 	NewCasbinEnforcer,
+	NewOssUploader,
+	NewDataAuthorityProvider,
+	// System
 	datasystem.NewUserRepo,
 	datasystem.NewApiRepo,
 	datasystem.NewAuthorityRepo,
@@ -30,6 +35,15 @@ var ProviderSet = wire.NewSet(
 	datasystem.NewJwtBlacklistRepo,
 	datasystem.NewOperationRecordRepo,
 	datasystem.NewParamsRepo,
+	datasystem.NewErrorRepo,
+	datasystem.NewVersionRepo,
+	datasystem.NewExportTemplateRepo,
+	datasystem.NewAutoCodeRepo,
+	datasystem.NewAutoCodeHistoryRepo,
+	// Example
+	dataexample.NewFileUploadRepo,
+	dataexample.NewCustomerRepo,
+	dataexample.NewAttachmentCategoryRepo,
 )
 
 // Data 数据层包装器
@@ -66,3 +80,15 @@ func NewDB(c *conf.Mysql) (*gorm.DB, error) {
 func NewCasbinEnforcer(db *gorm.DB) (*casbin.SyncedCachedEnforcer, error) {
 	return pkgcasbin.InitCasbin(db, "")
 }
+
+// NewOssUploader 创建OSS上传器（默认使用空实现）
+func NewOssUploader() example.OssUploader {
+	// TODO: 根据配置返回实际的OSS实现
+	return &example.NilOssUploader{}
+}
+
+// NewDataAuthorityProvider 创建数据权限提供者（默认使用简单实现）
+func NewDataAuthorityProvider() example.DataAuthorityProvider {
+	// TODO: 根据需要返回实际的数据权限实现
+	return &example.SimpleDataAuthorityProvider{}
+}

internal/data/example/attachment_category.go

@@ -0,0 +1,92 @@
+package example
+
+import (
+	"context"
+
+	"kra/internal/biz/example"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type attachmentCategoryRepo struct {
+	db *gorm.DB
+}
+
+// NewAttachmentCategoryRepo 创建附件分类仓储
+func NewAttachmentCategoryRepo(db *gorm.DB) example.AttachmentCategoryRepo {
+	return &attachmentCategoryRepo{db: db}
+}
+
+func (r *attachmentCategoryRepo) Create(ctx context.Context, category *example.AttachmentCategory) error {
+	m := &model.ExaAttachmentCategory{
+		Name: category.Name,
+		Pid:  int64(category.Pid),
+	}
+	return r.db.WithContext(ctx).Create(m).Error
+}
+
+func (r *attachmentCategoryRepo) Update(ctx context.Context, category *example.AttachmentCategory) error {
+	return r.db.WithContext(ctx).Model(&model.ExaAttachmentCategory{}).
+		Where("id = ?", category.ID).
+		Updates(map[string]any{
+			"name": category.Name,
+			"pid":  category.Pid,
+		}).Error
+}
+
+func (r *attachmentCategoryRepo) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Unscoped().
+		Where("id = ?", id).
+		Delete(&model.ExaAttachmentCategory{}).Error
+}
+
+func (r *attachmentCategoryRepo) FindByID(ctx context.Context, id uint) (*example.AttachmentCategory, error) {
+	c := query.ExaAttachmentCategory
+	m, err := c.WithContext(ctx).Where(c.ID.Eq(int64(id))).First()
+	if err != nil {
+		return nil, err
+	}
+	return toCategoryBiz(m), nil
+}
+
+func (r *attachmentCategoryRepo) FindByNameAndPid(ctx context.Context, name string, pid uint) (*example.AttachmentCategory, error) {
+	c := query.ExaAttachmentCategory
+	m, err := c.WithContext(ctx).Where(c.Name.Eq(name), c.Pid.Eq(int64(pid))).First()
+	if err != nil {
+		return nil, err
+	}
+	return toCategoryBiz(m), nil
+}
+
+func (r *attachmentCategoryRepo) FindAll(ctx context.Context) ([]*example.AttachmentCategory, error) {
+	c := query.ExaAttachmentCategory
+	list, err := c.WithContext(ctx).Find()
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]*example.AttachmentCategory, len(list))
+	for i, m := range list {
+		result[i] = toCategoryBiz(m)
+	}
+	return result, nil
+}
+
+func (r *attachmentCategoryRepo) HasChildren(ctx context.Context, id uint) (bool, error) {
+	c := query.ExaAttachmentCategory
+	count, err := c.WithContext(ctx).Where(c.Pid.Eq(int64(id))).Count()
+	return count > 0, err
+}
+
+// 转换函数
+func toCategoryBiz(m *model.ExaAttachmentCategory) *example.AttachmentCategory {
+	return &example.AttachmentCategory{
+		ID:        uint(m.ID),
+		Name:      m.Name,
+		Pid:       uint(m.Pid),
+		CreatedAt: m.CreatedAt,
+		UpdatedAt: m.UpdatedAt,
+	}
+}

internal/data/example/customer.go

@@ -0,0 +1,95 @@
+package example
+
+import (
+	"context"
+
+	"kra/internal/biz/example"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type customerRepo struct {
+	db *gorm.DB
+}
+
+// NewCustomerRepo 创建客户仓储
+func NewCustomerRepo(db *gorm.DB) example.CustomerRepo {
+	return &customerRepo{db: db}
+}
+
+func (r *customerRepo) Create(ctx context.Context, customer *example.Customer) error {
+	m := toCustomerModel(customer)
+	return r.db.WithContext(ctx).Create(m).Error
+}
+
+func (r *customerRepo) Update(ctx context.Context, customer *example.Customer) error {
+	return r.db.WithContext(ctx).Save(toCustomerModel(customer)).Error
+}
+
+func (r *customerRepo) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.ExaCustomer{}, id).Error
+}
+
+func (r *customerRepo) FindByID(ctx context.Context, id uint) (*example.Customer, error) {
+	c := query.ExaCustomer
+	m, err := c.WithContext(ctx).Where(c.ID.Eq(int64(id))).First()
+	if err != nil {
+		return nil, err
+	}
+	return toCustomerBiz(m), nil
+}
+
+func (r *customerRepo) List(ctx context.Context, authorityIds []uint, page, pageSize int) ([]*example.Customer, int64, error) {
+	c := query.ExaCustomer
+	q := c.WithContext(ctx)
+
+	if len(authorityIds) > 0 {
+		ids := make([]int64, len(authorityIds))
+		for i, id := range authorityIds {
+			ids[i] = int64(id)
+		}
+		q = q.Where(c.SysUserAuthorityID.In(ids...))
+	}
+
+	total, err := q.Count()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	offset := (page - 1) * pageSize
+	list, err := q.Offset(offset).Limit(pageSize).Find()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*example.Customer, len(list))
+	for i, m := range list {
+		result[i] = toCustomerBiz(m)
+	}
+	return result, total, nil
+}
+
+// 转换函数
+func toCustomerModel(c *example.Customer) *model.ExaCustomer {
+	return &model.ExaCustomer{
+		ID:                 int64(c.ID),
+		CustomerName:       c.CustomerName,
+		CustomerPhoneData:  c.CustomerPhoneData,
+		SysUserID:          int64(c.SysUserID),
+		SysUserAuthorityID: int64(c.SysUserAuthorityID),
+	}
+}
+
+func toCustomerBiz(m *model.ExaCustomer) *example.Customer {
+	return &example.Customer{
+		ID:                 uint(m.ID),
+		CustomerName:       m.CustomerName,
+		CustomerPhoneData:  m.CustomerPhoneData,
+		SysUserID:          uint(m.SysUserID),
+		SysUserAuthorityID: uint(m.SysUserAuthorityID),
+		CreatedAt:          m.CreatedAt,
+		UpdatedAt:          m.UpdatedAt,
+	}
+}

internal/data/example/file_upload.go

@@ -0,0 +1,120 @@
+package example
+
+import (
+	"context"
+
+	"kra/internal/biz/example"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type fileUploadRepo struct {
+	db *gorm.DB
+}
+
+// NewFileUploadRepo 创建文件上传仓储
+func NewFileUploadRepo(db *gorm.DB) example.FileUploadRepo {
+	return &fileUploadRepo{db: db}
+}
+
+func (r *fileUploadRepo) Create(ctx context.Context, file *example.FileUpload) error {
+	m := toFileUploadModel(file)
+	return r.db.WithContext(ctx).Create(m).Error
+}
+
+func (r *fileUploadRepo) Update(ctx context.Context, file *example.FileUpload) error {
+	return r.db.WithContext(ctx).Model(&model.ExaFileUploadAndDownload{}).
+		Where("id = ?", file.ID).
+		Updates(map[string]any{
+			"name":     file.Name,
+			"class_id": file.ClassId,
+		}).Error
+}
+
+func (r *fileUploadRepo) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Unscoped().
+		Where("id = ?", id).
+		Delete(&model.ExaFileUploadAndDownload{}).Error
+}
+
+func (r *fileUploadRepo) FindByID(ctx context.Context, id uint) (*example.FileUpload, error) {
+	f := query.ExaFileUploadAndDownload
+	m, err := f.WithContext(ctx).Where(f.ID.Eq(int64(id))).First()
+	if err != nil {
+		return nil, err
+	}
+	return toFileUploadBiz(m), nil
+}
+
+func (r *fileUploadRepo) FindByKey(ctx context.Context, key string) (*example.FileUpload, error) {
+	f := query.ExaFileUploadAndDownload
+	m, err := f.WithContext(ctx).Where(f.Key.Eq(key)).First()
+	if err != nil {
+		return nil, err
+	}
+	return toFileUploadBiz(m), nil
+}
+
+func (r *fileUploadRepo) List(ctx context.Context, req *example.FileUploadSearchReq) ([]*example.FileUpload, int64, error) {
+	f := query.ExaFileUploadAndDownload
+	q := f.WithContext(ctx)
+
+	if req.Keyword != "" {
+		q = q.Where(f.Name.Like("%" + req.Keyword + "%"))
+	}
+	if req.ClassId > 0 {
+		q = q.Where(f.ClassID.Eq(int64(req.ClassId)))
+	}
+
+	total, err := q.Count()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	offset := (req.Page - 1) * req.PageSize
+	list, err := q.Order(f.ID.Desc()).Offset(offset).Limit(req.PageSize).Find()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*example.FileUpload, len(list))
+	for i, m := range list {
+		result[i] = toFileUploadBiz(m)
+	}
+	return result, total, nil
+}
+
+func (r *fileUploadRepo) BatchCreate(ctx context.Context, files []*example.FileUpload) error {
+	models := make([]*model.ExaFileUploadAndDownload, len(files))
+	for i, f := range files {
+		models[i] = toFileUploadModel(f)
+	}
+	return r.db.WithContext(ctx).Create(&models).Error
+}
+
+// 转换函数
+func toFileUploadModel(f *example.FileUpload) *model.ExaFileUploadAndDownload {
+	return &model.ExaFileUploadAndDownload{
+		ID:      int64(f.ID),
+		Name:    f.Name,
+		ClassID: int64(f.ClassId),
+		URL:     f.Url,
+		Tag:     f.Tag,
+		Key:     f.Key,
+	}
+}
+
+func toFileUploadBiz(m *model.ExaFileUploadAndDownload) *example.FileUpload {
+	return &example.FileUpload{
+		ID:        uint(m.ID),
+		Name:      m.Name,
+		ClassId:   int(m.ClassID),
+		Url:       m.URL,
+		Tag:       m.Tag,
+		Key:       m.Key,
+		CreatedAt: m.CreatedAt,
+		UpdatedAt: m.UpdatedAt,
+	}
+}

internal/data/system/auto_code.go

@@ -0,0 +1,71 @@
+package system
+
+import (
+	"context"
+
+	"kra/internal/biz/system"
+
+	"gorm.io/gorm"
+)
+
+type autoCodeRepo struct {
+	db *gorm.DB
+}
+
+// NewAutoCodeRepo 创建自动代码仓储
+func NewAutoCodeRepo(db *gorm.DB) system.AutoCodeRepo {
+	return &autoCodeRepo{db: db}
+}
+
+// GetDB 获取所有数据库
+func (r *autoCodeRepo) GetDB(ctx context.Context) ([]system.Db, error) {
+	var entities []system.Db
+	sql := "SELECT SCHEMA_NAME AS `database` FROM INFORMATION_SCHEMA.SCHEMATA;"
+	err := r.db.WithContext(ctx).Raw(sql).Scan(&entities).Error
+	return entities, err
+}
+
+// GetTables 获取指定数据库的所有表
+func (r *autoCodeRepo) GetTables(ctx context.Context, dbName string) ([]system.Table, error) {
+	var entities []system.Table
+	sql := `SELECT table_name AS table_name FROM information_schema.tables WHERE table_schema = ?`
+	err := r.db.WithContext(ctx).Raw(sql, dbName).Scan(&entities).Error
+	return entities, err
+}
+
+// GetColumn 获取指定表的所有列
+func (r *autoCodeRepo) GetColumn(ctx context.Context, tableName, dbName string) ([]system.Column, error) {
+	var entities []system.Column
+	sql := `
+	SELECT 
+		c.COLUMN_NAME column_name,
+		c.DATA_TYPE data_type,
+		CASE c.DATA_TYPE
+			WHEN 'longtext' THEN c.CHARACTER_MAXIMUM_LENGTH
+			WHEN 'varchar' THEN c.CHARACTER_MAXIMUM_LENGTH
+			WHEN 'double' THEN CONCAT_WS(',', c.NUMERIC_PRECISION, c.NUMERIC_SCALE)
+			WHEN 'decimal' THEN CONCAT_WS(',', c.NUMERIC_PRECISION, c.NUMERIC_SCALE)
+			WHEN 'int' THEN c.NUMERIC_PRECISION
+			WHEN 'bigint' THEN c.NUMERIC_PRECISION
+			ELSE '' 
+		END AS data_type_long,
+		c.COLUMN_COMMENT column_comment,
+		CASE WHEN kcu.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS primary_key,
+		c.ORDINAL_POSITION
+	FROM 
+		INFORMATION_SCHEMA.COLUMNS c
+	LEFT JOIN 
+		INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu 
+	ON 
+		c.TABLE_SCHEMA = kcu.TABLE_SCHEMA 
+		AND c.TABLE_NAME = kcu.TABLE_NAME 
+		AND c.COLUMN_NAME = kcu.COLUMN_NAME 
+		AND kcu.CONSTRAINT_NAME = 'PRIMARY'
+	WHERE 
+		c.TABLE_NAME = ? 
+		AND c.TABLE_SCHEMA = ?
+	ORDER BY 
+		c.ORDINAL_POSITION;`
+	err := r.db.WithContext(ctx).Raw(sql, tableName, dbName).Scan(&entities).Error
+	return entities, err
+}

internal/data/system/auto_code_history.go

@@ -0,0 +1,68 @@
+package system
+
+import (
+	"context"
+
+	"kra/internal/biz/system"
+
+	"gorm.io/gorm"
+)
+
+type autoCodeHistoryRepo struct {
+	db *gorm.DB
+}
+
+// NewAutoCodeHistoryRepo 创建自动代码历史仓储
+func NewAutoCodeHistoryRepo(db *gorm.DB) system.AutoCodeHistoryRepo {
+	return &autoCodeHistoryRepo{db: db}
+}
+
+// First 根据id获取meta信息
+func (r *autoCodeHistoryRepo) First(ctx context.Context, id uint) (string, error) {
+	var meta string
+	err := r.db.WithContext(ctx).Model(&system.SysAutoCodeHistory{}).
+		Where("id = ?", id).
+		Pluck("request", &meta).Error
+	return meta, err
+}
+
+// Delete 删除历史记录
+func (r *autoCodeHistoryRepo) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Where("id = ?", id).Delete(&system.SysAutoCodeHistory{}).Error
+}
+
+// GetList 获取历史记录列表
+func (r *autoCodeHistoryRepo) GetList(ctx context.Context, page, pageSize int) ([]system.SysAutoCodeHistory, int64, error) {
+	var list []system.SysAutoCodeHistory
+	var total int64
+
+	db := r.db.WithContext(ctx).Model(&system.SysAutoCodeHistory{})
+	err := db.Count(&total).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	offset := (page - 1) * pageSize
+	err = db.Offset(offset).Limit(pageSize).Order("updated_at desc").Find(&list).Error
+	return list, total, err
+}
+
+// GetByID 根据ID获取历史记录
+func (r *autoCodeHistoryRepo) GetByID(ctx context.Context, id uint) (*system.SysAutoCodeHistory, error) {
+	var history system.SysAutoCodeHistory
+	err := r.db.WithContext(ctx).Where("id = ?", id).First(&history).Error
+	return &history, err
+}
+
+// UpdateFlag 更新标记
+func (r *autoCodeHistoryRepo) UpdateFlag(ctx context.Context, id uint, flag int) error {
+	return r.db.WithContext(ctx).Model(&system.SysAutoCodeHistory{}).
+		Where("id = ?", id).
+		Update("flag", flag).Error
+}
+
+// DropTable 删除表
+func (r *autoCodeHistoryRepo) DropTable(ctx context.Context, businessDB, tableName string) error {
+	// 注意：这里简化处理，实际应该支持多数据库
+	return r.db.WithContext(ctx).Exec("DROP TABLE IF EXISTS " + tableName).Error
+}

internal/data/system/error.go

@@ -0,0 +1,138 @@
+package system
+
+import (
+	"context"
+	"strconv"
+
+	"kra/internal/biz/system"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type errorRepo struct {
+	db *gorm.DB
+}
+
+// NewErrorRepo 创建错误日志仓储
+func NewErrorRepo(db *gorm.DB) system.ErrorRepo {
+	return &errorRepo{db: db}
+}
+
+func (r *errorRepo) Create(ctx context.Context, sysError *system.SysError) error {
+	m := toModelError(sysError)
+	return query.SysError.WithContext(ctx).Create(m)
+}
+
+func (r *errorRepo) Delete(ctx context.Context, id string) error {
+	_, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.Eq(parseID(id))).Delete()
+	return err
+}
+
+func (r *errorRepo) DeleteByIds(ctx context.Context, ids []string) error {
+	idList := make([]int64, len(ids))
+	for i, id := range ids {
+		idList[i] = parseID(id)
+	}
+	_, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.In(idList...)).Delete()
+	return err
+}
+
+func (r *errorRepo) Update(ctx context.Context, sysError *system.SysError) error {
+	_, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.Eq(sysError.ID)).Updates(map[string]any{
+		"form":     sysError.Form,
+		"info":     sysError.Info,
+		"level":    sysError.Level,
+		"solution": sysError.Solution,
+		"status":   sysError.Status,
+	})
+	return err
+}
+
+func (r *errorRepo) GetById(ctx context.Context, id string) (*system.SysError, error) {
+	m, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.Eq(parseID(id))).First()
+	if err != nil {
+		return nil, err
+	}
+	return toBizError(m), nil
+}
+
+func (r *errorRepo) GetList(ctx context.Context, req *system.ErrorSearchReq) ([]*system.SysError, int64, error) {
+	q := query.SysError.WithContext(ctx).Order(query.SysError.CreatedAt.Desc())
+
+	// 条件搜索
+	if len(req.CreatedAtRange) == 2 {
+		q = q.Where(query.SysError.CreatedAt.Between(req.CreatedAtRange[0], req.CreatedAtRange[1]))
+	}
+	if req.Form != nil && *req.Form != "" {
+		q = q.Where(query.SysError.Form.Eq(*req.Form))
+	}
+	if req.Info != nil && *req.Info != "" {
+		q = q.Where(query.SysError.Info.Like("%" + *req.Info + "%"))
+	}
+
+	total, err := q.Count()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if req.PageSize > 0 {
+		offset := req.PageSize * (req.Page - 1)
+		q = q.Limit(req.PageSize).Offset(offset)
+	}
+
+	list, err := q.Find()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*system.SysError, len(list))
+	for i, m := range list {
+		result[i] = toBizError(m)
+	}
+	return result, total, nil
+}
+
+func (r *errorRepo) UpdateStatus(ctx context.Context, id string, status string) error {
+	_, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.Eq(parseID(id))).Update(query.SysError.Status, status)
+	return err
+}
+
+func (r *errorRepo) UpdateSolution(ctx context.Context, id string, status string, solution string) error {
+	_, err := query.SysError.WithContext(ctx).Where(query.SysError.ID.Eq(parseID(id))).Updates(map[string]any{
+		"status":   status,
+		"solution": solution,
+	})
+	return err
+}
+
+// 转换函数
+func parseID(id string) int64 {
+	n, _ := strconv.ParseInt(id, 10, 64)
+	return n
+}
+
+func toModelError(e *system.SysError) *model.SysError {
+	return &model.SysError{
+		ID:       e.ID,
+		Form:     e.Form,
+		Info:     e.Info,
+		Level:    e.Level,
+		Solution: e.Solution,
+		Status:   e.Status,
+	}
+}
+
+func toBizError(m *model.SysError) *system.SysError {
+	return &system.SysError{
+		ID:        m.ID,
+		Form:      m.Form,
+		Info:      m.Info,
+		Level:     m.Level,
+		Solution:  m.Solution,
+		Status:    m.Status,
+		CreatedAt: m.CreatedAt,
+		UpdatedAt: m.UpdatedAt,
+	}
+}

internal/data/system/export_template.go

@@ -0,0 +1,283 @@
+package system
+
+import (
+	"context"
+
+	"kra/internal/biz/system"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type exportTemplateRepo struct {
+	db *gorm.DB
+}
+
+// NewExportTemplateRepo 创建导出模板仓储
+func NewExportTemplateRepo(db *gorm.DB) system.ExportTemplateRepo {
+	return &exportTemplateRepo{db: db}
+}
+
+func (r *exportTemplateRepo) Create(ctx context.Context, template *system.ExportTemplate) error {
+	m := toModelExportTemplate(template)
+	if err := r.db.WithContext(ctx).Create(m).Error; err != nil {
+		return err
+	}
+	template.ID = uint(m.ID)
+
+	// 创建条件
+	if len(template.Conditions) > 0 {
+		for _, c := range template.Conditions {
+			c.TemplateID = template.TemplateID
+		}
+		if err := r.CreateConditions(ctx, template.Conditions); err != nil {
+			return err
+		}
+	}
+
+	// 创建关联
+	if len(template.JoinTemplate) > 0 {
+		for _, j := range template.JoinTemplate {
+			j.TemplateID = template.TemplateID
+		}
+		if err := r.CreateJoins(ctx, template.JoinTemplate); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (r *exportTemplateRepo) Update(ctx context.Context, template *system.ExportTemplate) error {
+	m := toModelExportTemplate(template)
+	return r.db.WithContext(ctx).Model(&model.SysExportTemplate{}).Where("id = ?", template.ID).Updates(m).Error
+}
+
+func (r *exportTemplateRepo) Delete(ctx context.Context, id uint) error {
+	return r.db.WithContext(ctx).Delete(&model.SysExportTemplate{}, id).Error
+}
+
+func (r *exportTemplateRepo) FindByID(ctx context.Context, id uint) (*system.ExportTemplate, error) {
+	var m model.SysExportTemplate
+	if err := r.db.WithContext(ctx).First(&m, id).Error; err != nil {
+		return nil, err
+	}
+
+	// 加载条件
+	var conditions []model.SysExportTemplateCondition
+	r.db.WithContext(ctx).Where("template_id = ?", m.TemplateID).Find(&conditions)
+
+	// 加载关联
+	var joins []model.SysExportTemplateJoin
+	r.db.WithContext(ctx).Where("template_id = ?", m.TemplateID).Find(&joins)
+
+	return toBizExportTemplate(&m, conditions, joins), nil
+}
+
+func (r *exportTemplateRepo) FindByTemplateID(ctx context.Context, templateID string) (*system.ExportTemplate, error) {
+	var m model.SysExportTemplate
+	if err := r.db.WithContext(ctx).Where("template_id = ?", templateID).First(&m).Error; err != nil {
+		return nil, err
+	}
+
+	// 加载条件
+	var conditions []model.SysExportTemplateCondition
+	r.db.WithContext(ctx).Where("template_id = ?", templateID).Find(&conditions)
+
+	// 加载关联
+	var joins []model.SysExportTemplateJoin
+	r.db.WithContext(ctx).Where("template_id = ?", templateID).Find(&joins)
+
+	return toBizExportTemplate(&m, conditions, joins), nil
+}
+
+func (r *exportTemplateRepo) GetList(ctx context.Context, req *system.ExportTemplateSearchReq) ([]*system.ExportTemplate, int64, error) {
+	q := query.SysExportTemplate
+	do := q.WithContext(ctx)
+
+	if req.Name != "" {
+		do = do.Where(q.Name.Like("%" + req.Name + "%"))
+	}
+	if req.TableName != "" {
+		do = do.Where(q.TblName.Eq(req.TableName))
+	}
+	if req.TemplateID != "" {
+		do = do.Where(q.TemplateID.Eq(req.TemplateID))
+	}
+	if req.StartCreatedAt != nil && req.EndCreatedAt != nil {
+		do = do.Where(q.CreatedAt.Between(*req.StartCreatedAt, *req.EndCreatedAt))
+	}
+
+	total, err := do.Count()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if req.PageSize > 0 {
+		do = do.Limit(req.PageSize).Offset((req.Page - 1) * req.PageSize)
+	}
+
+	list, err := do.Find()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*system.ExportTemplate, len(list))
+	for i, m := range list {
+		result[i] = toBizExportTemplateSimple(m)
+	}
+
+	return result, total, nil
+}
+
+func (r *exportTemplateRepo) DeleteConditionsByTemplateID(ctx context.Context, templateID string) error {
+	return r.db.WithContext(ctx).Where("template_id = ?", templateID).Delete(&model.SysExportTemplateCondition{}).Error
+}
+
+func (r *exportTemplateRepo) DeleteJoinsByTemplateID(ctx context.Context, templateID string) error {
+	return r.db.WithContext(ctx).Where("template_id = ?", templateID).Delete(&model.SysExportTemplateJoin{}).Error
+}
+
+func (r *exportTemplateRepo) CreateConditions(ctx context.Context, conditions []*system.Condition) error {
+	if len(conditions) == 0 {
+		return nil
+	}
+	models := make([]*model.SysExportTemplateCondition, len(conditions))
+	for i, c := range conditions {
+		models[i] = &model.SysExportTemplateCondition{
+			TemplateID: c.TemplateID,
+			From:       c.From,
+			Column:     c.Column,
+			Operator:   c.Operator,
+		}
+	}
+	return r.db.WithContext(ctx).Create(&models).Error
+}
+
+func (r *exportTemplateRepo) CreateJoins(ctx context.Context, joins []*system.JoinTemplate) error {
+	if len(joins) == 0 {
+		return nil
+	}
+	models := make([]*model.SysExportTemplateJoin, len(joins))
+	for i, j := range joins {
+		models[i] = &model.SysExportTemplateJoin{
+			TemplateID: j.TemplateID,
+			Joins:      j.Joins,
+			TblName:    j.Table,
+			On:         j.On,
+		}
+	}
+	return r.db.WithContext(ctx).Create(&models).Error
+}
+
+func (r *exportTemplateRepo) GetDB(dbName string) interface{} {
+	// 简化实现：返回默认数据库
+	return r.db
+}
+
+func (r *exportTemplateRepo) ExecuteQuery(ctx context.Context, dbName, sql string, args ...interface{}) ([]map[string]interface{}, error) {
+	var result []map[string]interface{}
+	if err := r.db.WithContext(ctx).Raw(sql, args...).Scan(&result).Error; err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (r *exportTemplateRepo) GetColumnTypes(ctx context.Context, dbName, tableName string) ([]string, error) {
+	columns, err := r.db.Migrator().ColumnTypes(tableName)
+	if err != nil {
+		return nil, err
+	}
+	result := make([]string, len(columns))
+	for i, col := range columns {
+		result[i] = col.Name()
+	}
+	return result, nil
+}
+
+func (r *exportTemplateRepo) HasDeletedAtColumn(ctx context.Context, tableName string) bool {
+	var count int64
+	r.db.Raw("SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ? AND COLUMN_NAME = 'deleted_at'", tableName).Count(&count)
+	return count > 0
+}
+
+func (r *exportTemplateRepo) ImportData(ctx context.Context, dbName, tableName string, items []map[string]interface{}) error {
+	return r.db.WithContext(ctx).Table(tableName).CreateInBatches(&items, 1000).Error
+}
+
+// 转换函数
+func toModelExportTemplate(t *system.ExportTemplate) *model.SysExportTemplate {
+	var limit int64
+	if t.Limit != nil {
+		limit = int64(*t.Limit)
+	}
+	return &model.SysExportTemplate{
+		ID:           int64(t.ID),
+		DbName:       t.DBName,
+		Name:         t.Name,
+		TblName:      t.TableName,
+		TemplateID:   t.TemplateID,
+		TemplateInfo: t.TemplateInfo,
+		Limit:        limit,
+		Order:        t.Order,
+	}
+}
+
+func toBizExportTemplate(m *model.SysExportTemplate, conditions []model.SysExportTemplateCondition, joins []model.SysExportTemplateJoin) *system.ExportTemplate {
+	limit := int(m.Limit)
+	t := &system.ExportTemplate{
+		ID:           uint(m.ID),
+		DBName:       m.DbName,
+		Name:         m.Name,
+		TableName:    m.TblName,
+		TemplateID:   m.TemplateID,
+		TemplateInfo: m.TemplateInfo,
+		Limit:        &limit,
+		Order:        m.Order,
+		CreatedAt:    m.CreatedAt,
+		UpdatedAt:    m.UpdatedAt,
+	}
+
+	// 转换条件
+	t.Conditions = make([]*system.Condition, len(conditions))
+	for i, c := range conditions {
+		t.Conditions[i] = &system.Condition{
+			ID:         uint(c.ID),
+			TemplateID: c.TemplateID,
+			From:       c.From,
+			Column:     c.Column,
+			Operator:   c.Operator,
+		}
+	}
+
+	// 转换关联
+	t.JoinTemplate = make([]*system.JoinTemplate, len(joins))
+	for i, j := range joins {
+		t.JoinTemplate[i] = &system.JoinTemplate{
+			ID:         uint(j.ID),
+			TemplateID: j.TemplateID,
+			Joins:      j.Joins,
+			Table:      j.TblName,
+			On:         j.On,
+		}
+	}
+
+	return t
+}
+
+func toBizExportTemplateSimple(m *model.SysExportTemplate) *system.ExportTemplate {
+	limit := int(m.Limit)
+	return &system.ExportTemplate{
+		ID:           uint(m.ID),
+		DBName:       m.DbName,
+		Name:         m.Name,
+		TableName:    m.TblName,
+		TemplateID:   m.TemplateID,
+		TemplateInfo: m.TemplateInfo,
+		Limit:        &limit,
+		Order:        m.Order,
+		CreatedAt:    m.CreatedAt,
+		UpdatedAt:    m.UpdatedAt,
+	}
+}

internal/data/system/version.go

@@ -0,0 +1,103 @@
+package system
+
+import (
+	"context"
+	"strconv"
+
+	"kra/internal/biz/system"
+	"kra/internal/data/model"
+	"kra/internal/data/query"
+
+	"gorm.io/gorm"
+)
+
+type versionRepo struct {
+	db *gorm.DB
+}
+
+// NewVersionRepo 创建版本仓储
+func NewVersionRepo(db *gorm.DB) system.VersionRepo {
+	return &versionRepo{db: db}
+}
+
+func (r *versionRepo) Create(ctx context.Context, version *system.SysVersion) error {
+	m := &model.SysVersion{
+		VersionName: version.VersionName,
+		VersionCode: version.VersionCode,
+		Description: version.Description,
+		VersionData: version.VersionData,
+	}
+	return query.SysVersion.WithContext(ctx).Create(m)
+}
+
+func (r *versionRepo) Delete(ctx context.Context, id string) error {
+	idInt, _ := strconv.ParseInt(id, 10, 64)
+	_, err := query.SysVersion.WithContext(ctx).Where(query.SysVersion.ID.Eq(idInt)).Delete()
+	return err
+}
+
+func (r *versionRepo) DeleteByIds(ctx context.Context, ids []string) error {
+	idList := make([]int64, len(ids))
+	for i, id := range ids {
+		idList[i], _ = strconv.ParseInt(id, 10, 64)
+	}
+	_, err := query.SysVersion.WithContext(ctx).Where(query.SysVersion.ID.In(idList...)).Delete()
+	return err
+}
+
+func (r *versionRepo) GetById(ctx context.Context, id string) (*system.SysVersion, error) {
+	idInt, _ := strconv.ParseInt(id, 10, 64)
+	m, err := query.SysVersion.WithContext(ctx).Where(query.SysVersion.ID.Eq(idInt)).First()
+	if err != nil {
+		return nil, err
+	}
+	return toBizVersion(m), nil
+}
+
+func (r *versionRepo) GetList(ctx context.Context, req *system.VersionSearchReq) ([]*system.SysVersion, int64, error) {
+	q := query.SysVersion.WithContext(ctx).Order(query.SysVersion.CreatedAt.Desc())
+
+	// 条件搜索
+	if len(req.CreatedAtRange) == 2 {
+		q = q.Where(query.SysVersion.CreatedAt.Between(req.CreatedAtRange[0], req.CreatedAtRange[1]))
+	}
+	if req.VersionName != nil && *req.VersionName != "" {
+		q = q.Where(query.SysVersion.VersionName.Like("%" + *req.VersionName + "%"))
+	}
+	if req.VersionCode != nil && *req.VersionCode != "" {
+		q = q.Where(query.SysVersion.VersionCode.Eq(*req.VersionCode))
+	}
+
+	total, err := q.Count()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if req.PageSize > 0 {
+		offset := req.PageSize * (req.Page - 1)
+		q = q.Limit(req.PageSize).Offset(offset)
+	}
+
+	list, err := q.Find()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	result := make([]*system.SysVersion, len(list))
+	for i, m := range list {
+		result[i] = toBizVersion(m)
+	}
+	return result, total, nil
+}
+
+func toBizVersion(m *model.SysVersion) *system.SysVersion {
+	return &system.SysVersion{
+		ID:          m.ID,
+		VersionName: m.VersionName,
+		VersionCode: m.VersionCode,
+		Description: m.Description,
+		VersionData: m.VersionData,
+		CreatedAt:   m.CreatedAt,
+		UpdatedAt:   m.UpdatedAt,
+	}
+}