eta_api/controllers/ppt_v2.go

package controllers

import (
	"encoding/json"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/company"
	"eta_gn/eta_api/services"
	"eta_gn/eta_api/services/ppt"
	"eta_gn/eta_api/utils"
	"fmt"
	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"
	"os"
	"path"
	"strconv"
	"strings"
	"time"

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

// PptV2Controller 新版ppt模块
type PptV2Controller struct {
	BaseAuthController
}

// PptV2CommonController 新版ppt公共模块
type PptV2CommonController struct {
	BaseCommonController
}

// ListPpt
// @Title 获取ppt列表
// @Description 获取ppt列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Success 200 {object} models.PptV2ListResp
// @router /list [get]
func (this *PptV2Controller) ListPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyWord := this.GetString("KeyWord")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = utils.StartIndex(currentIndex, pageSize)

	var condition string
	var pars []interface{}

	if keyWord != "" {
		condition += ` AND (title LIKE ? OR admin_real_name LIKE ? ) `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 2)
	}
	total, err := models.GetPptV2ListCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, err := models.GetPptV2List(condition, pars, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	lenList := len(list)
	for i := 0; i < lenList; i++ {
		adminId := list[i].AdminId
		if adminId == sysUser.AdminId || sysUser.Role == "admin" {
			list[i].IsAuth = true
		} else {
			list[i].IsAuth = false
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.PptV2ListResp)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// AddPpt
// @Title 新增ppt
// @Description 新增ppt接口
// @Param	request	body models.AddPptV2Req true "type json string"
// @Success 200 Ret=200 新增成功
// @router /add [post]
func (this *PptV2Controller) AddPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.AddPptV2Req
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.FirstPage.Title == "" {
		br.Msg = "标题不能为空"
		return
	}

	var newId int64
	var msg string
	if req.PptId <= 0 {
		if req.GroupId == 0 {
			br.Msg = "请输入目录ID"
			return
		}
		//item, err := models.GetPptV2ByTitleAndId(req.FirstPage.Title, this.SysUser.AdminId)
		//if err != nil && !utils.IsErrNoRow(err) {
		//	br.Msg = "获取数据异常！"
		//	br.ErrMsg = "获取数据异常，Err:" + err.Error()
		//	return
		//}
		//if item != nil && item.PptId > 0 && item.PptId != int(req.PptId) {
		//	br.Msg = "标题已存在，不可重复添加"
		//	br.IsSendEmail = false
		//	return
		//}
		pptInfo := &models.PptV2{
			//PptId:         0,
			TemplateType:  req.FirstPage.TemplateType,
			BackgroundImg: req.FirstPage.ImgUrl,
			Title:         req.FirstPage.Title,
			ReportType:    req.FirstPage.ReportType,
			PptDate:       req.FirstPage.PptDate,
			Content:       req.Content,
			CoverContent:  req.CoverContent,
			CreateTime:    time.Now(),
			ModifyTime:    time.Now(),
			AdminId:       this.SysUser.AdminId,
			AdminRealName: this.SysUser.RealName,
			PptVersion:    2,
			TitleSetting:  req.TitleSetting,
		}
		newId, err = models.AddPptV2(pptInfo)
		if err != nil {
			br.Msg = "新增失败"
			br.ErrMsg = "新增失败,Err:" + err.Error()
			return
		}
		//新增ppt和目录映射
		_, err = ppt.AddGroupPptMapping(newId, req.GroupId, this.SysUser.AdminId, this.SysUser.RealName)
		if err != nil {
			br.Msg = err.Error()
			return
		}
		msg = "新增成功"
	} else {
		newId = req.PptId

		pptInfo, err := models.GetPptV2ById(int(req.PptId))
		if err != nil {
			br.Msg = "信息获取失败"
			br.ErrMsg = "信息获取失败,Err:" + err.Error()
			return
		}
		pptInfo.TemplateType = req.FirstPage.TemplateType
		pptInfo.BackgroundImg = req.FirstPage.ImgUrl
		pptInfo.Title = req.FirstPage.Title
		pptInfo.ReportType = req.FirstPage.ReportType
		pptInfo.PptDate = req.FirstPage.PptDate
		pptInfo.Content = req.Content
		pptInfo.CoverContent = req.CoverContent
		pptInfo.ModifyTime = time.Now()
		pptInfo.TitleSetting = req.TitleSetting
		err = pptInfo.Update([]string{"TemplateType", "BackgroundImg", "Title", "ReportType", "PptDate", "Content", "ModifyTime", "CoverContent", "TitleSetting"})

		msg = "保存成功"
	}
	resp := models.AddPptResp{
		PptId: newId,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = resp
}

// EditPpt
// @Title 编辑ppt
// @Description 编辑ppt接口
// @Param	request	body models.AddPptV2Req true "type json string"
// @Success 200 Ret=200 编辑成功
// @router /edit [post]
func (this *PptV2Controller) EditPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.AddPptV2Req
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.FirstPage.Title == "" {
		br.Msg = "标题不能为空"
		return
	}
	//item, err := models.GetPptV2ByTitleAndId(req.FirstPage.Title, this.SysUser.AdminId)
	//if err != nil && !utils.IsErrNoRow(err) {
	//	br.Msg = "获取数据异常！"
	//	br.ErrMsg = "获取数据异常，Err:" + err.Error()
	//	return
	//}
	//if item != nil && item.PptId > 0 && item.PptId != int(req.PptId) {
	//	br.Msg = "标题已存在，不可重复添加"
	//	br.IsSendEmail = false
	//	return
	//}
	pptInfo, err := models.GetPptV2ById(int(req.PptId))
	if err != nil {
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + err.Error()
		return
	}

	// 协作人权限
	if pptInfo.AdminId != this.SysUser.AdminId {
		if pptInfo.CollaborateType != utils.ReportWriteTypeGroup {
			br.Msg = "非协作人无权操作"
			return
		}
		if pptInfo.CollaborateUsers == "" {
			br.Msg = "非协作人无权操作"
			return
		}
		partnerArr := strings.Split(pptInfo.CollaborateUsers, ",")
		if !utils.InArrayByStr(partnerArr, fmt.Sprint(this.SysUser.AdminId)) {
			br.Msg = "非协作人无权操作"
			return
		}
	}

	// 判断权限
	//if pptInfo.AdminId != this.SysUser.AdminId {
	//	_, err := models.GetPPtGrantConf(pptInfo.PptId, this.SysUser.AdminId)
	//	if err != nil {
	//		if utils.IsErrNoRow(err) {
	//			br.Msg = `该PPT已取消共享，保存失败`
	//			br.ErrMsg = `该PPT已取消共享，保存失败`
	//			br.IsSendEmail = false
	//		} else {
	//			br.Msg = `保存失败`
	//			br.ErrMsg = `保存失败，ERR：` + err.Error()
	//		}
	//		return
	//	}
	//}

	// 修改
	pptInfo.TemplateType = req.FirstPage.TemplateType
	pptInfo.BackgroundImg = req.FirstPage.ImgUrl
	pptInfo.Title = req.FirstPage.Title
	pptInfo.ReportType = req.FirstPage.ReportType
	pptInfo.PptDate = req.FirstPage.PptDate
	pptInfo.Content = req.Content
	pptInfo.CoverContent = req.CoverContent
	pptInfo.ModifyTime = time.Now()
	pptInfo.TitleSetting = req.TitleSetting
	err = pptInfo.Update([]string{"TemplateType", "BackgroundImg", "Title", "ReportType", "PptDate", "Content", "ModifyTime", "CoverContent", "TitleSetting"})
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑失败,Err:" + err.Error()
		return
	}

	//pptMap, err := models.GetPptMappingByPptId(req.PptId)
	//if err != nil {
	//	br.Msg = `该PPT信息不存在, 保存失败`
	//	br.ErrMsg = `该PPT信息不存在, 保存失败, Err` + err.Error()
	//	br.IsSendEmail = false
	//	return
	//}
	//pptMapList, err := models.GetPptMappingListByGroupId(pptMap.GroupId)
	//if err != nil {
	//	br.ErrMsg = "PPT目录信息异常"
	//	return
	//}
	//count, err := models.GetPptMappingByGroupPptCountId(pptMap.GroupPptId, this.SysUser.AdminId)
	//if err != nil {
	//	br.Msg = "查询映射关系失败"
	//	br.ErrMsg = "查询映射关系失败, 保存失败, Err:" + err.Error()
	//	return
	//}
	//if !pptMap.IsMoved && len(pptMapList) > 1 && count > 0 {
	//	// 如果没有人为移动位置, 默认将当前ppt置顶
	//	err = ppt.MoveGroupPpt(pptMap.GroupId, pptMap.GroupPptId, pptMapList[0].GroupPptId, 0, this.SysUser.AdminId)
	//	if err != nil {
	//		br.Msg = err.Error()
	//		br.ErrMsg = "移动失败,Err:" + err.Error()
	//		return
	//	}
	//}

	// 日志记录
	{
		logInfo := &models.PptV2SaveLog{
			PptId:         pptInfo.PptId,
			TemplateType:  pptInfo.TemplateType,
			BackgroundImg: pptInfo.BackgroundImg,
			Title:         pptInfo.Title,
			ReportType:    pptInfo.ReportType,
			PptDate:       pptInfo.PptDate,
			Content:       pptInfo.Content,
			CoverContent:  pptInfo.CoverContent,
			AdminId:       this.SysUser.AdminId,
			AdminRealName: this.SysUser.RealName,
			CreateTime:    time.Now(),
		}
		_, err = models.AddPptV2SaveLog(logInfo)
	}

	resp := models.AddPptResp{
		PptId: req.PptId,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
	br.IsAddLog = true
	br.Data = resp
}

// DeletePpt
// @Title 删除ppt
// @Description 删除ppt接口
// @Param	request	body models.DeletePptV2Req true "type json string"
// @Success 200 Ret=200 删除成功
// @router /delete [post]
func (this *PptV2Controller) DeletePpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DeletePptV2Req
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.PptId <= 0 {
		br.Msg = "参数错误"
		return
	}
	pptInfo, err := models.GetPptV2ById(req.PptId)
	if err != nil {
		br.Msg = "ppt不存在"
		return
	}
	if pptInfo.AdminId != this.SysUser.AdminId {
		br.Msg = "无权删除"
		return
	}
	if pptInfo.ReportSource != utils.ReportSourceLocal {
		br.Msg = "仅允许删除系统内部报告"
		return
	}

	err = models.DeletePptV2(req.PptId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败,Err:" + err.Error()
		return
	}
	//如果该ppt存在单个共享记录，则删除共享
	err = ppt.DeleteGroupPpt(req.PptId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败,Err:" + err.Error()
		return
	}

	// 更新报告计数
	go func() {
		_ = services.UpdateClassifyReportNum(pptInfo.ClassifyId)
	}()

	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "删除成功"
}

// DetailPpt
// @Title 获取ppt详情
// @Description 获取ppt详情接口
// @Param   PptId   query   int  true       "PptId"
// @Success 200 {object} models.PptV2
// @router /detail [get]
func (this *PptV2Controller) DetailPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	pptId, _ := this.GetInt("PptId")

	pptInfo, err := models.GetPptV2ById(pptId)
	if err != nil {
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + err.Error()
		return
	}

	// 权限
	var hasAuth bool
	if pptInfo.AdminId == sysUser.AdminId {
		hasAuth = true
	}
	if hasAuth == false && pptInfo.CollaborateUsers != "" {
		authorArr := strings.Split(pptInfo.CollaborateUsers, ",")
		strId := strconv.Itoa(sysUser.AdminId)
		if utils.InArrayByStr(authorArr, strId) {
			hasAuth = true
		}
	}

	// 编辑中
	editor, e := services.UpdatePptEditing(pptId, 0, sysUser.AdminId, sysUser.RealName, false)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新编辑状态失败, err: " + e.Error()
		return
	}
	resp := new(models.PPTDetailResp)
	resp.PptV2 = pptInfo
	resp.Editor = editor
	resp.HasAuth = hasAuth

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// DownloadPptx
// @Title ppt下载
// @Description ppt下载
// @Param   PptId   query   int  true       "PptId"
// @Success 200 下载成功
// @router /downloadpptx [get]
func (this *PptV2CommonController) DownloadPptx() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pptId, err := this.GetInt("PptId")
	if err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "获取，pptId，Err:" + err.Error()
		return
	}
	pptInfo, err := models.GetPptV2ById(pptId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	filePath := pptInfo.PptxUrl
	fileName := pptInfo.Title + ".pptx"
	this.Ctx.Output.Download(filePath, fileName)
	br.Success = true
	br.Ret = 200
	br.Msg = "下载成功"
	return
}

// Publish
// @Title 发布接口
// @Description 发布接口
// @Param	request	body models.SavePptV2PathReq true "type json string"
// @Success Ret=200 发布成功
// @router /publish [post]
func (this *PptV2Controller) Publish() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.SavePptV2PathReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	pptId := req.PptId
	if pptId <= 0 {
		br.Msg = "参数错误"
		return
	}
	req.PptxUrl = strings.TrimSpace(req.PptxUrl)
	if req.PptxUrl == "" {
		br.Msg = "文件地址为空"
		return
	}
	//err = models.EditPptV2Path(pptId, req.PptxUrl)
	//if err != nil {
	//	br.Msg = "发布失败"
	//	br.ErrMsg = "发布失败，Err:" + err.Error()
	//	return
	//}

	pptItem, e := models.GetPptV2ById(pptId)
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "PPT不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("获取PPT失败, %v", e)
		return
	}
	stateOrigin := pptItem.State

	var updateCols []string
	updateCols = append(updateCols, "PptxUrl", "ModifyTime")
	pptItem.PptxUrl = req.PptxUrl
	pptItem.ModifyTime = time.Now()

	// 本地PPT(不加限制, 想发布就发布)
	if pptItem.ReportSource == utils.ReportSourceLocal {
		updateCols = append(updateCols, "State", "PublishTime")
		pptItem.State = models.ReportStatePublished
		pptItem.PublishTime = time.Now()
	}

	// 外部PPT
	if pptItem.ReportSource == utils.ReportSourceOuter {
		// 报告状态
		if pptItem.OutReportId == "" {
			br.Msg = "PPT异常"
			br.ErrMsg = fmt.Sprintf("PPT外部报告ID为空, ID: %d", pptId)
			return
		}
		if pptItem.State != models.ReportStateWaitSubmit && pptItem.State != models.ReportStateRefused {
			br.Msg = "状态异常, 不允许提交"
			br.ErrMsg = fmt.Sprintf("PPT报告状态异常, %d", pptItem.State)
			return
		}
		updateCols = append(updateCols, "SubmitTime", "State")
		pptItem.SubmitTime = time.Now()
		pptItem.State = models.ReportStateWaitApprove
	}

	// 更新PPT
	if e = pptItem.Update(updateCols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = fmt.Sprintf("更新PPT失败, %v", e)
		return
	}

	//添加发布记录
	{
		record := new(models.PptV2PublishRecord)
		record.CreateTime = time.Now()
		record.PptId = pptId
		record.PptUrl = req.PptxUrl
		go models.AddPptV2PublishRecord(record)
	}

	// 回调智力共享审批
	go func() {
		if pptItem.ReportSource != utils.ReportSourceOuter {
			return
		}
		outId, _ := strconv.Atoi(pptItem.OutReportId)
		// 若回调失败, 则恢复提交前状态(先这么处理吧，允许再次提交)
		e = services.OuterReportCallBack(outId, pptItem.Title, req.PptxUrl, ".pptx")
		if e != nil {
			pptItem.State = stateOrigin
			_ = pptItem.Update([]string{"State"})
		}
	}()

	br.Ret = 200
	br.Success = true
	br.Msg = "发布成功"
	br.IsAddLog = true
	return
}

// PptUpload
// @Title ppt上传
// @Description ppt上传
// @Param   PptId   query   int  true       "PptId"
// @Success 200 新增成功
// @router /pptUpload [post]
func (this *PptV2Controller) PptUpload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pptId, _ := this.GetInt("PptId", 0)
	if pptId <= 0 {
		br.Msg = "参数错误"
		return
	}
	_, err := models.GetPptV2ById(pptId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取PPT详情失败，Err:" + err.Error()
		return
	}
	f, h, err := this.GetFile("file")
	if err != nil {
		br.Msg = "获取资源信息失败"
		br.ErrMsg = "获取资源信息失败,Err:" + err.Error()
		return
	}
	defer func() {
		_ = f.Close()
	}()
	uploadFileName := h.Filename //上传的文件名
	ext := path.Ext(h.Filename)
	dateDir := time.Now().Format("20060102")
	uploadDir := utils.STATIC_DIR + "ppt/" + dateDir
	err = os.MkdirAll(uploadDir, utils.DIR_MOD)
	if err != nil {
		br.Msg = "存储目录创建失败"
		br.ErrMsg = "存储目录创建失败,Err:" + err.Error()
		return
	}
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ext
	fpath := uploadDir + "/" + fileName

	if err = this.SaveToFile("file", fpath); err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	defer func() {
		_ = os.Remove(fpath)
	}()
	hzUploadDir := utils.RESOURCE_DIR + "ppt/"
	savePptxToOssPath := hzUploadDir + time.Now().Format("200601/20060102/")

	//pptName := strings.Replace(pptItem.Title, "\n", "", -1)
	//pptName = strings.TrimSuffix(pptName, " ")
	pptName := utils.GetRandStringNoSpecialChar(28)
	savePptxToOssPath += pptName + ".pptx"

	//上传到阿里云 和 minio
	pptxUrl := ``
	ossClient := services.NewOssClient()
	if ossClient == nil {
		br.Msg = "上传失败"
		br.ErrMsg = "初始化OSS服务失败"
		return
	}
	pptxUrl, err = ossClient.UploadFile(fileName, fpath, savePptxToOssPath)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}

	resp := models.ResourceResp{
		ResourceUrl:  pptxUrl,
		ResourceName: uploadFileName,
	}

	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

// SaveLog
// @Title 定时ppt操作日志记录
// @Description 定时ppt操作日志记录
// @Param	request	body models.AddPptV2Req true "type json string"
// @Success 200 新增成功
// @router /saveLog [post]
func (this *PptV2Controller) SaveLog() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.AddPptV2Req
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.FirstPage.Title == "" {
		br.Msg = "标题不能为空"
		return
	}
	var pptContent []services.PPTContent
	err = json.Unmarshal([]byte(req.Content), &pptContent)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	// 获取ppt
	//item, err := models.GetPptV2ByTitleAndId(req.FirstPage.Title, this.SysUser.AdminId)
	//if err != nil && !utils.IsErrNoRow(err) {
	//	br.Msg = "获取数据异常！"
	//	br.ErrMsg = "获取数据异常，Err:" + err.Error()
	//	return
	//}
	//if item != nil && item.PptId > 0 && item.PptId != int(req.PptId) {
	//	br.Msg = "标题已存在，不可重复添加"
	//	br.IsSendEmail = false
	//	return
	//}

	//变更ppt内容
	pptItem, e := models.GetPptV2ById(int(req.PptId))
	if e != nil {
		if utils.IsErrNoRow(e) {
			br.Msg = "PPT已被删除, 请刷新页面"
			return
		}
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + e.Error()
		return
	}

	// 标记编辑状态
	if pptItem.PptId > 0 {
		_, e = services.UpdatePptEditing(pptItem.PptId, 1, sysUser.AdminId, sysUser.RealName, false)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "更新编辑状态失败, err: " + e.Error()
			return
		}
	}
	pptItem.TemplateType = req.FirstPage.TemplateType
	pptItem.BackgroundImg = req.FirstPage.ImgUrl
	pptItem.Title = req.FirstPage.Title
	pptItem.ReportType = req.FirstPage.ReportType
	pptItem.PptDate = req.FirstPage.PptDate
	pptItem.Content = req.Content
	pptItem.ModifyTime = time.Now()
	pptItem.TitleSetting = req.TitleSetting
	pptItem.PptPage = len(pptContent)
	err = pptItem.Update([]string{"TemplateType", "BackgroundImg", "Title", "ReportType", "PptDate", "Content", "ModifyTime", "TitleSetting", "ppt_page"})
	if err != nil {
		br.Msg = "自动保存失败"
		br.ErrMsg = fmt.Sprintf("自动保存PPT失败, ID: %d, Err: %v", pptItem.PptId, err)
		return
	}

	// 将更新后的PPT, 置顶
	//pptMap, err := models.GetPptMappingByPptId(int64(req.PptId))
	//if err != nil {
	//	br.Msg = `该PPT信息不存在, 保存失败`
	//	br.ErrMsg = `该PPT信息不存在, 保存失败, Err` + err.Error()
	//	br.IsSendEmail = false
	//	return
	//}
	//pptMapList, err := models.GetPptMappingListByGroupId(pptMap.GroupId)
	//if err != nil {
	//	br.ErrMsg = "PPT目录信息异常"
	//	return
	//}
	//count, err := models.GetPptMappingByGroupPptCountId(pptMap.GroupPptId, this.SysUser.AdminId)
	//if err != nil {
	//	br.Msg = "查询映射关系失败"
	//	br.ErrMsg = "查询映射关系失败, 保存失败, Err:" + err.Error()
	//	return
	//}
	//if !pptMap.IsMoved && len(pptMapList) > 1 && count > 0 {
	//	// 如果没有人为移动位置, 且当前用户有权限, 默认将当前ppt置顶
	//	err = ppt.MoveGroupPpt(pptMap.GroupId, pptMap.GroupPptId, pptMapList[0].GroupPptId, 0, this.SysUser.AdminId)
	//	if err != nil {
	//		br.Msg = err.Error()
	//		br.ErrMsg = "移动失败,Err:" + err.Error()
	//		return
	//	}
	//}

	//日志记录
	logInfo := &models.PptV2SaveLog{
		PptId:         int(req.PptId),
		TemplateType:  req.FirstPage.TemplateType,
		BackgroundImg: req.FirstPage.ImgUrl,
		Title:         req.FirstPage.Title,
		ReportType:    req.FirstPage.ReportType,
		PptDate:       req.FirstPage.PptDate,
		Content:       req.Content,
		CoverContent:  req.CoverContent,
		AdminId:       this.SysUser.AdminId,
		AdminRealName: this.SysUser.RealName,
		CreateTime:    time.Now(),
		TitleSetting:  req.TitleSetting,
	}
	_, e = models.AddPptV2SaveLog(logInfo)
	if e != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存PPT日志失败, Err: " + e.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
}

// GetConfig
// @Title 获取ppt配置
// @Description 获取ppt列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Success 200 {object} models.PptV2ListResp
// @router /config [get]
func (this *PptV2Controller) GetConfig() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	crmConfig, err := company.GetConfigDetailByCode("ppt_limit")
	if err != nil {
		br.Msg = "获取配置失败"
		br.ErrMsg = "获取配置失败"
		br.IsSendEmail = false
		return
	}
	resp := new(models.PptV2ConfigResp)

	err = json.Unmarshal([]byte(crmConfig.ConfigValue), resp)
	if err != nil {
		br.Msg = "获取配置失败"
		br.ErrMsg = "获取配置失败;err:" + err.Error()
		br.IsSendEmail = false
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ToReport
// @Title PPT转报告
// @Description PPT转报告
// @Param	request	body models.PPT2ReportReq true "type json string"
// @Success 200 Ret=200 转换成功
// @router /to_report [post]
func (this *PptV2Controller) ToReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.PPT2ReportReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.PptId == 0 {
		br.Msg = "参数有误"
		return
	}
	reportId, reportCode, msg, e := services.SavePPTReport(req.PptId, req.ClassifyId, req.Title, sysUser)
	if e != nil {
		br.Msg = msg
		br.ErrMsg = "PPT转报告失败, Err: " + e.Error()
		return
	}

	resp := &models.PPT2ReportResp{
		ReportId:   reportId,
		ReportCode: reportCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "转换成功"
	br.IsAddLog = true
	br.Data = resp
}

// Grant
// @Title 分配ppt权限
// @Description 分配ppt权限接口
// @Param	request	body models.GrantPptReq true "type json string"
// @Success 200 Ret=200 分配成功
// @router /grant [post]
func (this *PptV2Controller) Grant() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.GrantPptReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.PptId <= 0 {
		br.Msg = "参数错误"
		return
	}

	// 查找ppt信息
	pptInfo, err := models.GetPptV2ById(req.PptId)
	if err != nil {
		br.Msg = "ppt不存在"
		return
	}
	if pptInfo.AdminId != this.SysUser.AdminId {
		br.Msg = "无权配置"
		return
	}

	// 分配
	err, errMsg := ppt.GrantPpt(req.PptId, req.GrantType, req.AdminIdStr, this.SysUser.AdminId)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = errMsg + ";Err:" + err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "分配成功"
}

// CancelGrant
// @Title 取消分配ppt权限
// @Description 取消分配ppt权限
// @Param	request	body models.DeletePptV2Req true "type json string"
// @Success 200 Ret=200 分配成功
// @router /grant/cancel [post]
func (this *PptV2Controller) CancelGrant() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DeletePptV2Req
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.PptId <= 0 {
		br.Msg = "参数错误"
		return
	}

	// 查找ppt信息
	pptInfo, err := models.GetPptV2ById(req.PptId)
	if err != nil {
		br.Msg = "ppt不存在"
		return
	}
	if pptInfo.AdminId != this.SysUser.AdminId {
		br.Msg = "无权取消配置"
		return
	}

	// 分配
	err, errMsg := ppt.DeleteGrantPpt(req.PptId)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = errMsg + ";Err:" + err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "取消成功"
}

// GrantInfo
// @Title 获取分配ppt权限详情
// @Description 获取分配ppt权限详情接口
// @Param   PptId   query   int  true       "ppt的id"
// @Success 200 {object} models.GrantInfoResp
// @router /grant/info [get]
func (this *PptV2Controller) GrantInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pptId, _ := this.GetInt("PptId")
	if pptId <= 0 {
		br.Msg = "参数错误"
		return
	}

	// 查找ppt信息
	pptInfo, err := models.GetPptV2ById(pptId)
	if err != nil {
		br.Msg = "ppt不存在"
		return
	}
	if pptInfo.AdminId != this.SysUser.AdminId {
		br.Msg = "无权配置"
		return
	}

	pptGrantInfoList, err := models.GetPPtGrantInfo(pptId)
	if err != nil {
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + err.Error()
		return
	}

	if len(pptGrantInfoList) <= 0 {
		br.Msg = "未配置"
		br.IsSendEmail = false
		return
	}
	grantType := 0
	var adminIdStr string
	if pptGrantInfoList[0].DepartmentId > 0 { //分配类型;1：全部ficc研究员；2：指定成员
		grantType = 1
	} else {
		grantType = 2
		adminIdsList := make([]string, 0)
		for _, v := range pptGrantInfoList {
			adminIdsList = append(adminIdsList, strconv.Itoa(int(v.GrantAdminId)))
		}
		adminIdStr = strings.Join(adminIdsList, ",")
	}

	br.Ret = 200
	br.Success = true
	br.Data = models.GrantInfoResp{
		PptId:      pptId,
		GrantType:  grantType,
		AdminIdStr: adminIdStr,
	}
	br.Msg = "分配成功"
}

// TitleCheck
// @Title 校验标题是否重复
// @Description 校验标题是否重复接口
// @Param   Title   query   int  true       "标题"
// @Success 200 Ret=200 编辑成功
// @router /titleCheck [get]
func (this *PptV2Controller) TitleCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	title := this.GetString("Title")
	pptId, _ := this.GetInt("PptId")
	if title == "" {
		br.Msg = "标题不能为空"
		return
	}
	item, err := models.GetPptV2ByTitleAndId(title, this.SysUser.AdminId)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取数据异常！"
		br.ErrMsg = "获取数据异常，Err:" + err.Error()
		return
	}
	if item != nil && item.PptId > 0 && item.PptId != pptId {
		br.Msg = "标题已存在，不可重复添加"
		br.IsSendEmail = false
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "校验成功"
}

// Editing
// @Title 标记/查询编辑状态
// @Description 标记/查询编辑状态
// @Param	request	body models.PPTEditingReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /editing [post]
func (this *PptV2Controller) Editing() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.PPTEditingReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.PptId <= 0 {
		br.Msg = "参数有误"
		return
	}
	if req.Status < 0 {
		br.Msg = "标记状态异常"
		return
	}

	editor, e := services.UpdatePptEditing(req.PptId, req.Status, sysUser.AdminId, sysUser.RealName, false)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新编辑状态失败, err: " + e.Error()
		return
	}

	br.Data = editor
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}