eta_api/models/data_manage/data_manage_permission/excel.go

package data_manage_permission

import (
	"eta_gn/eta_api/global"
	"eta_gn/eta_api/utils"
	"fmt"
	"strconv"
	"time"
)

type ExcelInfoPermission struct {
	ExcelInfoPermissionId int64     `json:"excel_info_permission_id" orm:"column(excel_info_permission_id);pk" gorm:"primaryKey" `
	ExcelInfoId           int32     `json:"excel_info_id"`   // ETA表格id
	Source                int32     `json:"source"`          // 表格来源，1：excel插件的表格，2：自定义表格，3：混合表格，4：自定义分析，默认：1
	SysUserId             int32     `json:"sys_user_id"`     // 系统用户id
	ModifyTime            time.Time `json:"modify_time"`     // 变更时间
	CreateTime            time.Time `json:"create_time"`     // 关系建立时间
	PermissionType        int       `json:"permission_type"` // 权限类型: 0-默认; 1-查看; 2-编辑
}

type ExcelClassifyPermission struct {
	ExcelClassifyPermissionId int64     `json:"excel_classify_permission_id" orm:"column(excel_classify_permission_id);pk" gorm:"primaryKey" `
	ExcelClassifyId           int32     `json:"excel_classify_id"` // 分类id
	Source                    int32     `json:"source"`            // 表格来源，1：excel插件的表格，2：自定义表格，3：混合表格，4：自定义分析，默认：1
	SysUserId                 int32     `json:"sys_user_id"`       // 系统用户id
	ModifyTime                time.Time `json:"modify_time"`       // 变更时间
	CreateTime                time.Time `json:"create_time"`       // 关系建立时间
}

func SetIsPermissionByExcelClassifyIdList(classifyIdList []int, excelClassifySource int) (err error) {
	num := len(classifyIdList)
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()
	sql := `UPDATE excel_classify SET is_join_permission=?,modify_time=now() WHERE is_join_permission = 1 AND source = ?`
	err = o.Exec(sql, 0, excelClassifySource).Error
	if err != nil {
		return
	}

	if num > 0 {
		sql = `UPDATE excel_classify SET is_join_permission=?,modify_time=now() WHERE source = ? AND excel_classify_id in (` + utils.GetOrmInReplace(num) + `) `
		err = o.Exec(sql, 1, excelClassifySource, classifyIdList).Error
		if err != nil {
			return
		}
	}

	return
}

func SetPermissionByExcelIdList(excelIdList []string, userIdList []int, source int) (err error) {
	excelNum := len(excelIdList)
	if excelNum <= 0 {
		return
	}
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	excelInfoPermissionList := make([]*ExcelInfoPermission, 0)
	sql := `SELECT * FROM excel_info_permission WHERE source = ? AND excel_info_id in (` + utils.GetOrmInReplace(excelNum) + `) `
	err = o.Raw(sql, source, excelIdList).Scan(&excelInfoPermissionList).Error
	if err != nil {
		return
	}
	excelInfoPermissionMap := make(map[string]*ExcelInfoPermission)
	for _, v := range excelInfoPermissionList {
		excelInfoPermissionMap[fmt.Sprint(v.ExcelInfoId, "_", v.SysUserId)] = v
	}

	{
		isJoinPermission := 1
		if len(userIdList) <= 0 {
			isJoinPermission = 0
		}
		sql = `UPDATE excel_info SET is_join_permission=?,modify_time=now() WHERE source = ? AND excel_info_id in (` + utils.GetOrmInReplace(excelNum) + `) `
		err = global.DmSQL["data"].Exec(sql, isJoinPermission, source, excelIdList).Error
		if err != nil {
			return
		}
	}

	addList := make([]*ExcelInfoPermission, 0)

	for _, excelInfoIdStr := range excelIdList {
		excelInfoId, tmpErr := strconv.ParseInt(excelInfoIdStr, 10, 64)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, userId := range userIdList {
			key := fmt.Sprint(excelInfoId, "_", userId)
			if _, ok := excelInfoPermissionMap[key]; ok {
				delete(excelInfoPermissionMap, key)
			} else {
				addList = append(addList, &ExcelInfoPermission{
					ExcelInfoId: int32(excelInfoId),
					SysUserId:   int32(userId),
					Source:      int32(source),
					ModifyTime:  time.Now(),
					CreateTime:  time.Now(),
				})
			}
		}
	}

	if len(addList) > 0 {
		err = o.CreateInBatches(addList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	{
		deletePermissionIdList := make([]int64, 0)
		for _, v := range excelInfoPermissionMap {
			deletePermissionIdList = append(deletePermissionIdList, v.ExcelInfoPermissionId)
		}

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

	return
}

func SetPermissionByExcelClassifyIdList(classifyIdList []int, userIdList []int, classifyType int) (err error) {
	userNum := len(userIdList)
	if userNum <= 0 {
		return
	}
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	classifyPermissionList := make([]*ExcelClassifyPermission, 0)
	sql := `SELECT * FROM excel_classify_permission WHERE source = ? AND sys_user_id in (` + utils.GetOrmInReplace(userNum) + `) `
	err = o.Raw(sql, classifyType, userIdList).Scan(&classifyPermissionList).Error
	if err != nil {
		return
	}
	classifyPermissionMap := make(map[string]*ExcelClassifyPermission)
	for _, v := range classifyPermissionList {
		classifyPermissionMap[fmt.Sprint(v.ExcelClassifyId, "_", v.SysUserId)] = v
	}

	addList := make([]*ExcelClassifyPermission, 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, &ExcelClassifyPermission{
					ExcelClassifyId: int32(classifyId),
					Source:          int32(classifyType),
					SysUserId:       int32(userId),
					ModifyTime:      time.Now(),
					CreateTime:      time.Now(),
				})
			}
		}
	}

	if len(addList) > 0 {
		err = o.CreateInBatches(addList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	{
		deletePermissionIdList := make([]int64, 0)
		for _, v := range classifyPermissionMap {
			deletePermissionIdList = append(deletePermissionIdList, v.ExcelClassifyPermissionId)
		}

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

	return
}

func GetPermissionExcelClassifyIdListByUserId(userId int, classifyType int) (excelClassifyIdList []int, err error) {
	sql := `SELECT excel_classify_id FROM excel_classify_permission WHERE source = ? AND sys_user_id = ? `
	err = global.DmSQL["data"].Raw(sql, classifyType, userId).Scan(&excelClassifyIdList).Error

	return
}

func GetPermissionUserIdListByExcelId(dataId int, source int) (userIdList []int, err error) {
	sql := `SELECT sys_user_id FROM excel_info_permission WHERE source = ? AND excel_info_id= ? `
	err = global.DmSQL["data"].Raw(sql, source, dataId).Scan(&userIdList).Error

	return
}

func GetPermissionUserIdListByExcelClassifyId(classifyId int, source int) (userIdList []int, err error) {
	sql := `SELECT sys_user_id FROM excel_classify_permission WHERE source = ? AND excel_classify_id= ? `
	err = global.DmSQL["data"].Raw(sql, source, classifyId).Scan(&userIdList).Error

	return
}

func GetPermissionExcelIdList(userId, excelInfoId int) (idList []int, err error) {
	pars := []interface{}{userId}
	sql := `SELECT excel_info_id FROM excel_info_permission WHERE sys_user_id = ? `
	if excelInfoId > 0 {
		sql += ` AND excel_info_id = ? `
		pars = append(pars, excelInfoId)
	}
	err = global.DmSQL["data"].Raw(sql, pars...).Scan(&idList).Error

	return
}

func GetPermissionExcelClassifyIdList(userId, classifyId int) (idList []int, err error) {
	pars := []interface{}{userId}
	sql := `SELECT excel_classify_id FROM excel_classify_permission WHERE sys_user_id = ? `
	if classifyId > 0 {
		sql += ` AND excel_classify_id = ? `
		pars = append(pars, classifyId)
	}
	err = global.DmSQL["data"].Raw(sql, pars...).Scan(&idList).Error

	return
}

func InheritParentClassifyByExcelClassifyId(dataSource, excelSource, classifyId, parentClassifyId int, classifyName, uniqueCode string) (err error) {
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	sql := `UPDATE excel_classify SET is_join_permission=?,modify_time=now() WHERE source = ? AND excel_classify_id = ? `
	err = o.Exec(sql, 1, excelSource, classifyId).Error
	if err != nil {
		return
	}

	{
		var parentRecordItems []*ExcelInfoClassifyPermissionNoAuthRecord
		sql = `SELECT * FROM data_permission_classify_no_auth_record WHERE classify_id = ? AND source = ? AND sub_source = ? ORDER BY data_permission_classify_no_auth_record_id desc LIMIT ?,? `
		err = o.Raw(sql, parentClassifyId, dataSource, excelSource).Scan(&parentRecordItems).Error

		addNoAuthRecordItems := make([]*ExcelInfoClassifyPermissionNoAuthRecord, 0)
		for _, v := range parentRecordItems {
			addNoAuthRecordItems = append(addNoAuthRecordItems, &ExcelInfoClassifyPermissionNoAuthRecord{
				ExcelInfoClassifyPermissionNoAuthRecordId: 0,
				Source:       v.Source,
				OpUniqueCode: uniqueCode,
				ClassifyId:   fmt.Sprint(classifyId),
				ClassifyName: classifyName,
				SysUserId:    v.SysUserId,
				CreateTime:   time.Now(),
			})
		}

		if len(addNoAuthRecordItems) > 0 {
			err = o.CreateInBatches(addNoAuthRecordItems, utils.MultiAddNum).Error
			if err != nil {
				return
			}
		}

	}

	{
		parentClassifyPermissionList := make([]*ExcelClassifyPermission, 0)
		sql = `SELECT * FROM excel_classify_permission WHERE source = ? AND excel_classify_id = ? `
		err = o.Raw(sql, excelSource, parentClassifyId).Scan(&parentClassifyPermissionList).Error
		if err != nil {
			return
		}

		addList := make([]*ExcelClassifyPermission, 0)
		for _, v := range parentClassifyPermissionList {
			addList = append(addList, &ExcelClassifyPermission{
				ExcelClassifyId: int32(classifyId),
				Source:          int32(excelSource),
				SysUserId:       v.SysUserId,
				ModifyTime:      time.Now(),
				CreateTime:      time.Now(),
			})
		}
		if len(addList) > 0 {
			err = o.CreateInBatches(addList, utils.MultiAddNum).Error
			if err != nil {
				return
			}
		}
	}

	return
}

type ExcelInfoPermissionNoAuthRecord struct {
	ExcelInfoPermissionNoAuthRecordId int64     `json:"excel_info_permission_no_auth_record_id"  orm:"column(excel_info_permission_no_auth_record_id);pk" gorm:"primaryKey" ` // 资产数据操作记录id
	OpUniqueCode                      string    `json:"op_unique_code"`                                                                                                       // 操作的唯一编码，主要是记录统一操作的日志
	Source                            int32     `json:"source"`                                                                                                               // 表格来源，1：excel插件的表格，2：自定义表格，3：混合表格，4：自定义分析，默认：1
	ExcelInfoId                       int32     `json:"excel_info_id"`                                                                                                        // 指标id
	ExcelName                         string    `json:"excel_name"`                                                                                                           // 图表名称
	SysUserId                         int32     `json:"sys_user_id"`                                                                                                          // 系统用户id
	CreateTime                        time.Time `json:"create_time"`                                                                                                          // 创建时间
}

func AddExcelInfoPermissionNoAuthRecordBySourceAndDataIdList(source, excelSource int, dataList []DataItem, noAuthUserIdList, authUserIdList []int, uniqueCode, title, content string, opUserId int) (err error) {
	num := len(dataList)
	if num <= 0 {
		return
	}
	dataIdList := make([]int, 0)
	for _, v := range dataList {
		dataIdList = append(dataIdList, v.DataId)
	}
	userNum := len(noAuthUserIdList)
	if userNum <= 0 {
		return
	}
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	var existList []*ExcelInfoPermissionNoAuthRecord
	sql := `SELECT * FROM excel_info_permission_no_auth_record WHERE  source = ? AND excel_info_id in (` + utils.GetOrmInReplace(num) + `)`
	err = o.Raw(sql, excelSource, dataIdList).Scan(&existList).Error
	if err != nil {
		return
	}

	existMap := make(map[int32]map[string]*ExcelInfoPermissionNoAuthRecord)
	for _, v := range existList {
		tmpUserExistMap, ok := existMap[v.SysUserId]
		if !ok {
			tmpUserExistMap = make(map[string]*ExcelInfoPermissionNoAuthRecord)
		}

		key := fmt.Sprint(v.Source, "_", v.ExcelInfoId)
		tmpUserExistMap[key] = v
		existMap[v.SysUserId] = tmpUserExistMap
	}

	addMessageList := make([]*DataPermissionMessage, 0)
	addRecordList := make([]*ExcelInfoPermissionNoAuthRecord, 0)
	for _, userId := range noAuthUserIdList {
		isAdd := false

		tmpUserExistMap, userExistOk := existMap[int32(userId)]

		for _, dataItem := range dataList {
			if userExistOk {
				key := fmt.Sprint(excelSource, "_", dataItem.DataId)
				_, ok := tmpUserExistMap[key]
				if ok {
					continue
				}
			}

			isAdd = true
			addRecordList = append(addRecordList, &ExcelInfoPermissionNoAuthRecord{
				ExcelInfoPermissionNoAuthRecordId: 0,
				OpUniqueCode:                      uniqueCode,
				Source:                            int32(excelSource),
				ExcelInfoId:                       int32(dataItem.DataId),
				ExcelName:                         dataItem.DataName,
				SysUserId:                         int32(userId),
				CreateTime:                        time.Now(),
			})
		}

		if isAdd {
			addMessageList = append(addMessageList, &DataPermissionMessage{
				DataPermissionMessageId: 0,
				SendUserId:              int32(opUserId),
				ReceiveUserId:           int32(userId),
				Content:                 title,
				Remark:                  content,
				OpType:                  3,
				Source:                  int32(source),
				SubSource:               int32(excelSource),
				OpUniqueCode:            uniqueCode,
				IsRead:                  0,
				CreateTime:              time.Now(),
				ModifyTime:              time.Now(),
			})
		}
	}

	if len(addMessageList) > 0 {
		err = o.CreateInBatches(addMessageList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	if len(addRecordList) > 0 {
		err = o.CreateInBatches(addRecordList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	authUserIdNum := len(authUserIdList)
	if authUserIdNum > 0 {
		sql = `DELETE FROM excel_info_permission_no_auth_record WHERE  source = ? AND sys_user_id in (` + utils.GetOrmInReplace(authUserIdNum) + `) AND excel_info_id in (` + utils.GetOrmInReplace(num) + `)`
		err = o.Exec(sql, excelSource, authUserIdList, dataIdList).Error
	}

	return
}

func DeleteExcelInfoPermissionNoAuthRecordBySourceAndDataIdList(excelSource int, dataIdList []string) (err error) {
	num := len(dataIdList)
	if num <= 0 {
		return
	}

	sql := `DELETE FROM excel_info_permission_no_auth_record WHERE source = ? AND excel_info_id in (` + utils.GetOrmInReplace(num) + `)`
	err = global.DmSQL["data"].Exec(sql, excelSource, dataIdList).Error

	return
}

func GetExcelInfoDataPermissionNoAuthRecordListByUserId(userId, excelSource int32, startSize, pageSize int) (total int, items []*DataPermissionNoAuthRecord, err error) {
	sql := `SELECT count(1) AS total FROM excel_info_permission_no_auth_record WHERE sys_user_id = ? AND source = ? `
	err = global.DmSQL["data"].Raw(sql, userId, excelSource).Scan(&total).Error
	if err != nil {
		return
	}

	sql = `SELECT excel_info_permission_no_auth_record_id as data_permission_no_auth_record_id,op_unique_code,source as sub_source,excel_info_id as data_id,excel_name as data_name,sys_user_id,create_time FROM excel_info_permission_no_auth_record WHERE sys_user_id = ? AND source = ? ORDER BY excel_info_permission_no_auth_record_id desc LIMIT ?,? `
	err = global.DmSQL["data"].Raw(sql, userId, excelSource, startSize, pageSize).Scan(&items).Error

	return
}

type ExcelInfoClassifyPermissionNoAuthRecord struct {
	ExcelInfoClassifyPermissionNoAuthRecordId int64     `json:"excel_info_classify_permission_no_auth_record_id" orm:"column(excel_info_classify_permission_no_auth_record_id);pk" gorm:"primaryKey" ` // 资产分类数据操作记录id
	Source                                    int32     `json:"source"`                                                                                                                                // 子来源 ：ETA表格中的各种表格类型，以及图表的来源（这个是后续的扩展方向）
	OpUniqueCode                              string    `json:"op_unique_code"`                                                                                                                        // 操作的唯一编码，主要是记录统一操作的日志
	ClassifyId                                string    `json:"classify_id"`                                                                                                                           // ETA表格资产分类id
	ClassifyName                              string    `json:"classify_name"`                                                                                                                         // ETA表格资产分类名称
	SysUserId                                 int32     `json:"sys_user_id"`                                                                                                                           // 系统用户id
	CreateTime                                time.Time `json:"create_time"`                                                                                                                           // 创建时间
}

func AddExcelInfoClassifyNoAuthRecordBySourceAndClassifyIdList(source, excelSource int, classifyInfoList []ClassifyDataItem, noAuthUserIdList []int, uniqueCode, title, content string, opUserId int) (err error) {
	num := len(classifyInfoList)
	if num <= 0 {
		return
	}
	classifyIdList := make([]int, 0)
	for _, v := range classifyInfoList {
		classifyIdList = append(classifyIdList, v.ClassifyId)
	}

	userNum := len(noAuthUserIdList)
	if userNum <= 0 {
		return
	}
	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	var existList []*ExcelInfoClassifyPermissionNoAuthRecord
	sql := `SELECT * FROM excel_info_classify_permission_no_auth_record WHERE source = ? AND classify_id in (` + utils.GetOrmInReplace(num) + `)`
	err = o.Raw(sql, excelSource, classifyIdList).Scan(&existList).Error
	if err != nil {
		return
	}

	existMap := make(map[int32]map[string]*ExcelInfoClassifyPermissionNoAuthRecord)
	for _, v := range existList {
		tmpUserExistMap, ok := existMap[v.SysUserId]
		if !ok {
			tmpUserExistMap = make(map[string]*ExcelInfoClassifyPermissionNoAuthRecord)
		}

		key := fmt.Sprint(v.Source, "_", v.ClassifyId)
		tmpUserExistMap[key] = v
		existMap[v.SysUserId] = tmpUserExistMap
	}

	addMessageList := make([]*DataPermissionMessage, 0)
	addRecordList := make([]*ExcelInfoClassifyPermissionNoAuthRecord, 0)
	for _, userId := range noAuthUserIdList {
		isAdd := false

		tmpUserExistMap, userExistOk := existMap[int32(userId)]

		for _, dataItem := range classifyInfoList {
			if userExistOk {
				key := fmt.Sprint(excelSource, "_", dataItem.ClassifyId)
				_, ok := tmpUserExistMap[key]
				if ok {
					continue
				}
			}

			isAdd = true
			addRecordList = append(addRecordList, &ExcelInfoClassifyPermissionNoAuthRecord{
				ExcelInfoClassifyPermissionNoAuthRecordId: 0,
				Source:       int32(excelSource),
				OpUniqueCode: uniqueCode,
				ClassifyId:   fmt.Sprint(dataItem.ClassifyId),
				ClassifyName: dataItem.ClassifyName,
				SysUserId:    int32(userId),
				CreateTime:   time.Now(),
			})
		}

		if isAdd {
			addMessageList = append(addMessageList, &DataPermissionMessage{
				DataPermissionMessageId: 0,
				SendUserId:              int32(opUserId),
				ReceiveUserId:           int32(userId),
				Content:                 title,
				Remark:                  content,
				OpType:                  4,
				Source:                  int32(source),
				SubSource:               int32(excelSource),
				OpUniqueCode:            uniqueCode,
				IsRead:                  0,
				CreateTime:              time.Now(),
				ModifyTime:              time.Now(),
			})
		}
	}

	if len(addMessageList) > 0 {
		err = o.CreateInBatches(addMessageList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	if len(addRecordList) > 0 {
		err = o.CreateInBatches(addRecordList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	authUserIdNum := len(classifyIdList)
	if authUserIdNum > 0 {
		sql = `DELETE FROM excel_info_classify_permission_no_auth_record WHERE source = ? AND classify_id not in (` + utils.GetOrmInReplace(num) + `)`
		err = o.Exec(sql, excelSource, classifyIdList).Error
	}

	return
}

func AddExcelInfoClassifyNoAuthRecordBySourceAndUserIdList(source, excelSource int, noAuthClassifyMap map[int]ClassifyDataItem, configUserIdList []int, uniqueCode, title, content string, opUserId int) (err error) {
	configUserNum := len(configUserIdList)
	if configUserNum <= 0 {
		return
	}

	o := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = o.Rollback()
		} else {
			_ = o.Commit()
		}
	}()

	var existList []*ExcelInfoClassifyPermissionNoAuthRecord
	sql := `SELECT * FROM excel_info_classify_permission_no_auth_record WHERE source = ? AND sys_user_id in (` + utils.GetOrmInReplace(configUserNum) + `)`
	err = o.Raw(sql, excelSource, configUserIdList).Scan(&existList).Error
	if err != nil {
		return
	}

	existMap := make(map[int32]map[string]*ExcelInfoClassifyPermissionNoAuthRecord)
	delRecordIdMap := make(map[int64]int64)
	for _, v := range existList {
		tmpUserExistMap, ok := existMap[v.SysUserId]
		if !ok {
			tmpUserExistMap = make(map[string]*ExcelInfoClassifyPermissionNoAuthRecord)
		}

		tmpUserExistMap[v.ClassifyId] = v
		existMap[v.SysUserId] = tmpUserExistMap

		delRecordIdMap[v.ExcelInfoClassifyPermissionNoAuthRecordId] = v.ExcelInfoClassifyPermissionNoAuthRecordId
	}

	addMessageList := make([]*DataPermissionMessage, 0)
	addRecordList := make([]*ExcelInfoClassifyPermissionNoAuthRecord, 0)
	for _, userId := range configUserIdList {
		isAdd := false

		tmpUserExistMap, userExistOk := existMap[int32(userId)]

		for _, dataItem := range noAuthClassifyMap {
			if userExistOk {
				key := fmt.Sprint(dataItem.ClassifyId)
				tmpUserRecord, ok := tmpUserExistMap[key]
				if ok {
					delete(delRecordIdMap, tmpUserRecord.ExcelInfoClassifyPermissionNoAuthRecordId)
					continue
				}
			}

			isAdd = true
			addRecordList = append(addRecordList, &ExcelInfoClassifyPermissionNoAuthRecord{
				ExcelInfoClassifyPermissionNoAuthRecordId: 0,
				Source:       int32(excelSource),
				OpUniqueCode: uniqueCode,
				ClassifyId:   fmt.Sprint(dataItem.ClassifyId),
				ClassifyName: dataItem.ClassifyName,
				SysUserId:    int32(userId),
				CreateTime:   time.Now(),
			})
		}

		if isAdd {
			addMessageList = append(addMessageList, &DataPermissionMessage{
				DataPermissionMessageId: 0,
				SendUserId:              int32(opUserId),
				ReceiveUserId:           int32(userId),
				Content:                 title,
				Remark:                  content,
				OpType:                  4,
				Source:                  int32(source),
				SubSource:               int32(excelSource),
				OpUniqueCode:            uniqueCode,
				IsRead:                  0,
				CreateTime:              time.Now(),
				ModifyTime:              time.Now(),
			})
		}
	}

	if len(addMessageList) > 0 {
		err = o.CreateInBatches(addMessageList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	if len(addRecordList) > 0 {
		err = o.CreateInBatches(addRecordList, utils.MultiAddNum).Error
		if err != nil {
			return
		}
	}

	delRecordIdNum := len(delRecordIdMap)
	if delRecordIdNum > 0 {
		delRecordIdList := make([]int64, 0)
		for _, v := range delRecordIdMap {
			delRecordIdList = append(delRecordIdList, v)
		}
		sql = `DELETE FROM excel_info_classify_permission_no_auth_record WHERE excel_info_classify_permission_no_auth_record_id in (` + utils.GetOrmInReplace(delRecordIdNum) + `) `
		err = o.Exec(sql, delRecordIdList).Error
	}

	return
}

func DeleteExcelInfoClassifyNoAuthRecordBySourceAndClassifyIdList(excelSource int) (err error) {
	sql := `DELETE FROM excel_info_classify_permission_no_auth_record WHERE source = ?`
	err = global.DmSQL["data"].Exec(sql, excelSource).Error

	return
}

func GetExcelInfoDataPermissionClassifyNoAuthRecordListByUserId(userId, excelSource int32, startSize, pageSize int) (total int, items []*DataPermissionClassifyNoAuthRecord, err error) {
	sql := `SELECT count(1) AS total FROM excel_info_classify_permission_no_auth_record WHERE sys_user_id = ? AND source = ? `
	err = global.DmSQL["data"].Raw(sql, userId, excelSource).Scan(&total).Error
	if err != nil {
		return
	}

	sql = `SELECT excel_info_classify_permission_no_auth_record_id as data_permission_classify_no_auth_record_id,source as sub_source,op_unique_code,classify_id,classify_name,sys_user_id,create_time  FROM excel_info_classify_permission_no_auth_record WHERE sys_user_id = ? AND source = ? ORDER BY excel_info_classify_permission_no_auth_record_id desc LIMIT ?,? `
	err = global.DmSQL["data"].Raw(sql, userId, excelSource, startSize, pageSize).Scan(&items).Error

	return
}

type ExcelInfoPermissionAdminAuth struct {
	ExcelInfoPermission
	ExcelName    string `json:"excel_name"`     // 表格名称
	UniqueCode   string `json:"unique_code"`    // 唯一编码
	CreateUserId int    `json:"create_user_id"` // 创建人ID
}

func GetAdminAuthExcelInfoPermission(source, adminId int, keywords string) (items []*ExcelInfoPermissionAdminAuth, err error) {
	sql := `SELECT a.*, b.sys_user_id AS create_user_id, b.excel_name, b.unique_code FROM excel_info_permission AS a
		JOIN excel_info AS b ON a.excel_info_id = b.excel_info_id
		WHERE a.source = ? AND (b.sys_user_id = ? OR a.sys_user_id = ?)`
	var pars []interface{}
	pars = append(pars, source, adminId, adminId)
	if keywords != "" {
		sql += ` AND b.excel_name LIKE ?`
		pars = append(pars, keywords)
	}
	sql += ` ORDER BY a.create_time ASC`
	err = global.DmSQL["data"].Raw(sql, pars...).Scan(&items).Error

	return
}

func ClearAndSetExcelInfoPermission(source, excelInfoId int, permissions []*ExcelInfoPermission) (err error) {
	if excelInfoId <= 0 {
		return
	}
	tx := global.DmSQL["data"].Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	sql := `DELETE FROM excel_info_permission WHERE excel_info_id = ? AND source = ?`
	err = tx.Exec(sql, excelInfoId, source).Error
	if err != nil {
		err = fmt.Errorf("clear permission err: %v", err)
		return
	}
	if len(permissions) > 0 {
		err = tx.CreateInBatches(permissions, utils.MultiAddNum).Error
		if err != nil {
			err = fmt.Errorf("insert permissions err: %v", err)
			return
		}
	}
	return
}

func GetExcelPermissionBySourceAndId(excelId, source int) (items []*ExcelInfoPermission, err error) {
	sql := `SELECT * FROM excel_info_permission WHERE source = ? AND excel_info_id = ?`
	err = global.DmSQL["data"].Raw(sql, source, excelId).Scan(&items).Error

	return
}

func GetExcelPermissionByExcelIdAndUserId(excelId, userId int) (items []*ExcelInfoPermission, err error) {
	sql := `SELECT * FROM excel_info_permission WHERE excel_info_id = ? AND sys_user_id = ?`
	err = global.DmSQL["data"].Raw(sql, excelId, userId).Scan(&items).Error

	return
}