eta_api/models/data_manage/chart_framework.go

package data_manage

import (
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
)

// ChartFramework 图库框架表
type ChartFramework struct {
	ChartFrameworkId int       `gorm:"column(chart_framework_id);primaryKey" description:"框架ID"`
	FrameworkCode    string    `gorm:"column(framework_code)" description:"框架唯一编码"`
	FrameworkName    string    `gorm:"column(framework_name)" description:"框架名称"`
	FrameworkImg     string    `gorm:"column(framework_img)" description:"框架图片"`
	FrameworkContent string    `gorm:"column(framework_content)" description:"框架内容"`
	IsPublic         int       `gorm:"column(is_public)" description:"是否公开：0-私有；1-公开"`
	PublicTime       time.Time `gorm:"column(public_time)" description:"公开时间"`
	Sort             int       `gorm:"column(sort)" description:"排序"`
	AdminId          int       `gorm:"column(admin_id)" description:"创建人ID"`
	AdminName        string    `gorm:"column(admin_name)" description:"创建人姓名"`
	CreateTime       time.Time `gorm:"column(create_time)" description:"创建时间"`
	ModifyTime       time.Time `gorm:"column(modify_time)" description:"更新时间"`
}

func (m *ChartFramework) TableName() string {
	return "chart_framework"
}

func (m *ChartFramework) PrimaryId() string {
	return ChartFrameworkColumns.ChartFrameworkId
}

var ChartFrameworkColumns = struct {
	ChartFrameworkId string
	FrameworkCode    string
	FrameworkName    string
	FrameworkImg     string
	FrameworkContent string
	IsPublic         string
	PublicTime       string
	Sort             string
	AdminId          string
	AdminName        string
	CreateTime       string
	ModifyTime       string
}{
	ChartFrameworkId: "chart_framework_id",
	FrameworkCode:    "framework_code",
	FrameworkName:    "framework_name",
	FrameworkImg:     "framework_img",
	FrameworkContent: "framework_content",
	IsPublic:         "is_public",
	PublicTime:       "public_time",
	Sort:             "sort",
	AdminId:          "admin_id",
	AdminName:        "admin_name",
	CreateTime:       "create_time",
	ModifyTime:       "modify_time",
}

// Create 创建单个 ChartFramework 记录
func (m *ChartFramework) Create() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Create(m).Error
	return
}

// CreateMulti 批量创建 ChartFramework 记录
func (m *ChartFramework) CreateMulti(items []*ChartFramework) (err error) {
	if len(items) == 0 {
		return
	}
	o := global.DbMap[utils.DbNameIndex]
	err = o.CreateInBatches(items, utils.MultiAddNum).Error
	return
}

// Update 更新指定字段的 ChartFramework 记录
func (m *ChartFramework) Update(cols []string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	err = o.Model(m).Select(cols).Updates(m).Error
	return
}

// Del 删除单个 ChartFramework 记录
func (m *ChartFramework) Del() (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.PrimaryId())
	err = o.Exec(sql, m.ChartFrameworkId).Error
	return
}

// GetItemById 根据ID获取单个 ChartFramework 记录
func (m *ChartFramework) GetItemById(id int) (item *ChartFramework, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.PrimaryId())
	err = o.Raw(sql, id).First(&item).Error
	return
}

// GetItemByCondition 根据条件获取单个 ChartFramework 记录
func (m *ChartFramework) GetItemByCondition(condition string, pars []interface{}) (item *ChartFramework, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 %s LIMIT 1`, m.TableName(), condition)
	err = o.Raw(sql, pars...).First(&item).Error
	return
}

// GetCountByCondition 根据条件获取 ChartFramework 记录数量
func (m *ChartFramework) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
	err = o.Raw(sql, pars...).Scan(&count).Error
	return
}

// GetItemsByCondition 根据条件获取多条 ChartFramework 记录
func (m *ChartFramework) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*ChartFramework, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := `ORDER BY create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
	err = o.Raw(sql, pars...).Find(&items).Error
	return
}

// GetPageItemsByCondition 根据条件分页获取 ChartFramework 记录
func (m *ChartFramework) GetPageItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string, startSize, pageSize int) (items []*ChartFramework, err error) {
	o := global.DbMap[utils.DbNameIndex]
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := `ORDER BY create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s LIMIT ?,?`, fields, m.TableName(), condition, order)
	err = o.Raw(sql, append(pars, startSize, pageSize)...).Find(&items).Error
	return
}

func (m *ChartFramework) CreateFrameworkAndNodes(item *ChartFramework, nodes []*ChartFrameworkNode) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	err = tx.Create(item).Error
	if err != nil {
		err = fmt.Errorf("insert framework err: %s", err.Error())
		return
	}
	newId := item.ChartFrameworkId

	if len(nodes) > 0 {
		for _, n := range nodes {
			n.ChartFrameworkId = newId
		}
		err = tx.CreateInBatches(nodes, utils.MultiAddNum).Error
		if err != nil {
			err = fmt.Errorf("insert multi nodes err: %s", err.Error())
			return
		}
	}
	return
}

func (m *ChartFramework) EditFrameworkAndNodes(item *ChartFramework, updateCols []string, nodes []*ChartFrameworkNode) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	err = tx.Model(item).Select(updateCols).Updates(item).Error
	if err != nil {
		err = fmt.Errorf("framework update err: %s", err.Error())
		return
	}

	sql := `DELETE FROM chart_framework_node WHERE chart_framework_id = ?`
	err = tx.Exec(sql, item.ChartFrameworkId).Error
	if err != nil {
		err = fmt.Errorf("clear nodes err: %s", err.Error())
		return
	}
	if len(nodes) > 0 {
		err = tx.CreateInBatches(nodes, utils.MultiAddNum).Error
		if err != nil {
			err = fmt.Errorf("insert multi nodes err: %s", err.Error())
			return
		}
	}
	return
}

func (m *ChartFramework) RemoveFrameworkAndNodes(frameworkId int) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	tx := o.Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), m.PrimaryId())
	err = tx.Exec(sql, frameworkId).Error
	if err != nil {
		err = fmt.Errorf("delete framework err: %s", err.Error())
		return
	}

	sql = `DELETE FROM chart_framework_node WHERE chart_framework_id = ?`
	err = tx.Exec(sql, frameworkId).Error
	if err != nil {
		err = fmt.Errorf("clear nodes err: %s", err.Error())
		return
	}
	return
}

// ChartFrameworkAddReq 图库框架新增请求体
type ChartFrameworkAddReq struct {
	FrameworkName    string                  `description:"框架名称"`
	FrameworkImg     string                  `description:"框架图片"`
	FrameworkContent string                  `description:"框架内容"`
	Nodes            []ChartFrameworkNodeReq `description:"框架节点"`
}

// ChartFrameworkNodeReq 图库框架节点请求体
type ChartFrameworkNodeReq struct {
	MyChartClassifyId int    `description:"我的图表分类ID"`
	NodeId            string `description:"节点ID"`
	NodeName          string `description:"节点名称"`
}

// ChartFrameworkEditReq 图库框架编辑请求体
type ChartFrameworkEditReq struct {
	ChartFrameworkId int `description:"图库框架ID"`
	ChartFrameworkAddReq
}

// ChartFrameworkRemoveReq 图库框架移除请求体
type ChartFrameworkRemoveReq struct {
	ChartFrameworkId int `description:"图库框架ID"`
}

// ChartFrameworkRenameReq 图库框架重命名请求体
type ChartFrameworkRenameReq struct {
	ChartFrameworkId int    `description:"图库框架ID"`
	FrameworkName    string `description:"框架名称"`
}

// ChartFrameworkEditPublicReq 图库框架编辑公开请求体
type ChartFrameworkEditPublicReq struct {
	ChartFrameworkId int `description:"图库框架ID"`
	IsPublic         int `description:"0-隐藏公开; 1-公开"`
}

// ChartFrameworkMoveReq 图库框架移动排序请求体
type ChartFrameworkMoveReq struct {
	ChartFrameworkId     int `description:"图库框架ID"`
	PrevChartFrameworkId int `description:"上一个框架ID"`
	NextChartFrameworkId int `description:"下一个框架ID"`
}

// UpdateChartFrameworkSort 更新我的图库框架排序
func UpdateChartFrameworkSort(adminId, frameworkId, current int, updates string) (err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := fmt.Sprintf(`UPDATE chart_framework SET sort = %s WHERE admin_id = ? and sort > ?`, updates)
	if frameworkId > 0 {
		sql += ` OR (chart_framework_id > ` + strconv.Itoa(frameworkId) + ` AND sort = ` + strconv.Itoa(current) + `)`
	}
	err = o.Exec(sql, adminId, current).Error
	return
}

// GetFirstChartFramework 获取我的图库框架排首位的数据
func GetFirstChartFramework(adminId int) (item *ChartFramework, err error) {
	o := global.DbMap[utils.DbNameIndex]
	sql := `SELECT * FROM chart_framework WHERE admin_id = ? ORDER BY sort ASC,chart_framework_id ASC LIMIT 1`
	err = o.Raw(sql, adminId).First(&item).Error
	return
}

// ChartFrameworkItem 图库框架表信息
type ChartFrameworkItem struct {
	ChartFrameworkId int                       `description:"框架ID"`
	FrameworkCode    string                    `description:"框架唯一编码"`
	FrameworkName    string                    `description:"框架名称"`
	FrameworkImg     string                    `description:"框架图片"`
	FrameworkContent string                    `description:"框架内容"`
	IsPublic         int                       `description:"是否公开：0-私有；1-公开"`
	PublicTime       string                    `description:"公开时间"`
	Sort             int                       `description:"排序"`
	AdminId          int                       `description:"创建人ID"`
	AdminName        string                    `description:"创建人姓名"`
	CreateTime       string                    `description:"创建时间"`
	ModifyTime       string                    `description:"更新时间"`
	Nodes            []*ChartFrameworkNodeItem `description:"框架节点"`
}

// FormatChartFramework2Item 格式化框架信息
func FormatChartFramework2Item(origin *ChartFramework, nodes []*ChartFrameworkNodeItem) (item *ChartFrameworkItem) {
	if origin == nil {
		return
	}
	item = new(ChartFrameworkItem)
	item.ChartFrameworkId = origin.ChartFrameworkId
	item.FrameworkCode = origin.FrameworkCode
	item.FrameworkName = origin.FrameworkName
	item.FrameworkImg = origin.FrameworkImg
	item.FrameworkContent = origin.FrameworkContent
	item.IsPublic = origin.IsPublic
	item.PublicTime = utils.TimeTransferString(utils.FormatDateTime, origin.PublicTime)
	item.Sort = origin.Sort
	item.AdminId = origin.AdminId
	item.AdminName = origin.AdminName
	item.CreateTime = utils.TimeTransferString(utils.FormatDateTime, origin.CreateTime)
	item.ModifyTime = utils.TimeTransferString(utils.FormatDateTime, origin.ModifyTime)
	item.Nodes = nodes
	return
}

// ChartFrameworkPublicMenuItem 公开框架目录
type ChartFrameworkPublicMenuItem struct {
	AdminId    int                   `description:"创建人ID"`
	MenuName   string                `description:"目录名称"`
	Frameworks []*ChartFrameworkItem `description:"框架列表"`
}

// ChartFrameworkListResp 图库框架分页列表
type ChartFrameworkListResp struct {
	Paging *paging.PagingItem
	List   []*ChartFrameworkItem
}