eta_api/services/ppt/ppt_english_group.go

package ppt

import (
	"encoding/json"
	"errors"
	"eta/eta_api/models/ppt_english"
	"eta/eta_api/models/system"
	"eta/eta_api/utils"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)

// AddEnglishGroup 新增ppt目录
func AddEnglishGroup(groupName string, adminId int, isShare int8, isSharedAdd int8) (newId int64, err error) {
	item, err := ppt_english.GetPptGroupByName(groupName, adminId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	if item != nil {
		err = errors.New("目录名称已存在，不可重复添加")
		return
	}
	groupInfo := &ppt_english.PptEnglishGroup{
		GroupName:  groupName,
		AdminId:    adminId,
		IsShare:    isShare,
		IsShareAdd: isSharedAdd,
	}
	if isShare == 1 {
		groupInfo.ShareTime = time.Now()
	}
	newId, err = ppt_english.AddPptGroup(groupInfo)
	if err != nil {
		err = errors.New("新增失败,Err:" + err.Error())
		return
	}
	groupInfo.GroupSort = newId
	groupInfo.GroupId = newId
	// 更新排序标识
	err = groupInfo.Update([]string{"group_sort"})
	if err != nil {
		err = errors.New("更新排序失败:" + err.Error())
		return
	}
	return
}

// AddGroupPptEnglishMapping 新增ppt和目录映射关系
func AddGroupPptEnglishMapping(pptId int64, groupId int64, adminId int, adminRealName string) (newId int64, err error) {
	_, err = ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	bindInfo := &ppt_english.PptEnglishGroupMapping{
		GroupId:       groupId,
		PptId:         pptId,
		AdminId:       adminId,
		AdminRealName: adminRealName,
	}

	newId, err = ppt_english.AddPptGroupMapping(bindInfo)
	if err != nil {
		err = errors.New("绑定目录失败:" + err.Error())
		return
	}

	bindInfo.GroupPptId = newId
	bindInfo.PptSort = newId
	err = bindInfo.Update([]string{"ppt_sort"})
	if err != nil {
		err = errors.New("更新排序失败:" + err.Error())
		return
	}
	return
}

// DelEnglishGroup 删除ppt 目录
func DelEnglishGroup(groupId int64, adminId int) (err error) {
	_, err = ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	//查询是否有映射存在
	count, err := ppt_english.GetPptMappingCountByGroupId(groupId)
	if err != nil {
		err = errors.New("查询目录里的ppt个数出错:" + err.Error())
		return
	}

	if count > 0 {
		err = errors.New("该目录下有关联PPT，不允许删除")
		return
	}
	err = ppt_english.DeletePptGroup(groupId)
	if err != nil {
		err = errors.New("删除失败:" + err.Error())
		return
	}
	return
}

// ShareEnglishGroup 共享/取消共享目录
func ShareEnglishGroup(groupId int64, adminId int) (respShare ppt_english.RespPptGroupShare, err error) {
	// 查询目录是否存在
	groupInfo, err := ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	// 判断是共享操作还是取消共享操作
	if groupInfo.IsShare == 1 {
		//取消共享
		groupInfo.IsShare = 0
		//groupInfo.ModifyTime = time.Now()
		err = groupInfo.Update([]string{"is_share"})
		if err != nil {
			err = errors.New("取消共享出错:" + err.Error())
			return
		}
	} else {
		//设置共享
		groupInfo.IsShare = 1
		groupInfo.ShareTime = time.Now()
		err = groupInfo.Update([]string{"is_share", "share_time"})
		if err != nil {
			err = errors.New("设置共享出错:" + err.Error())
			return
		}
		respShare.IsShare = 1
	}

	respShare.GroupId = groupId
	return
}

// CopyEnglishGroup 复制目录
func CopyEnglishGroup(groupId int64, adminId int, adminRealName string) (err error) {
	//查询目录是否存在
	groupInfo, err := ppt_english.GetPptGroupByGroupId(groupId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	//新增公共目录。目录名称在原来的基础上带上复制序号
	groupNames, err := ppt_english.GetPptGroupNamesByAdminId(adminId)
	if err != nil {
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	newGroupName := generateCopyName(groupInfo.GroupName, 1, groupNames)
	newGroupId, err := AddEnglishGroup(newGroupName, adminId, 0, 0)
	if err != nil {
		err = errors.New("复制目录出错:" + err.Error())
		return
	}
	//查询该目录下面是否存在ppt，如果存在则批量复制ppt到新目录下
	mappingList, err := ppt_english.GetPptMappingListByGroupId(groupId)
	if err != nil {
		err = errors.New("查询目录里的ppt列表出错:" + err.Error())
		return
	}
	if len(mappingList) <= 0 {
		return
	}
	pptIds := make([]int, 0)
	for _, v := range mappingList {
		pptIds = append(pptIds, int(v.PptId))
	}
	//批量查询ppt详情
	pptList, err := ppt_english.GetPptEnglishByIds(pptIds)
	if err != nil {
		err = errors.New("查询ppt列表出错:" + err.Error())
		return
	}
	pptNames, err := ppt_english.GetAllPptTitle()
	if err != nil {
		err = errors.New("查询ppt标题出错:" + err.Error())
		return
	}
	//批量复制ppt，更新作者为当前账号，并返回新的pptID
	newPptList := make([]*ppt_english.PptEnglish, 0)
	for _, v := range pptList {
		tmp := &ppt_english.PptEnglish{
			TemplateType:  v.TemplateType,
			BackgroundImg: v.BackgroundImg,
			Title:         generateCopyName(v.Title, 1, pptNames),
			ReportType:    v.ReportType,
			PptDate:       v.PptDate,
			Content:       v.Content,
			CoverContent:  v.CoverContent,
			CreateTime:    time.Now(),
			ModifyTime:    time.Now(),
			AdminId:       adminId,
			AdminRealName: adminRealName,
			TitleSetting:  v.TitleSetting,
		}
		newPptList = append(newPptList, tmp)
	}
	if len(newPptList) > 0 {
		err = ppt_english.AddPptEnglishMulti(newPptList)
		if err != nil {
			err = errors.New("复制目录里的ppt出错:" + err.Error())
			return
		}

		newMappings := make([]*ppt_english.PptEnglishGroupMapping, 0)
		for _, v := range newPptList {
			tmp := &ppt_english.PptEnglishGroupMapping{
				GroupId:       newGroupId,
				PptId:         int64(v.PptId),
				CreateTime:    time.Now(),
				ModifyTime:    time.Now(),
				AdminId:       adminId,
				AdminRealName: adminRealName,
			}
			newMappings = append(newMappings, tmp)
		}
		err = ppt_english.AddPptGroupMappingMulti(newMappings)
		if err != nil {
			err = errors.New("复制目录里的ppt出错:" + err.Error())
			return
		}
		//批量更新排序字段
		var newGroupPptIds []int64
		for _, v := range newMappings {
			newGroupPptIds = append(newGroupPptIds, v.GroupPptId)
		}
		err = ppt_english.UpdatePptGroupMappingSortMulti(newGroupPptIds)
		if err != nil {
			err = errors.New("更新排序标识出错:" + err.Error())
			return
		}
	}
	return
}

// RenameEnglishGroupName 目录重命名
func RenameEnglishGroupName(groupId int64, groupName string, adminId int) (err error) {
	groupInfo, err := ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	if groupInfo.GroupName == groupName {
		err = errors.New("与原名字一致，无需修改")
		return
	}
	item, err := ppt_english.GetPptGroupByName(groupName, adminId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	if item != nil {
		err = errors.New("目录名称已存在，不可重复添加")
		return
	}

	//更新新名字
	groupInfo.GroupName = groupName
	err = groupInfo.Update([]string{"group_name"})
	if err != nil {
		err = errors.New("目录重命名失败" + err.Error())
		return
	}
	return
}

// ShareSingleEnglishGroupPpt 共享单个ppt/取消共享单个ppt，返回共享状态
func ShareSingleEnglishGroupPpt(groupPptId int64, adminId int, adminRealName string) (ret ppt_english.RespPptShare, err error) {
	//判断当前登录者是否有共享的权限
	groupPpt, err := ppt_english.GetPptMappingByGroupPptId(groupPptId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("当前目录下的ppt不存在")
			return
		}
		err = errors.New("目录下的ppt查询出错:" + err.Error())
		return
	}
	groupInfo, err := ppt_english.GetPptGroupByGroupIdAdminId(groupPpt.GroupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	//判断当前的共享状态
	if groupPpt.ChildGroupPptId > 0 {
		err = CancelShareSingleGroupPptEnglish(groupPpt, adminId)
		if err != nil {
			err = errors.New(err.Error())
			return
		}
		ret.IsSingleShare = 0
	} else {
		//如果是未共享状态，则共享该ppt，类似复制流程，并更新共享标识
		//新增公共目录。目录名称在原来的基础上带上复制序号
		groupNames, tErr := ppt_english.GetPptGroupNamesByAdminId(adminId)
		if tErr != nil {
			err = errors.New("目录查询出错:" + tErr.Error())
			return
		}
		newGroupName := generateCopyName(groupInfo.GroupName, 1, groupNames)
		newGroupId, tErr := AddGroup(newGroupName, adminId, 1, 1)
		if tErr != nil {
			err = errors.New(tErr.Error())
			return
		}
		//新增公共的目录和ppt之间的映射关系
		newGroupPptId, tErr := AddGroupPptMapping(groupPpt.PptId, newGroupId, adminId, adminRealName)
		if tErr != nil {
			err = errors.New(tErr.Error())
			return
		}
		//更新共享标识
		groupPpt.ChildGroupPptId = newGroupPptId
		err = groupPpt.Update([]string{"child_group_ppt_id"})
		if err != nil {
			err = errors.New("更新共享标识失败" + err.Error())
			return
		}
		ret.IsSingleShare = 1
	}
	ret.GroupPptId = groupPptId
	return
}

// GetGroupPptEnglishList 公共目录下的ppt列表或者单个目录里的ppt列表
func GetGroupPptEnglishList(groupId int64, adminId int) (ret ppt_english.RespGroupPptList, err error) {
	var groupPptList []*ppt_english.PptEnglishGroupMapping
	var groups []*ppt_english.PptEnglishGroup
	list := make([]*ppt_english.RespGroupPptListItem, 0)
	ret.List = list
	if groupId > 0 {
		//只查询组内的ppt列表
		//查询目录是否存在
		groupInfo, tErr := ppt_english.GetPptGroupByGroupId(groupId)
		if tErr != nil {
			if tErr.Error() == utils.ErrNoRow() {
				err = errors.New("目录不存在")
				return
			}
			err = errors.New("目录查询出错:" + tErr.Error())
			return
		}
		groups = append(groups, groupInfo)
		groupPptList, tErr = ppt_english.GetPptMappingListByGroupId(groupId)
		if tErr != nil {
			err = errors.New("目录里的ppt查询出错:" + tErr.Error())
			return
		}
	} else {
		// 获取我的所有的ppt
		ret, err = GetMyPptEnglishList(adminId, ``)
		return
	}
	if len(groupPptList) <= 0 {
		return
	}
	pptMap := make(map[int]*ppt_english.PptEnglish)
	groupMap := make(map[int64][]*ppt_english.PptEnglishGroupMapping)
	pptIds := make([]int, 0)
	for _, v := range groupPptList {
		pptIds = append(pptIds, int(v.PptId))
		groupMap[v.GroupId] = append(groupMap[v.GroupId], v)
	}

	if len(pptIds) == 0 {
		// 返回所有空目录
		return
	}
	pptList, err := ppt_english.GetPptEnglishByIds(pptIds)
	if err != nil {
		err = errors.New("查询ppt详情出错:" + err.Error())
		return
	}

	for _, v := range pptList {
		pptMap[v.PptId] = v
	}

	//按照排序顺序，依次放入ppt
	hasPpt := make(map[int]struct{})
	for _, v := range groups {
		if mapList, ok := groupMap[v.GroupId]; ok {
			if len(mapList) > 0 {
				for _, pptV := range mapList {
					pptInfo, ok1 := pptMap[int(pptV.PptId)]
					_, ok2 := hasPpt[int(pptV.PptId)]
					if ok1 && !ok2 {
						tmp := &ppt_english.RespGroupPptListItem{
							GroupPptId:    pptV.GroupPptId,
							PptId:         pptV.PptId,
							TemplateType:  pptInfo.TemplateType,
							BackgroundImg: pptInfo.BackgroundImg,
							Title:         pptInfo.Title,
							AdminId:       pptV.AdminId,
							AdminRealName: pptV.AdminRealName,
							IsSingleShare: 0,
							PptCreateTime: pptInfo.CreateTime.Format(utils.FormatDateTime),
							PptModifyTime: pptInfo.ModifyTime.Format(utils.FormatDateTime),
							PptxUrl:       pptInfo.PptxUrl,
							ReportId:      pptInfo.ReportId,
							ReportCode:    pptInfo.ReportCode,
							PublishTime:   utils.DealDateTimeZero(pptInfo.PublishTime, utils.FormatDateTime),
						}
						if pptV.ChildGroupPptId > 0 {
							tmp.IsSingleShare = 1
						}

						list = append(list, tmp)
						hasPpt[pptInfo.PptId] = struct{}{}
					}
				}
			}
		}
	}

	ret.List = list
	if groupId <= 0 {
		sort.Sort(ret)
	}
	ret.Total = len(list)
	return
}

// MoveGroupPptEnglish 移动ppt操作
func MoveGroupPptEnglish(groupId, groupPptId, prevGroupPptId, nextGroupPptId int64, adminId int) (err error) {
	//查询当前映射是否存在
	//判断当前登录者是否有共享的权限oo
	groupPpt, err := ppt_english.GetPptMappingByGroupPptId(groupPptId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("当前目录下的ppt不存在")
			return
		}
		err = errors.New("目录下的ppt查询出错:" + err.Error())
		return
	}
	var updateStr []string
	//如果更换了目录，默认当前排序值为0
	var currentSort, prevSort, nextSort int64
	//判断是否更换group
	if groupPpt.GroupId != groupId {
		_, err = ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				err = errors.New("目录不存在")
				return
			}
			err = errors.New("目录查询出错:" + err.Error())
			return
		}
		//判断是否需要解除当个ppt共享
		//解除共享操作
		err = CancelShareSingleGroupPptEnglish(groupPpt, adminId)
		if err != nil {
			err = errors.New(err.Error())
			return
		}
		groupPpt.GroupId = groupId
		updateStr = append(updateStr, "group_id")
	}
	currentSort = groupPpt.PptSort

	var prevGroupPpt *ppt_english.PptEnglishGroupMapping
	var nextGroupPpt *ppt_english.PptEnglishGroupMapping
	if prevGroupPptId > 0 {
		prevGroupPpt, err = ppt_english.GetPptMappingByGroupPptId(prevGroupPptId, adminId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				err = errors.New("目录下的ppt不存在")
				return
			}
			err = errors.New("目录下的ppt查询出错:" + err.Error())
			return
		}
		prevSort = prevGroupPpt.PptSort
	}

	if nextGroupPptId > 0 {
		nextGroupPpt, err = ppt_english.GetPptMappingByGroupPptId(nextGroupPptId, adminId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				err = errors.New("目录下的ppt不存在")
				return
			}
			err = errors.New("目录下的ppt查询出错:" + err.Error())
			return
		}
		nextSort = nextGroupPpt.PptSort
	}

	updateStr = append(updateStr, "ppt_sort")

	//移到两个排序值中间操作
	if prevSort >= currentSort {
		//往下移动
		err = ppt_english.MoveDownGroupPptBySort(groupId, prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动ppt出错:" + err.Error())
			return
		}
		groupPpt.PptSort = prevSort
	} else if nextSort <= currentSort && nextSort != 0 {
		//往上移动
		err = ppt_english.MoveUpGroupPptBySort(groupId, nextSort, currentSort)
		if err != nil {
			err = errors.New("向上移动ppt出错:" + err.Error())
			return
		}
		groupPpt.PptSort = nextSort
	}
	//更新当前排序
	err = groupPpt.Update(updateStr)
	if err != nil {
		err = errors.New("移动ppt出错:" + err.Error())
		return
	}
	return
}

// MoveEnglishGroup 移动目录
func MoveEnglishGroup(groupId, prevGroupId, nextGroupId int64, adminId int) (err error) {
	//查询目录是否存在
	groupInfo, err := ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	//如果更换了目录，默认当前排序值为0
	var currentSort, prevSort, nextSort int64

	currentSort = groupInfo.GroupSort

	var prevGroup *ppt_english.PptEnglishGroup
	var nextGroup *ppt_english.PptEnglishGroup
	if prevGroupId > 0 {
		prevGroup, err = ppt_english.GetPptGroupByGroupIdAdminId(prevGroupId, adminId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				err = errors.New("目录不存在")
				return
			}
			err = errors.New("目录查询出错:" + err.Error())
			return
		}
		prevSort = prevGroup.GroupSort
	}

	if nextGroupId > 0 {
		nextGroup, err = ppt_english.GetPptGroupByGroupIdAdminId(nextGroupId, adminId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				err = errors.New("目录不存在")
				return
			}
			err = errors.New("目录查询出错:" + err.Error())
			return
		}
		nextSort = nextGroup.GroupSort
	}
	//移到两个排序值中间操作
	if prevSort >= currentSort {
		//往下移动
		err = ppt_english.MoveDownGroupBySort(prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动ppt出错:" + err.Error())
			return
		}
		groupInfo.GroupSort = prevSort
	} else if nextSort <= currentSort && nextSort != 0 {
		//往上移动
		err = ppt_english.MoveUpGroupBySort(nextSort, currentSort)
		if err != nil {
			err = errors.New("向上移动ppt出错:" + err.Error())
			return
		}
		groupInfo.GroupSort = nextSort
	}
	//更新当前排序
	err = groupInfo.Update([]string{"group_sort"})
	if err != nil {
		err = errors.New("移动目录出错:" + err.Error())
		return
	}
	return
}

// CancelShareSingleGroupPptEnglish 解除单个共享的ppt
func CancelShareSingleGroupPptEnglish(groupPpt *ppt_english.PptEnglishGroupMapping, adminId int) (err error) {
	if groupPpt.ChildGroupPptId <= 0 {
		return
	}
	//如果已经是共享状态，
	//判断当前登录者是否有取消共享的权限
	childGroupPpt, tErr := ppt_english.GetPptMappingByGroupPptId(groupPpt.ChildGroupPptId, adminId)
	if tErr != nil {
		if tErr.Error() != utils.ErrNoRow() {
			err = errors.New("目录下的ppt查询出错:" + tErr.Error())
			return
		}
	}

	if childGroupPpt != nil {
		//删除共享目录和ppt的映射关系
		err = ppt_english.DeletePptGroupMapping(childGroupPpt.GroupPptId, adminId)
		if err != nil {
			err = errors.New("删除共享目录下的ppt失败:" + err.Error())
			return
		}
		//删除共享出去的公共目录
		err = ppt_english.DeletePptGroup(childGroupPpt.GroupId)
		if err != nil {
			err = errors.New("删除共享目录失败:" + err.Error())
			return
		}
	}
	//更新共享状态为未共享，
	//更新共享标识
	groupPpt.ChildGroupPptId = 0
	err = groupPpt.Update([]string{"child_group_ppt_id"})
	if err != nil {
		err = errors.New("更新共享标识失败" + err.Error())
		return
	}
	return
}

// DeleteGroupPptEnglish 删除ppt
func DeleteGroupPptEnglish(PptId int) (err error) {
	//查询该ppt的所有单个共享出去的目录信息
	groupPpts, err := ppt_english.GetGroupPptByPptId(PptId)
	if err != nil {
		err = errors.New("查询目录里的ppt失败" + err.Error())
		return
	}
	if len(groupPpts) <= 0 {
		return
	}
	//整理出需要删除的groupId
	groupPptMap := make(map[int64]*ppt_english.PptEnglishGroupMapping)
	for _, v := range groupPpts {
		groupPptMap[v.GroupPptId] = v
	}
	var delGroupIds string
	for _, v := range groupPpts {
		if v.ChildGroupPptId > 0 {
			if childGroup, ok := groupPptMap[v.ChildGroupPptId]; ok {
				delGroupIds += strconv.Itoa(int(childGroup.GroupId)) + ","
			}
		}
	}
	if delGroupIds != "" {
		delGroupIds = "(" + strings.Trim(delGroupIds, ",") + ")"
		err = ppt_english.DeletePptGroupByGroupIds(delGroupIds)
		if err != nil {
			err = errors.New("删除单个共享目录失败" + err.Error())
			return
		}
	}
	//再统一删除目录里相关的ppt
	err = ppt_english.DeletePptGroupMappingByPptId(PptId)
	if err != nil {
		err = errors.New("删除目录里的ppt失败" + err.Error())
		return
	}
	return
}

// CopyPptEnglish 复制单个ppt，并移动到新的目录下面
func CopyPptEnglish(pptId int, groupId int64, adminId int, adminRealName string) (resp ppt_english.RespGroupPptNameListItem, err error) {
	//查询ppt详情
	pptInfo, err := ppt_english.GetPptEnglishById(pptId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("ppt 不存在")
			return
		}
		err = errors.New("查询ppt失败" + err.Error())
		return
	}
	// 查询目录是否存在
	_, err = ppt_english.GetPptGroupByGroupIdAdminId(groupId, adminId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("目录不存在")
			return
		}
		err = errors.New("目录查询出错:" + err.Error())
		return
	}
	pptNames, err := ppt_english.GetAllPptTitle()
	if err != nil {
		err = errors.New("查询ppt标题出错:" + err.Error())
		return
	}
	//复制ppt，更新作者为当前账号，并返回新的pptID
	var newPptList []*ppt_english.PptEnglish
	newPpt := &ppt_english.PptEnglish{
		TemplateType:  pptInfo.TemplateType,
		BackgroundImg: pptInfo.BackgroundImg,
		Title:         generateCopyName(pptInfo.Title, 1, pptNames),
		ReportType:    pptInfo.ReportType,
		PptDate:       pptInfo.PptDate,
		Content:       pptInfo.Content,
		CoverContent:  pptInfo.CoverContent,
		CreateTime:    time.Now(),
		ModifyTime:    time.Now(),
		AdminId:       adminId,
		AdminRealName: adminRealName,
		TitleSetting:  pptInfo.TitleSetting,
	}
	newPptList = append(newPptList, newPpt)

	err = ppt_english.AddPptEnglishMulti(newPptList)
	if err != nil {
		err = errors.New("复制目录里的ppt出错:" + err.Error())
		return
	}
	var newMappings []*ppt_english.PptEnglishGroupMapping
	newGroupPpt := &ppt_english.PptEnglishGroupMapping{
		GroupId:       groupId,
		PptId:         int64(newPpt.PptId),
		CreateTime:    time.Now(),
		ModifyTime:    time.Now(),
		AdminId:       adminId,
		AdminRealName: adminRealName,
	}
	newMappings = append(newMappings, newGroupPpt)

	err = ppt_english.AddPptGroupMappingMulti(newMappings)
	if err != nil {
		err = errors.New("复制目录里的ppt出错:" + err.Error())
		return
	}
	//批量更新排序字段
	err = ppt_english.UpdatePptGroupMappingSortMulti([]int64{newGroupPpt.GroupPptId})
	if err != nil {
		err = errors.New("更新排序标识出错:" + err.Error())
		return
	}
	var pptPage int
	if newPpt.Content != "" {
		contents := make([]PageContent, 0)
		if e := json.Unmarshal([]byte(newPpt.Content), &contents); e != nil {
			err = errors.New(fmt.Sprintf("%d,解析PPT内容页数失败: %s", newPpt.PptId, e.Error()))
			return
		}
		pptPage = len(contents)
	}
	resp = ppt_english.RespGroupPptNameListItem{
		GroupPptId:    newGroupPpt.GroupPptId,
		PptId:         int64(newPpt.PptId),
		Title:         newPpt.Title,
		AdminId:       newPpt.AdminId,
		AdminRealName: newPpt.AdminRealName,
		PptCreateTime: newPpt.CreateTime.Format(utils.FormatDateTime),
		PptPage:       pptPage,
		TitleSetting:  newPpt.TitleSetting,
	}
	return
}

// generateCopyNameEnglish 生成复制的目录名称
func generateCopyNameEnglish(originName string, count int, nameList []string) (newName string) {
	newName = originName + "（" + strconv.Itoa(count) + "）"
	for _, v := range nameList {
		if v == newName {
			count++
			newName = generateCopyName(originName, count, nameList)
			return
		}
	}
	return
}

// SearchGroupPptEnglish 根据ppt标题搜索ppt
func SearchGroupPptEnglish(keyWord string) (ret ppt_english.RespSearchGroupPptList, err error) {
	//组装group ppt
	list := make([]*ppt_english.RespSearchGroupPptListItem, 0)
	ret.List = list
	condition := " and title like ? "
	var pars []interface{}
	pars = append(pars, utils.GetLikeKeyword(keyWord))
	pptList, err := ppt_english.GetPptEnglishByCondition(condition, pars)
	if err != nil {
		err = errors.New("查询ppt列表出错:" + err.Error())
		return
	}
	if len(pptList) == 0 {
		return
	}
	pptIds := make([]string, 0)
	pptMap := make(map[int]*ppt_english.PptEnglish)
	for _, v := range pptList {
		pptIds = append(pptIds, strconv.Itoa(v.PptId))
		pptMap[v.PptId] = v
	}

	groupPptList, err := ppt_english.GetPublicGroupPptByPptIds(pptIds)
	if err != nil {
		err = errors.New("查询目录里的ppt列表出错:" + err.Error())
		return
	}

	for _, v := range groupPptList {
		tmp := new(ppt_english.RespSearchGroupPptListItem)
		tmp.GroupPptId = v.GroupPptId
		tmp.PptId = v.PptId
		if i, ok := pptMap[int(v.PptId)]; ok {
			tmp.Title = i.Title
		}
		list = append(list, tmp)
	}
	ret.List = list
	return
}

func GetEnglishGroupsByAdminId(adminId int) (ret ppt_english.RespGroupList, err error) {
	myPptList := make([]*ppt_english.RespGroupPptNameListItem, 0)
	otherPptList := make([]*ppt_english.RespGroupPptNameListItem, 0)
	grantList := []ppt_english.RespGroupListItem{
		{
			GroupId:   1,
			GroupName: "我共享的",
			PptList:   myPptList,
		},
		{
			GroupId:   2,
			GroupName: "收到共享",
			PptList:   otherPptList,
		},
	}
	ret.PublicList = make([]*ppt_english.RespGroupListItem, 0)
	ret.PrivateList = make([]*ppt_english.RespGroupListItem, 0)
	ret.GrantList = grantList

	pptMap := make(map[int]*ppt_english.PptEnglish)
	groupMap := make(map[int64][]*ppt_english.RespGroupPptNameListItem)
	groupHasNewPptMap := make(map[int64]struct{})
	pptIds := make([]int, 0)

	// 获取我的ppt分组
	privateGroups, err := ppt_english.GetPrivatePptGroupsByAdminId(adminId)
	if err != nil {
		err = errors.New("私有目录查询出错:" + err.Error())
		return
	}
	groupIds := make([]int64, 0)
	for _, v := range privateGroups {
		groupIds = append(groupIds, v.GroupId)
	}

	var pptMappings []*ppt_english.PptEnglishGroupMapping
	// 如果没有分组，那么直接返回
	if len(groupIds) > 0 {
		// 遍历分组并拼接
		for _, v := range privateGroups {
			tmp := new(ppt_english.RespGroupListItem)
			tmp.GroupId = v.GroupId
			tmp.GroupName = v.GroupName
			tmp.IsShare = v.IsShare
			tmp.AdminId = v.AdminId
			ret.PrivateList = append(ret.PrivateList, tmp)
		}
		// 通过分组id获取相关的ppt信息，主要是为了获取所有的ppt_id字段
		pptMappings, err = ppt_english.GetPptMappingListByGroupIds(groupIds)
		if err != nil {
			err = errors.New("查询目录里的ppt出错:" + err.Error())
			return
		}
		for _, v := range pptMappings {
			pptIds = append(pptIds, int(v.PptId))
		}
	}

	adminIdList := make([]int, 0)   //需要查询的创建人admin_id列表集合
	adminIdMap := make(map[int]int) //需要查询的创建人admin_id集合，用来去重的，避免重复id

	// grantList 已经分配权限的ppt
	grantPptList, err := ppt_english.GetAllGrantList(adminId)
	for _, v := range grantPptList {
		pptIds = append(pptIds, v.PptId)
		if _, ok := adminIdMap[v.AdminId]; !ok {
			adminIdList = append(adminIdList, v.AdminId) //需要查询的创建人admin_id列表集合
			adminIdMap[v.AdminId] = v.AdminId            //需要查询的创建人admin_id集合，用来去重的，避免重复id
		}
	}

	if len(pptIds) > 0 {
		// 通过ppt_id列表字段获取所有的ppt信息
		pptList, tmpErr := ppt_english.GetPptEnglishByIds(pptIds)
		if tmpErr != nil {
			err = errors.New("查询ppt详情出错:" + err.Error())
			return
		}
		for _, v := range pptList {
			pptMap[v.PptId] = v
		}
	}

	// 私有的Ppt列表
	{
		//组装group ppt
		for _, v := range pptMappings {
			i, ok := pptMap[int(v.PptId)]
			if !ok { //找不到ppt，还干个啥，直接退出当前循环啊
				continue
			}
			pptPage := 0
			// 因之前并没有存储PPT页数字段，所以此处读取PPT内容的长度
			if i.Content != "" {
				contents := make([]PageContent, 0)
				if e := json.Unmarshal([]byte(i.Content), &contents); e != nil {
					err = errors.New(fmt.Sprintf("%d,解析PPT内容页数失败: %s", i.PptId, e.Error()))
					return
				}
				pptPage = len(contents)
			}

			tmp := &ppt_english.RespGroupPptNameListItem{
				AdminId:       v.AdminId,
				GroupPptId:    v.GroupPptId,
				PptId:         v.PptId,
				AdminRealName: v.AdminRealName,
				Title:         i.Title,
				IsSingleShare: i.IsShare,
				PptxUrl:       i.PptxUrl,
				ReportId:      i.ReportId,
				ReportCode:    i.ReportCode,
				PptCreateTime: i.CreateTime.Format(utils.FormatDateTime),
				PptModifyTime: i.ModifyTime.Format(utils.FormatDateTime),
				PublishTime:   utils.DealDateTimeZero(i.PublishTime, utils.FormatDateTime),
				PptPage:       pptPage,
			}

			if tmp.PptVersion == 2 {
				groupHasNewPptMap[v.GroupId] = struct{}{}
			}
			groupMap[v.GroupId] = append(groupMap[v.GroupId], tmp)
		}

		for k, v := range ret.PrivateList {
			if pptL, ok := groupMap[v.GroupId]; ok {
				ret.PrivateList[k].PptList = pptL
				if _, ok1 := groupHasNewPptMap[v.GroupId]; !ok1 && len(pptL) > 0 {
					ret.PrivateList[k].OnlyOld = true
				}
			}
		}
	}

	publicAdminIdList := make([]int, 0)
	publicPptListMap := make(map[int][]*ppt_english.RespGroupPptNameListItem)

	// 获取公开分享的ppt
	sharePptList, err := ppt_english.GetSharePptEnglish()
	for _, v := range sharePptList {
		publicPptList, ok := publicPptListMap[v.AdminId]
		if !ok {
			publicPptList = make([]*ppt_english.RespGroupPptNameListItem, 0)
			publicAdminIdList = append(publicAdminIdList, v.AdminId)

			// 需要查询的创建人信息
			if _, ok := adminIdMap[v.AdminId]; !ok {
				adminIdList = append(adminIdList, v.AdminId) //需要查询的创建人admin_id列表集合
				adminIdMap[v.AdminId] = v.AdminId            //需要查询的创建人admin_id集合，用来去重的，避免重复id
			}
		}

		contents := make([]PageContent, 0)
		if e := json.Unmarshal([]byte(v.Content), &contents); e != nil {
			err = errors.New("解析PPT内容页数失败: " + e.Error())
			return
		}
		pptPage := len(contents)
		tmpV := &ppt_english.RespGroupPptNameListItem{
			GroupPptId:    int64(v.PptId),
			PptId:         int64(v.PptId),
			Title:         v.Title,
			AdminId:       v.AdminId,
			AdminRealName: v.AdminRealName,
			IsSingleShare: v.IsShare,
			PptxUrl:       v.PptxUrl,
			ReportId:      v.ReportId,
			ReportCode:    v.ReportCode,
			PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
			PptModifyTime: v.ModifyTime.Format(utils.FormatDateTime),
			PublishTime:   utils.DealDateTimeZero(v.PublishTime, utils.FormatDateTime),
			PptPage:       pptPage,
		}
		publicPptList = append(publicPptList, tmpV)
		publicPptListMap[v.AdminId] = publicPptList
	}

	// 创建人信息
	systemAdminMap := make(map[int]*system.Admin)
	systemAdminList, err := system.GetAdminListByIdList(adminIdList)
	if err != nil {
		return
	}
	for _, v := range systemAdminList {
		systemAdminMap[v.AdminId] = v
	}

	// 公开分享的用户列表
	{
		for _, v := range publicAdminIdList {
			systemAdmin, ok := systemAdminMap[v]
			if !ok {
				continue
			}

			// ppt 列表信息
			respGroupPptNameListItemList, ok := publicPptListMap[v]
			if !ok {
				respGroupPptNameListItemList = make([]*ppt_english.RespGroupPptNameListItem, 0)
			}

			// ppt 分组信息
			tmpRespGroupListItem := &ppt_english.RespGroupListItem{
				GroupId:   int64(systemAdmin.AdminId),
				GroupName: systemAdmin.RealName + "的PPT",
				AdminId:   systemAdmin.AdminId,
				IsShare:   1,
				OnlyOld:   false,
				PptList:   respGroupPptNameListItemList,
			}
			ret.PublicList = append(ret.PublicList, tmpRespGroupListItem)
		}
	}

	myGrantPPtIdMap := make(map[int]int) //我分配的ppt的id集合
	// 共享Ppt
	{
		for _, v := range grantPptList {
			pptPage := 0
			// 因之前并没有存储PPT页数字段，所以此处读取PPT内容的长度
			if v.Content != "" {
				contents := make([]PageContent, 0)
				if e := json.Unmarshal([]byte(v.Content), &contents); e != nil {
					err = errors.New("解析PPT内容页数失败: " + e.Error())
					return
				}
			}

			title := v.Title
			if adminInfo, ok := systemAdminMap[v.AdminId]; ok {
				title = adminInfo.RealName + "———" + title
			}

			tmp := &ppt_english.RespGroupPptNameListItem{
				AdminId: v.AdminId,
				//GroupPptId:    v.GroupPptId,
				PptId:         int64(v.PptId),
				AdminRealName: v.AdminRealName,
				Title:         title,
				PptVersion:    v.PptVersion,
				IsSingleShare: v.IsShare,
				PptxUrl:       v.PptxUrl,
				ReportId:      v.ReportId,
				ReportCode:    v.ReportCode,
				PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
				PptModifyTime: v.ModifyTime.Format(utils.FormatDateTime),
				PublishTime:   utils.DealDateTimeZero(v.PublishTime, utils.FormatDateTime),
				PptPage:       pptPage,
			}

			if v.AdminId == adminId {
				tmp.IsGrant = 1
				myPptList = append(myPptList, tmp)
				myGrantPPtIdMap[v.PptId] = v.PptId
			} else {
				tmp.IsReceived = 1
				otherPptList = append(otherPptList, tmp)
			}
		}
		grantList[0].PptList = myPptList
		grantList[1].PptList = otherPptList
		ret.GrantList = grantList
	}

	// 处理公共ppt里面的关于自个的ppt是否有配置权限的字段数据变更
	for k, publicList := range ret.PublicList {
		for kk, pptInfo := range publicList.PptList {
			// 是否有过权限配置
			if _, ok := myGrantPPtIdMap[int(pptInfo.PptId)]; ok {
				pptInfo.IsGrant = 1
			}
			publicList.PptList[kk] = pptInfo
		}
		ret.PublicList[k] = publicList
	}

	for k, privateList := range ret.PrivateList {
		for kk, pptInfo := range privateList.PptList {
			// 是否有过权限配置
			if _, ok := myGrantPPtIdMap[int(pptInfo.PptId)]; ok {
				pptInfo.IsGrant = 1
			}
			privateList.PptList[kk] = pptInfo
		}
		ret.PrivateList[k] = privateList
	}

	return
	//则过滤空文件夹
	//公共ppt
	pubList := make([]*ppt_english.RespGroupListItem, 0)
	for _, v := range ret.PublicList {
		if len(v.PptList) > 0 {
			pubList = append(pubList, v)
		}
	}
	ret.PublicList = pubList

	// 私有ppt
	priList := make([]*ppt_english.RespGroupListItem, 0)
	for _, v := range ret.PrivateList {
		if len(v.PptList) > 0 {
			priList = append(priList, v)
		}
	}
	ret.PrivateList = priList
	return
}

// ShareSingleGroupPptEnglishEnglish 共享单个ppt/取消共享单个ppt，返回共享状态
// @Author roc
// @Time 2022-08-29 15:22:20
func ShareSingleGroupPptEnglish(pptId int, adminId int) (pptInfo *ppt_english.PptEnglish, err error) {
	//判断当前登录者是否有共享的权限
	pptInfo, err = ppt_english.GetPptEnglishById(pptId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = errors.New("当前目录下的ppt不存在")
			return
		}
		err = errors.New("目录下的ppt查询出错:" + err.Error())
		return
	}
	if pptInfo.AdminId != adminId {
		err = errors.New("该Ppt不是本人创建")
		return
	}

	//判断当前的共享状态
	if pptInfo.IsShare > 0 {
		pptInfo.IsShare = 0
		err = pptInfo.Update([]string{"IsShare"})
		if err != nil {
			err = errors.New(err.Error())
			return
		}
	} else {
		pptInfo.IsShare = 1
		err = pptInfo.Update([]string{"IsShare"})
		if err != nil {
			err = errors.New(err.Error())
			return
		}
	}
	return
}

func GetMyPptEnglishList(adminId int, keyword string) (ret ppt_english.RespGroupPptList, err error) {
	list := make([]*ppt_english.RespGroupPptListItem, 0)
	ret.List = list

	var condition string
	var pars []interface{}

	condition += ` AND admin_id=? `
	pars = append(pars, adminId)

	if keyword != `` {
		condition += ` AND (title LIKE ? OR admin_real_name LIKE ? ) `
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	}
	pptList, err := ppt_english.GetAllPptEnglishList(condition, pars)

	if len(pptList) <= 0 {
		return
	}

	for _, v := range pptList {
		tmpV := &ppt_english.RespGroupPptListItem{
			GroupPptId:    int64(v.PptId),
			PptId:         int64(v.PptId),
			TemplateType:  v.TemplateType,
			BackgroundImg: v.BackgroundImg,
			Title:         v.Title,
			PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
			PptModifyTime: v.ModifyTime.Format(utils.FormatDateTime),
			AdminId:       v.AdminId,
			AdminRealName: v.AdminRealName,
			IsSingleShare: v.IsShare,
			PptxUrl:       v.PptxUrl,
			ReportId:      v.ReportId,
			ReportCode:    v.ReportCode,
			PublishTime:   utils.DealDateTimeZero(v.PublishTime, utils.FormatDateTime),
		}
		list = append(list, tmpV)
	}

	ret.List = list
	ret.Total = len(list)
	return
}

// GetSharePptList 公共目录下的ppt列表
// @Author roc
// @Time 2022-08-29 16:27:59
func GetSharePptEnglishList(adminId int, keyword string, isPrivate bool) (ret ppt_english.RespGroupPptList, err error) {
	list := make([]*ppt_english.RespGroupPptListItem, 0)
	ret.List = list

	var condition string
	var pars []interface{}

	// 公开的ppt
	condition += ` AND is_share=? `
	if isPrivate {
		pars = append(pars, 0)
	} else {
		pars = append(pars, 1)
	}

	if adminId > 0 {
		condition += ` AND admin_id=? `
		pars = append(pars, adminId)
	}
	if keyword != `` {
		condition += ` AND (title LIKE ? OR admin_real_name LIKE ? ) `
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	}
	pptList, err := ppt_english.GetAllPptEnglishList(condition, pars)

	if len(pptList) <= 0 {
		return
	}

	for _, v := range pptList {
		tmpV := &ppt_english.RespGroupPptListItem{
			GroupPptId:    int64(v.PptId),
			PptId:         int64(v.PptId),
			TemplateType:  v.TemplateType,
			BackgroundImg: v.BackgroundImg,
			Title:         v.Title,
			PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
			PptModifyTime: v.ModifyTime.Format(utils.FormatDateTime),
			AdminId:       v.AdminId,
			AdminRealName: v.AdminRealName,
			IsSingleShare: v.IsShare,
			PptxUrl:       v.PptxUrl,
			ReportId:      v.ReportId,
			ReportCode:    v.ReportCode,
			PublishTime:   utils.DealDateTimeZero(v.PublishTime, utils.FormatDateTime),
		}
		list = append(list, tmpV)
	}

	ret.List = list
	ret.Total = len(list)
	return
}

// GetGrantPptList 公共目录下的ppt列表
// @Author roc
// @Time 2022-09-05 15:50:25
func GetGrantPptEnglishList(adminId int, keyword, sourceType string) (ret ppt_english.RespGroupPptList, err error) {
	list := make([]*ppt_english.RespGroupPptListItem, 0)
	ret.List = list

	var condition string
	var pars []interface{}

	switch sourceType {
	case "my":
		condition += ` AND a.admin_id = ? `
		pars = append(pars, adminId)
	case "other":
		condition += ` AND a.admin_id != ? AND (b.department_id = 1 OR b.grant_admin_id = ?) `
		pars = append(pars, adminId, adminId)
	default:
		err = errors.New("无效的来源")
		return
	}

	if keyword != `` {
		condition += ` AND a.title LIKE ? `
		pars = utils.GetLikeKeywordPars(pars, keyword, 1)
	}

	pptList, err := ppt_english.GetGrantList(condition, pars)
	if err != nil {
		return
	}
	if len(pptList) <= 0 {
		return
	}

	for _, v := range pptList {
		tmpV := &ppt_english.RespGroupPptListItem{
			GroupPptId:    int64(v.PptId),
			PptId:         int64(v.PptId),
			TemplateType:  v.TemplateType,
			BackgroundImg: v.BackgroundImg,
			Title:         v.Title,
			PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
			PptModifyTime: v.ModifyTime.Format(utils.FormatDateTime),
			AdminId:       v.AdminId,
			AdminRealName: v.AdminRealName,
			PptVersion:    v.PptVersion,
			IsSingleShare: v.IsShare,
			PptxUrl:       v.PptxUrl,
			ReportId:      v.ReportId,
			ReportCode:    v.ReportCode,
			PublishTime:   utils.DealDateTimeZero(v.PublishTime, utils.FormatDateTime),
		}
		list = append(list, tmpV)
	}

	ret.List = list
	ret.Total = len(list)
	return
}

// GetEnglishCopyUsableTitle 根据原标题获取复制/转换可用的标题
func GetEnglishCopyUsableTitle(title string) (newTitle string, err error) {
	if title == "" {
		return
	}
	// 标题列表
	titles, e := ppt_english.GetPPTTitleList()
	if e != nil {
		err = errors.New("获取英文PPT标题列表失败, Err: " + e.Error())
		return
	}
	if !utils.InArrayByStr(titles, title) {
		newTitle = title
		return
	}
	// 新标题
	titleFormat := title + "(%d)"
	for i := 1; i < 999; i++ {
		newTitle = fmt.Sprintf(titleFormat, i)
		if !utils.InArrayByStr(titles, newTitle) {
			return
		}
	}
	return
}

// SearchEnglishPptList PPT搜索(我的/公开PPT)
func SearchEnglishPptList(adminId int, keyword string) (ret ppt_english.RespGroupPptList, err error) {
	list := make([]*ppt_english.RespGroupPptListItem, 0)
	ret.List = list

	var condition string
	var pars []interface{}

	// 公开的PPT或是我的非公开PPT
	condition += ` AND (is_share = 1 OR (admin_id = ? AND is_share = 0)) `
	pars = append(pars, adminId)

	if keyword != `` {
		kw := fmt.Sprint("%", keyword, "%")
		condition += ` AND (title LIKE ? OR admin_real_name LIKE ? ) `
		pars = append(pars, kw, kw)
	}
	pptList, err := ppt_english.GetAllPptEnglishList(condition, pars)

	if len(pptList) <= 0 {
		return
	}

	for _, v := range pptList {
		tmpV := &ppt_english.RespGroupPptListItem{
			GroupPptId:    int64(v.PptId),
			PptId:         int64(v.PptId),
			TemplateType:  v.TemplateType,
			BackgroundImg: v.BackgroundImg,
			Title:         v.Title,
			PptCreateTime: v.CreateTime.Format(utils.FormatDateTime),
			AdminId:       v.AdminId,
			AdminRealName: v.AdminRealName,
			IsSingleShare: v.IsShare,
			PptxUrl:       v.PptxUrl,
			ReportId:      v.ReportId,
			ReportCode:    v.ReportCode,
		}
		list = append(list, tmpV)
	}

	ret.List = list
	ret.Total = len(list)
	return
}