kra-new/internal/data/system/version.go

package system

import (
	"context"
	"kra/internal/biz/system"
	"sort"
	"time"

	"kra/pkg/database/pagination"

	"gorm.io/gorm"
)

type versionPO struct {
	ID          uint `gorm:"primaryKey"`
	CreatedAt   time.Time
	UpdatedAt   time.Time
	DeletedAt   gorm.DeletedAt `gorm:"index"`
	Name        *string        `gorm:"column:version_name"`
	Code        *string        `gorm:"column:version_code"`
	Description *string
	Data        *string `gorm:"column:version_data;type:text"`
}

func (versionPO) TableName() string { return "sys_versions" }

type versionRepo struct{ data Provider }

func NewVersionRepo(data Provider) system.VersionRepo { return &versionRepo{data: data} }
func versionFromPO(v versionPO) *system.Version {
	return &system.Version{ID: v.ID, CreatedAt: v.CreatedAt, UpdatedAt: v.UpdatedAt, Name: v.Name, Code: v.Code, Description: v.Description, Data: v.Data}
}
func (r *versionRepo) CreateVersion(ctx context.Context, v *system.Version) error {
	po := versionPO{Name: v.Name, Code: v.Code, Description: v.Description, Data: v.Data}
	if err := r.data.DB().WithContext(ctx).Create(&po).Error; err != nil {
		return err
	}
	v.ID = po.ID
	return nil
}
func (r *versionRepo) DeleteVersions(ctx context.Context, ids []uint) error {
	return r.data.DB().WithContext(ctx).Where("id IN ?", ids).Delete(&versionPO{}).Error
}
func (r *versionRepo) FindVersion(ctx context.Context, id uint) (*system.Version, error) {
	var po versionPO
	if err := r.data.DB().WithContext(ctx).First(&po, id).Error; err != nil {
		return nil, err
	}
	return versionFromPO(po), nil
}
func (r *versionRepo) ListVersions(ctx context.Context, page, size int, name, code string, createdAtRange []*time.Time) ([]*system.Version, int64, error) {
	db := r.data.DB().WithContext(ctx).Model(&versionPO{})
	if len(createdAtRange) == 2 && createdAtRange[0] != nil && createdAtRange[1] != nil {
		db = db.Where("created_at BETWEEN ? AND ?", createdAtRange[0], createdAtRange[1])
	}
	if name != "" {
		db = db.Where("version_name LIKE ?", "%"+name+"%")
	}
	if code != "" {
		db = db.Where("version_code = ?", code)
	}
	db = db.Order("id desc")
	var total int64
	if err := db.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	var pos []versionPO
	if err := pagination.Apply(db, page, size, 100).Find(&pos).Error; err != nil {
		return nil, 0, err
	}
	out := make([]*system.Version, 0, len(pos))
	for _, po := range pos {
		out = append(out, versionFromPO(po))
	}
	return out, total, nil
}
func (r *versionRepo) BuildVersionBundle(ctx context.Context, menuIDs, apiIDs, dictIDs []uint) (*system.VersionBundle, error) {
	bundle := &system.VersionBundle{}
	var menus []menuPO
	if len(menuIDs) > 0 {
		if err := r.data.DB().WithContext(ctx).Where("id IN ?", menuIDs).Order("sort,id").Find(&menus).Error; err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageMenus, Err: err}
		}
	}
	byID := map[uint]*system.Menu{}
	for _, po := range menus {
		v := menuFromPO(po)
		byID[po.ID] = v
	}
	if len(menuIDs) > 0 {
		var buttons []menuButtonPO
		if err := r.data.DB().WithContext(ctx).Where("sys_base_menu_id IN ?", menuIDs).Find(&buttons).Error; err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageMenus, Err: err}
		}
		for _, button := range buttons {
			if menu := byID[button.MenuID]; menu != nil {
				menu.Buttons = append(menu.Buttons, &system.MenuButton{Name: button.Name, Description: button.Description})
			}
		}
		var parameters []menuParameterPO
		if err := r.data.DB().WithContext(ctx).Where("sys_base_menu_id IN ?", menuIDs).Find(&parameters).Error; err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageMenus, Err: err}
		}
		for _, parameter := range parameters {
			if menu := byID[parameter.MenuID]; menu != nil {
				menu.Parameters = append(menu.Parameters, &system.MenuParameter{Type: parameter.Type, Key: parameter.Key, Value: parameter.Value})
			}
		}
	}
	for _, po := range menus {
		v := byID[po.ID]
		if parent := byID[po.ParentID]; parent != nil {
			parent.Children = append(parent.Children, v)
		} else if po.ParentID == 0 {
			bundle.Menus = append(bundle.Menus, v)
		}
	}
	var sortMenus func([]*system.Menu)
	sortMenus = func(items []*system.Menu) {
		sort.Slice(items, func(i, j int) bool { return items[i].Sort < items[j].Sort })
		for _, item := range items {
			sortMenus(item.Children)
		}
	}
	sortMenus(bundle.Menus)
	var cleanMenu func(*system.Menu)
	cleanMenu = func(menu *system.Menu) {
		menu.ID = 0
		menu.ParentID = 0
		for _, button := range menu.Buttons {
			button.ID = 0
			button.MenuID = 0
			button.AuthorityID = 0
		}
		for _, parameter := range menu.Parameters {
			parameter.ID = 0
			parameter.MenuID = 0
		}
		for _, child := range menu.Children {
			cleanMenu(child)
		}
	}
	for _, menu := range bundle.Menus {
		cleanMenu(menu)
	}
	var apis []apiPO
	if len(apiIDs) > 0 {
		if err := r.data.DB().WithContext(ctx).Where("id IN ?", apiIDs).Find(&apis).Error; err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageAPIs, Err: err}
		}
	}
	for _, po := range apis {
		v := apiFromPO(po)
		v.ID = 0
		bundle.APIs = append(bundle.APIs, v)
	}
	var dictionaries []dictionaryPO
	if len(dictIDs) > 0 {
		if err := r.data.DB().WithContext(ctx).Where("id IN ?", dictIDs).Find(&dictionaries).Error; err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageDictionaries, Err: err}
		}
	}
	dictionariesRepo := &dictionaryRepo{data: r.data}
	for _, po := range dictionaries {
		v := dictionaryFromPO(po)
		v.ID = 0
		details, _, err := dictionariesRepo.ListDictionaryDetails(ctx, 0, 0, system.DictionaryDetailFilter{DictionaryID: po.ID})
		if err != nil {
			return nil, &system.VersionStageError{Stage: system.VersionStageDictionaries, Err: err}
		}
		for _, d := range details {
			d.ID = 0
			d.DictionaryID = 0
			d.ParentID = nil
			d.Path = ""
			d.Level = 0
		}
		v.Details = details
		bundle.Dictionaries = append(bundle.Dictionaries, v)
	}
	return bundle, nil
}
func (r *versionRepo) ImportVersionBundle(ctx context.Context, b *system.VersionBundle, audit *system.Version) error {
	return r.data.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		if len(b.Menus) > 0 {
			if err := importVersionMenus(tx, b.Menus, 0); err != nil {
				return &system.VersionStageError{Stage: system.VersionStageMenus, Err: err}
			}
		}
		if len(b.APIs) > 0 {
			if err := importVersionAPIs(tx, b.APIs); err != nil {
				return &system.VersionStageError{Stage: system.VersionStageAPIs, Err: err}
			}
		}
		if len(b.Dictionaries) > 0 {
			if err := importVersionDictionaries(tx, b.Dictionaries); err != nil {
				return &system.VersionStageError{Stage: system.VersionStageDictionaries, Err: err}
			}
		}
		if audit != nil {
			po := versionPO{Name: audit.Name, Code: audit.Code, Description: audit.Description, Data: audit.Data}
			if err := tx.Create(&po).Error; err != nil {
				return &system.VersionStageError{Stage: system.VersionStageSave, Err: err}
			}
			audit.ID = po.ID
		}
		return nil
	})
}

func importVersionMenus(tx *gorm.DB, items []*system.Menu, parentID uint) error {
	for _, item := range items {
		var existing menuPO
		if err := tx.Where("name = ? AND path = ?", item.Name, item.Path).First(&existing).Error; err == nil {
			if err = importVersionMenus(tx, item.Children, existing.ID); err != nil {
				return err
			}
			continue
		}
		po := menuToPO(item)
		po.ID = 0
		po.ParentID = parentID
		if err := tx.Create(&po).Error; err != nil {
			return err
		}
		for _, parameter := range item.Parameters {
			if err := tx.Create(&menuParameterPO{MenuID: po.ID, Type: parameter.Type, Key: parameter.Key, Value: parameter.Value}).Error; err != nil {
				return err
			}
		}
		for _, button := range item.Buttons {
			if err := tx.Create(&menuButtonPO{Name: button.Name, Description: button.Description, MenuID: po.ID}).Error; err != nil {
				return err
			}
		}
		if err := importVersionMenus(tx, item.Children, po.ID); err != nil {
			return err
		}
	}
	return nil
}

func importVersionAPIs(tx *gorm.DB, items []*system.API) error {
	for _, item := range items {
		var existing apiPO
		if err := tx.Where("path = ? AND method = ?", item.Path, item.Method).First(&existing).Error; err == nil {
			continue
		}
		if err := tx.Create(&apiPO{Path: item.Path, Description: item.Description, APIGroup: item.APIGroup, Method: item.Method}).Error; err != nil {
			return err
		}
	}
	return nil
}

func importVersionDictionaries(tx *gorm.DB, items []*system.Dictionary) error {
	for _, item := range items {
		var existing dictionaryPO
		if err := tx.Where("type = ?", item.Type).First(&existing).Error; err == nil {
			continue
		}
		po := dictionaryPO{Name: item.Name, Type: item.Type, Status: item.Status, Desc: item.Desc}
		if err := tx.Create(&po).Error; err != nil {
			return err
		}
		for _, detail := range item.Details {
			value := dictionaryDetailPO{Label: detail.Label, Value: detail.Value, Extend: detail.Extend, Status: detail.Status, Sort: detail.Sort, DictionaryID: po.ID}
			if err := tx.Create(&value).Error; err != nil {
				return err
			}
		}
	}
	return nil
}