eta_api/models/knowledge/knowledge_classify.go

package knowledge

import (
	"eta_gn/eta_api/global"
	"eta_gn/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"time"
)

type KnowledgeClassify struct {
	ClassifyId   int       `gorm:"primaryKey;autoIncrement;column:classify_id"`
	ClassifyName string    `gorm:"column:classify_name;default:'';type:varchar(125);not null"` // 注意：varchar的默认长度可能需要根据实际情况调整
	Sort         int       `gorm:"column:sort;default:0;type:tinyint"`
	ParentId     int       `gorm:"column:parent_id;default:0;type:int"`
	CreateTime   time.Time `gorm:"column:create_time;default:CURRENT_TIMESTAMP"`
	ModifyTime   time.Time `gorm:"column:modify_time;default:CURRENT_TIMESTAMP"`
	Enabled      int       `gorm:"column:enabled;default:1;type:tinyint"`
	Level        int       `gorm:"column:level;default:0;type:bigint"`
	ResourceType int       `gorm:"column:resource_type;default:0;not null;type:tinyint"`
	HasChild     int       `gorm:"column:has_child;default:0;type:int"`
}

func (k *KnowledgeClassify) TableName() string {
	return "knowledge_classify"
}

func (k *KnowledgeClassify) GetPrimaryKey() string {
	return "classify_id"
}

func (k *KnowledgeClassify) GetClassifyByName(classifyName string, parentId, resourceType int) (item *KnowledgeClassify, err error) {
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE classify_name=? AND parent_id=? AND resource_type=?`, k.TableName())
	err = global.DmSQL["rddp"].Raw(sql, classifyName, parentId, resourceType).First(&item).Error
	return
}

func (k *KnowledgeClassify) GetClassifyById(classifyId int) (item *KnowledgeClassify, err error) {
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s=? `, k.TableName(), k.GetPrimaryKey())
	err = global.DmSQL["rddp"].Raw(sql, classifyId).First(&item).Error
	return
}

// 添加分类
func (k *KnowledgeClassify) Add(item *KnowledgeClassify) (err error) {
	err = global.DmSQL["rddp"].Create(item).Error
	return
}

func (k *KnowledgeClassify) GetReportCountByClassifyId(classifyId int) (count int, err error) {
	sql := `SELECT COUNT(1) as num FROM knowledge_resource WHERE classify_id=? `
	err = global.DmSQL["rddp"].Raw(sql, classifyId).First(&count).Error
	return
}

func (k *KnowledgeClassify) GetClassifySubCountByClassifyId(classifyId int) (count int, err error) {

	sql := `SELECT COUNT(1) as num FROM knowledge_classify AS a
        INNER JOIN knowledge_resource AS b ON a.id=b.classify_id_second
        WHERE a.parent_id=? `
	//o := orm.NewOrmUsingDB("rddp")
	//err = o.Raw(sql, classifyId).QueryRow(&count)
	err = global.DmSQL["rddp"].Raw(sql, classifyId).First(&count).Error
	return
}

func (k *KnowledgeClassify) GetClassifySubCountByParentId(classifyId int) (count int, err error) {
	sqlCount := `
	SELECT COUNT(1) as num FROM knowledge_classify AS a
	WHERE a.parent_id=? `
	//o := orm.NewOrmUsingDB("rddp")
	//err = o.Raw(sqlCount, classifyId).QueryRow(&count)
	err = global.DmSQL["rddp"].Raw(sqlCount, classifyId).Scan(&count).Error
	return
}

// 删除分类
func (k *KnowledgeClassify) Delete(classifyId int) (err error) {
	sql := `DELETE FROM knowledge_classify WHERE classify_id =? `
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, classifyId).Exec()
	err = global.DmSQL["rddp"].Exec(sql, classifyId).Error
	if err != nil {
		return
	}
	return
}

type KnowledgeClassifyItem struct {
	KnowledgeClassify
	Child []*KnowledgeClassifyItem `gorm:"-"`
}

type KnowledgeClassifyListResp struct {
	List []*KnowledgeClassifyItem
}

type ClassifyPermissionListResp struct {
	List   []*KnowledgeClassifyItem
	Paging *paging.PagingItem `description:"分页数据"`
}

// 获取分类列表
func (k *KnowledgeClassify) GetClassifyList(keyWord string, enabled int) (items []*KnowledgeClassifyItem, err error) {
	sql := ``
	companyTypeSqlStr := ``
	if enabled == 1 {
		companyTypeSqlStr += ` AND enabled = 1 `
	}
	pars := make([]interface{}, 0)
	if keyWord != "" {
		sql = `SELECT * FROM (
                   SELECT * FROM classify
                   WHERE parent_id=0 ` + companyTypeSqlStr + `  AND classify_name LIKE ?
                   UNION
                   SELECT * FROM classify
                   WHERE classify_id IN( SELECT parent_id FROM classify
                   WHERE parent_id>0 ` + companyTypeSqlStr + `  AND classify_name LIKE ? )
                   )AS t
                   ORDER BY sort ASC,create_time ASC`
		pars = utils.GetLikeKeywordPars(pars, keyWord, 2)
	} else {
		sql = `SELECT * FROM knowledge_classify WHERE parent_id=0 ` + companyTypeSqlStr

		sql += ` ORDER BY sort ASC, create_time ASC`
	}
	pars = append(pars)

	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, pars...).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, pars).Find(&items).Error
	return
}

func (k *KnowledgeClassify) GetClassifyListCount(keyWord, companyType string, hideDayWeek int) (count int, err error) {
	sqlCount := ``
	pars := make([]interface{}, 0)

	if keyWord != "" {
		sqlCount = `SELECT  COUNT(1) AS count FROM (
               SELECT * FROM classify
               WHERE parent_id=0  AND classify_name LIKE ?
               UNION
               SELECT * FROM classify
               WHERE classify_id IN(SELECT parent_id FROM classify
               WHERE parent_id>0 AND classify_name LIKE ? )
               )AS t `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 2)
	} else {
		sqlCount = `SELECT COUNT(1) AS count FROM knowledge_classify WHERE parent_id=0 `
		if hideDayWeek == 1 {
			sqlCount += ` AND classify_name <> '晨报' AND classify_name <> '周报' `
		}
	}
	//o := orm.NewOrmUsingDB("rddp")
	//err = o.Raw(sqlCount, pars...).QueryRow(&count)
	err = global.DmSQL["rddp"].Raw(sqlCount, pars...).Scan(&count).Error
	return
}

type CheckDeleteClassifyReq struct {
	ClassifyId int `description:"分类ID"`
}

type CheckDeleteClassifyResp struct {
	Code int    `description:"编码：0:检测成功，可进行删除,1：分类不存在，2：该分类有关联报告，不允许删除,3:二级分类有关联报告，不允许删除,4:该分类下有关联分类，是否确认全部删除"`
	Msg  string `description:"描述信息"`
}

type ClassifyAddReq struct {
	ClassifyName string `description:"分类名称"`
	ParentId     int    `description:"父级分类id，没有父级分类传0"`
	ResourceType int    `description:"分类类型：0事件库，1政策库，2观点库，3知识库"`
}

type DeleteClassifyReq struct {
	ClassifyId int `description:"分类ID"`
}

type EditClassifyReq struct {
	ClassifyId int `description:"分类ID"`
	ClassifyAddReq
}

type FindByIdClassifyReq struct {
	ClassifyId int `description:"分类ID"`
}

func (k *KnowledgeClassify) GetClassifyChild(parentId int, keyWord string) (items []*KnowledgeClassify, err error) {
	sql := ``
	pars := make([]interface{}, 0)
	if keyWord != "" {
		sql = `SELECT * FROM knowledge_classify WHERE classify_name LIKE ? AND parent_id=? ORDER BY create_time ASC `
		pars = append(pars, utils.GetLikeKeyword(keyWord))
	} else {
		sql = `SELECT * FROM knowledge_classify WHERE parent_id=? ORDER BY create_time ASC `
	}
	pars = append(pars, parentId)
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, pars...).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

func (k *KnowledgeClassify) GetClassifyChildByParentIds(parentId []int, keyWord string, enabled int) (items []*KnowledgeClassify, err error) {
	parentIdLen := len(parentId)
	if parentIdLen == 0 {
		return
	}

	sql := ``
	pars := make([]interface{}, 0)
	pars = append(pars, parentId)
	if keyWord != "" {
		sql = `SELECT * FROM knowledge_classify WHERE parent_id IN (` + utils.GetOrmInReplace(parentIdLen) + `) AND classify_name LIKE ? `
		pars = append(pars, utils.GetLikeKeyword(keyWord))
	} else {
		sql = `SELECT * FROM knowledge_classify WHERE parent_id IN (` + utils.GetOrmInReplace(parentIdLen) + `) `
	}

	if enabled == 1 {
		sql += ` AND enabled=1 `
	}
	sql += ` ORDER BY create_time ASC `
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, pars...).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

// EditClassifyPermissionReq 编辑分类权限请求
type EditClassifyPermissionReq struct {
	ClassifyId            int   `description:"分类ID"`
	ChartPermissionIdList []int `description:"权限id数组"`
}

// GetAllClassify 获取所有分类
func (k *KnowledgeClassify) GetAllClassify() (list []*KnowledgeClassify, err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := ` SELECT * FROM classify `
	//_, err = o.Raw(sql).QueryRows(&list)
	sql := ` SELECT * FROM knowledge_classify `
	err = global.DmSQL["rddp"].Raw(sql).Find(&list).Error
	return
}

// GetClassifyByKeyword 名称获取分类
func (k *KnowledgeClassify) GetClassifyByKeyword(keyword string) (item *KnowledgeClassify, err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := ` SELECT * FROM knowledge_classify WHERE classify_name = ? LIMIT 1 `
	//err = o.Raw(sql, keyword).QueryRow(&item)
	sql := ` SELECT * FROM knowledge_classify WHERE classify_name = ? LIMIT 1 `
	err = global.DmSQL["rddp"].Raw(sql, keyword).Find(&item).Error
	return
}

// UpdateClassify 更新分类
func (k *KnowledgeClassify) Update(cols []string) (err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Update(classifyInfo, cols...)
	err = global.DmSQL["rddp"].Select(cols).Updates(k).Error
	return
}

// SimpleClassifyList 简版分类列表
type SimpleClassifyList struct {
	Id           int    `description:"分类ID"`
	ClassifyName string `description:"分类名称"`
	ParentId     int    `description:"父级ID"`
	Sort         int    `description:"排序"`
	Child        []*SimpleClassifyList
}

// GetClassifyByCondition 获取分类列表
func (k *KnowledgeClassify) GetClassifyByCondition(condition, orderRule string, pars []interface{}) (items []*SimpleClassifyList, err error) {

	sql := `SELECT * FROM knowledge_classify WHERE 1 = 1 `
	if condition != `` {
		sql += condition
	}
	order := `sort ASC, create_time ASC`
	if orderRule != `` {
		order = orderRule
	}
	sql += ` ORDER BY ` + order
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, pars).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

// UpdateChildClassifyRelateSetting 更新子分类关联设置
func (k *KnowledgeClassify) UpdateChildClassifyRelateSetting(parentId, relateTel, relateVideo int) (err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := `UPDATE knowledge_classify SET relate_tel = ?, relate_video = ? WHERE parent_id = ?`
	//_, err = o.Raw(sql, relateTel, relateVideo, parentId).Exec()
	sql := `UPDATE knowledge_classify SET relate_tel = ?, relate_video = ? WHERE parent_id = ?`
	err = global.DmSQL["rddp"].Exec(sql, relateTel, relateVideo, parentId).Error
	return
}

// RelateTelSecClassifyWithPermissions 关联了电话会的二级分类及权限
type RelateTelSecClassifyWithPermissions struct {
	Id                 int    `description:"分类ID"`
	ClassifyName       string `description:"分类名称"`
	ChartPermissionIds string `description:"权限IDs"`
}

// UpdateClassifySortByParentId 根据父类id更新排序
func (k *KnowledgeClassify) UpdateClassifySortByParentId(parentId, permissionId, nowSort int, updateSort string) (err error) {

	sql := ` update knowledge_classify set sort = ` + updateSort + ` WHERE parent_id=? AND sort > ? `
	if permissionId > 0 {
		sql += ` or ( classify_id > ` + fmt.Sprint(permissionId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
	}
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, parentId, nowSort).Exec()
	err = global.DmSQL["rddp"].Exec(sql, parentId, nowSort).Error
	return
}

// GetMaxSortByParentId 获取最大的排序值
func (k *KnowledgeClassify) GetMaxSortByParentId(parentId int) (maxSort int, err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := `SELECT max(sort) AS sort FROM knowledge_classify WHERE parent_id = ? `
	//err = o.Raw(sql, parentId).QueryRow(&maxSort)
	sql := `SELECT max(sort) AS sort FROM knowledge_classify WHERE parent_id = ? `
	err = global.DmSQL["rddp"].Raw(sql, parentId).Scan(&maxSort).Error
	return
}

// GetMaxSort 获取最大的排序值
func (k *KnowledgeClassify) GetMaxSort() (maxSort int, err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := `SELECT max(sort) AS sort FROM classify`
	//err = o.Raw(sql).QueryRow(&maxSort)
	sql := `SELECT max(sort) AS sort FROM classify`
	err = global.DmSQL["rddp"].Raw(sql).Scan(&maxSort).Error
	return
}

// GetFirstClassifyByParentId 获取当前父级分类下，且排序数相同 的排序第一条的数据
func (k *KnowledgeClassify) GetFirstClassifyByParentId(parentId int) (item *KnowledgeClassify, err error) {
	sql := `SELECT * FROM knowledge_classify WHERE parent_id = ? order by sort asc, classify_id asc limit 1`
	err = global.DmSQL["rddp"].Raw(sql, parentId).First(&item).Error
	return
}

type ClassifyMoveReq struct {
	ClassifyId     int `description:"分类ID"`
	PrevClassifyId int `description:"上一个兄弟节点分类id"`
	NextClassifyId int `description:"下一个兄弟节点分类id"`
}

type ClassifySetEnabledReq struct {
	ClassifyId int `description:"分类ID"`
	Enabled    int `description:"是否可用，1可用，0禁用"`
}

func (k *KnowledgeClassify) SetEnabled(id, enabled int) (err error) {
	to := global.DmSQL["rddp"].Begin()
	defer func() {
		if err != nil {
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()
	sql := ` UPDATE knowledge_classify SET enabled =?  WHERE classify_id = ?`
	err = to.Exec(sql, enabled, id).Error
	if err != nil {
		return
	}
	sql = ` UPDATE knowledge_classify SET enabled =?  WHERE parent_id = ?`
	err = to.Exec(sql, enabled, id).Error
	if err != nil {
		return
	}
	return
}

// GetCountClassifyChildByParentId
// @Description: 获取父级分类下子分类数量
// @author: Roc
// @datetime 2024-06-17 10:58:46
// @param parentId int
// @return total int
// @return err error
func (k *KnowledgeClassify) GetCountClassifyChildByParentId(parentId int) (total int, err error) {
	//o := orm.NewOrmUsingDB("rddp")
	//sql := `SELECT count(1) AS total FROM knowledge_classify WHERE parent_id = ? `
	//err = o.Raw(sql, parentId).QueryRow(&total)
	sql := fmt.Sprintf(`SELECT count(1) AS total FROM %s WHERE parent_id = ? `, k.TableName())
	err = global.DmSQL["rddp"].Raw(sql, parentId).Scan(&total).Error
	return
}

// GetClassifyListByKeyword
// @Description: 获取分类列表
// @author: Roc
// @datetime 2024-06-19 09:49:33
// @param keyWord string
// @param enabled int
// @return items []*KnowledgeClassifyList
// @return err error
func (k *KnowledgeClassify) GetClassifyListByKeyword(keyWord string, enabled int) (items []*KnowledgeClassifyItem, err error) {
	sql := ``
	pars := make([]interface{}, 0)

	sql = `SELECT * FROM knowledge_classify WHERE 1=1 `
	if enabled == 1 {
		sql += ` AND enabled = 1 `
	}

	if keyWord != `` {
		sql += ` AND classify_name LIKE ? `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 1)
	}
	sql += ` ORDER BY sort ASC, create_time ASC`

	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, pars).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, pars...).Find(&items).Error
	return
}

// GetClassifyListByParentIdList
// @Description: 获取分类列表
// @author: Roc
// @datetime 2024-06-19 09:49:33
// @param keyWord string
// @param enabled int
// @return items []*KnowledgeClassifyList
// @return err error
func (k *KnowledgeClassify) GetClassifyListByParentIdList(parentClassifyIdList []int) (items []*KnowledgeClassifyItem, err error) {
	num := len(parentClassifyIdList)
	if num <= 0 {
		return
	}
	sql := `SELECT * FROM knowledge_classify WHERE classify_id in (` + utils.GetOrmInReplace(num) + `) ORDER BY sort ASC, create_time ASC`

	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, parentClassifyIdList).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, parentClassifyIdList).Find(&items).Error
	return
}

// GetClassifyListByIdList
// @Description: 根据指标ID列表，获取分类列表
// @author: Roc
// @datetime 2024-06-27 15:23:57
// @param classifyIdList []int
// @return items []*KnowledgeClassify
// @return err error
func (k *KnowledgeClassify) GetClassifyListByIdList(classifyIdList []int) (items []*KnowledgeClassify, err error) {
	num := len(classifyIdList)
	if num <= 0 {
		return
	}
	sql := `SELECT * FROM knowledge_classify WHERE classify_id IN (` + utils.GetOrmInReplace(num) + `) `
	//o := orm.NewOrmUsingDB("rddp")
	//_, err = o.Raw(sql, classifyIdList).QueryRows(&items)
	err = global.DmSQL["rddp"].Raw(sql, classifyIdList).Find(&items).Error
	return
}