eta_api/models/data_manage/data_manage_permission/chart.go

package data_manage_permission

import (
	"eta/eta_api/utils"
	"fmt"
	"github.com/beego/beego/v2/client/orm"
	"strconv"
	"time"
)

// ChartInfoPermission
// @Description: 图表信息权限表
type ChartInfoPermission struct {
	ChartInfoPermissionId int64     `json:"chart_info_permission_id" orm:"column(chart_info_permission_id);pk"`
	ChartInfoId           int32     `json:"chart_info_id"` // 图表id
	Source                int32     `json:"source"`        // 1：ETA图库；2：商品价格曲线；3：相关性图
	SysUserId             int32     `json:"sys_user_id"`   // 系统用户id
	ModifyTime            time.Time `json:"modify_time"`   // 变更时间
	CreateTime            time.Time `json:"create_time"`   // 关系建立时间
}

// ChartClassifyPermission
// @Description: 图表分类权限表
type ChartClassifyPermission struct {
	ChartClassifyPermissionId int64     `json:"chart_classify_permission_id" orm:"column(chart_classify_permission_id);pk"`
	ChartClassifyId           int32     `json:"chart_classify_id"` // 分类id
	Source                    int32     `json:"source"`            // 分类来源: 1-图库; 2-商品价格曲线; 3-相关性图表; 6-拟合方程图表; 7-统计特征
	SysUserId                 int32     `json:"sys_user_id"`       // 系统用户id
	ModifyTime                time.Time `json:"modify_time"`       // 变更时间
	CreateTime                time.Time `json:"create_time"`       // 关系建立时间
}

// SetIsPermissionByChartClassifyIdList
// @Description: 设置图表分类是否涉密
// @author: Roc
// @datetime 2024-04-01 10:53:23
// @param classifyIdList []int
// @param chartClassifySource int
// @return err error
func SetIsPermissionByChartClassifyIdList(classifyIdList []int, chartClassifySource int) (err error) {
	num := len(classifyIdList)
	if num <= 0 {
		return
	}
	o, err := orm.NewOrmUsingDB("data").Begin()
	if err != nil {
		return
	}
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	//// 获取已经配置涉密的分类权限
	//chartClassifyList := make([]*ChartClassify, 0)
	//sql := `SELECT * FROM chart_classify WHERE is_join_permission = ? `
	//_, err = o.Raw(sql, 1).QueryRows(&chartClassifyList)
	//if err != nil {
	//	return
	//}
	//chartClassifyMap := make(map[int]*ChartClassify)
	//for _, v := range chartClassifyList {
	//	chartClassifyMap[v.ClassifyId] = v
	//}

	// 先将所有已经设置了涉密的分类设置为不涉密
	sql := `UPDATE chart_classify SET is_join_permission=?,modify_time=now() WHERE is_join_permission = 1 AND source = ?`
	_, err = o.Raw(sql, 0, chartClassifySource).Exec()
	if err != nil {
		return
	}

	if len(classifyIdList) > 0 {
		// 将对应的分类设置为涉密
		sql = `UPDATE chart_classify SET is_join_permission=?,modify_time=now() WHERE source = ? AND chart_classify_id in (` + utils.GetOrmInReplace(num) + `) `
		_, err = o.Raw(sql, 1, chartClassifySource, classifyIdList).Exec()
		if err != nil {
			return
		}
	}

	// TODO 判断是否要记录移除的分类，用于发送通知给客户

	return
}

// SetPermissionByChartIdList
// @Description: 根据图表ID列表设置图表的用户权限
// @author: Roc
// @datetime 2024-04-01 10:26:17
// @param chartIdList []string
// @param userIdList []int
// @param source int
// @return err error
func SetPermissionByChartIdList(chartIdList []string, userIdList []int, source int) (err error) {
	chartNum := len(chartIdList)
	if chartNum <= 0 {
		return
	}
	o, err := orm.NewOrmUsingDB("data").Begin()
	if err != nil {
		return
	}
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	// 获取已经配置的图表权限用户
	chartInfoPermissionList := make([]*ChartInfoPermission, 0)
	sql := `SELECT * FROM chart_info_permission WHERE source = ? AND chart_info_id in (` + utils.GetOrmInReplace(chartNum) + `) `
	_, err = o.Raw(sql, source, chartIdList).QueryRows(&chartInfoPermissionList)
	if err != nil {
		return
	}
	chartInfoPermissionMap := make(map[string]*ChartInfoPermission)
	for _, v := range chartInfoPermissionList {
		chartInfoPermissionMap[fmt.Sprint(v.ChartInfoId, "_", v.SysUserId)] = v
	}

	// 标记图表是否纳入权限管控
	{
		// 默认 标记图表为纳入权限管控
		isJoinPermission := 1
		// 用户不选的情况下，说明是要给这些图表移除权限管控
		if len(userIdList) <= 0 {
			// 标记图表为不纳入权限管控
			isJoinPermission = 0
		}
		sql = `UPDATE chart_info SET is_join_permission=?,modify_time=now() WHERE source = ? AND chart_info_id in (` + utils.GetOrmInReplace(chartNum) + `) `
		_, err = o.Raw(sql, isJoinPermission, source, chartIdList).Exec()
		if err != nil {
			return
		}
	}

	// 待添加的配置项
	addList := make([]*ChartInfoPermission, 0)

	// 遍历待配置的图表和用户，筛选出需要添加的配置项
	for _, chartInfoIdStr := range chartIdList {
		chartInfoId, tmpErr := strconv.ParseInt(chartInfoIdStr, 10, 64)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, userId := range userIdList {
			key := fmt.Sprint(chartInfoId, "_", userId)
			if _, ok := chartInfoPermissionMap[key]; ok {
				// 如果存在那么就移除，说明不需要处理了
				delete(chartInfoPermissionMap, key)
			} else {
				// 如果不存在，那么就添加
				addList = append(addList, &ChartInfoPermission{
					//PermissionId: 0,
					ChartInfoId: int32(chartInfoId),
					SysUserId:   int32(userId),
					Source:      int32(source),
					ModifyTime:  time.Now(),
					CreateTime:  time.Now(),
				})
			}
		}
	}

	// 添加待配置项
	if len(addList) > 0 {
		_, err = o.InsertMulti(500, addList)
		if err != nil {
			return
		}
	}

	// 移除废弃的配置项
	{
		// 待移除的配置项
		deletePermissionIdList := make([]int64, 0)
		for _, v := range chartInfoPermissionMap {
			deletePermissionIdList = append(deletePermissionIdList, v.ChartInfoPermissionId)
		}

		deletePermissionIdNum := len(deletePermissionIdList)
		if deletePermissionIdNum > 0 {
			sql = "DELETE FROM chart_info_permission WHERE chart_info_permission_id in (" + utils.GetOrmInReplace(deletePermissionIdNum) + ")"
			_, err = o.Raw(sql, deletePermissionIdList).Exec()
			if err != nil {
				return
			}
		}
	}

	return
}

// SetPermissionByChartClassifyIdList
// @Description: 根据图表分类ID列表设置分类的用户权限
// @author: Roc
// @datetime 2024-03-28 14:53:04
// @param classifyIdList []int
// @param userIdList []int
// @return err error
func SetPermissionByChartClassifyIdList(classifyIdList []int, userIdList []int, classifyType int) (err error) {
	userNum := len(userIdList)
	if userNum <= 0 {
		return
	}
	o, err := orm.NewOrmUsingDB("data").Begin()
	if err != nil {
		return
	}
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	// 获取当前选择用户已经配置的图表分类权限
	classifyPermissionList := make([]*ChartClassifyPermission, 0)
	sql := `SELECT * FROM chart_classify_permission WHERE source = ? AND sys_user_id in (` + utils.GetOrmInReplace(userNum) + `) `
	_, err = o.Raw(sql, classifyType, userIdList).QueryRows(&classifyPermissionList)
	if err != nil {
		return
	}
	classifyPermissionMap := make(map[string]*ChartClassifyPermission)
	for _, v := range classifyPermissionList {
		classifyPermissionMap[fmt.Sprint(v.ChartClassifyId, "_", v.SysUserId)] = v
	}

	// 待添加的配置项
	addList := make([]*ChartClassifyPermission, 0)

	// 遍历待配置的图表和用户，筛选出需要添加的配置项
	for _, userId := range userIdList {
		for _, classifyId := range classifyIdList {
			key := fmt.Sprint(classifyId, "_", userId)
			if _, ok := classifyPermissionMap[key]; ok {
				// 如果存在那么就移除，说明不需要处理了
				delete(classifyPermissionMap, key)
			} else {
				// 如果不存在，那么就提那家
				addList = append(addList, &ChartClassifyPermission{
					//PermissionId: 0,
					ChartClassifyId: int32(classifyId),
					Source:          int32(classifyType),
					SysUserId:       int32(userId),
					ModifyTime:      time.Now(),
					CreateTime:      time.Now(),
				})
			}
		}
	}

	// 添加待配置项
	if len(addList) > 0 {
		_, err = o.InsertMulti(500, addList)
		if err != nil {
			return
		}
	}

	// 移除废弃的配置项
	{
		// 获取移除的配置项
		deletePermissionIdList := make([]int64, 0)
		for _, v := range classifyPermissionMap {
			deletePermissionIdList = append(deletePermissionIdList, v.ChartClassifyPermissionId)
		}

		deletePermissionIdNum := len(deletePermissionIdList)
		if deletePermissionIdNum > 0 {
			sql = "DELETE FROM chart_classify_permission WHERE chart_classify_permission_id in (" + utils.GetOrmInReplace(deletePermissionIdNum) + ")"
			_, err = o.Raw(sql, deletePermissionIdList).Exec()
			if err != nil {
				return
			}
		}
	}

	return
}

// GetPermissionChartClassifyIdListByUserId
// @Description: 根据用户ID获取已经配置的分类id列表
// @author: Roc
// @datetime 2024-03-29 16:24:46
// @param userId int
// @param classifyType int
// @return chartClassifyIdList []int
// @return err error
func GetPermissionChartClassifyIdListByUserId(userId int, classifyType int) (chartClassifyIdList []int, err error) {
	o := orm.NewOrmUsingDB("data")
	sql := `SELECT chart_classify_id FROM chart_classify_permission WHERE source = ? AND sys_user_id = ? `
	_, err = o.Raw(sql, classifyType, userId).QueryRows(&chartClassifyIdList)

	return
}

// GetPermissionChartIdListByDataId
// @Description: 根据资产（图表、图表、表格）ID获取已经配置的用户id列表
// @author: Roc
// @datetime 2024-03-29 16:24:46
// @param dataId int
// @param source int
// @return chartIdList []int
// @return err error
func GetPermissionChartIdListByDataId(dataId int, source int) (chartIdList []int, err error) {
	o := orm.NewOrmUsingDB("data")
	sql := `SELECT sys_user_id FROM chart_info_permission WHERE source = ? AND chart_info_id= ? `
	_, err = o.Raw(sql, source, dataId).QueryRows(&chartIdList)

	return
}

// GetPermissionChartIdList
// @Description: 获取用户权限的图表列表
// @author: Roc
// @datetime 2024-03-28 16:50:47
// @param userId int
// @param chartInfoId int
// @return idList []int
// @return err error
func GetPermissionChartIdList(userId, chartInfoId int) (idList []int, err error) {
	pars := []interface{}{userId}
	o := orm.NewOrmUsingDB("data")
	sql := `SELECT chart_info_id FROM chart_info_permission WHERE sys_user_id = ? `
	if chartInfoId > 0 {
		sql += ` AND chart_info_id = ? `
		pars = append(pars, chartInfoId)
	}
	_, err = o.Raw(sql, pars).QueryRows(&idList)

	return
}

// GetPermissionChartClassifyIdList
// @Description: 获取用户权限的图表分类列表
// @author: Roc
// @datetime 2024-03-28 16:50:47
// @param userId int
// @param classifyId int
// @return idList []int
// @return err error
func GetPermissionChartClassifyIdList(userId, classifyId int) (idList []int, err error) {
	pars := []interface{}{userId}
	o := orm.NewOrmUsingDB("data")
	sql := `SELECT chart_classify_id FROM chart_classify_permission WHERE sys_user_id = ? `
	if classifyId > 0 {
		sql += ` AND chart_classify_id = ? `
		pars = append(pars, classifyId)
	}
	_, err = o.Raw(sql, pars).QueryRows(&idList)

	return
}