hz_crm_api/controllers/ppt.go

package controllers

import (
	"encoding/json"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/http"
	"github.com/rdlucklib/rdluck_tools/paging"
	"hongze/hz_crm_api/models"
	"hongze/hz_crm_api/services"
	"hongze/hz_crm_api/utils"
	"image"
	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"
	"os"
	"os/exec"
	"strings"
	"time"
)

// 报告
type PptController struct {
	BaseAuthController
}

// @Title 获取ppt列表
// @Description 获取ppt列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Success 200 {object} models.ReportListResp
// @router /list [get]
func (this *PptController) 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 '%` + keyWord + `%' OR admin_real_name LIKE '%` + keyWord + `%' ) `
	}
	total, err := models.GetPptListCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, err := models.GetPptList(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.PptListResp)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 新增ppt
// @Description 新增ppt接口
// @Param	request	body models.AddPptReq true "type json string"
// @Success 200 Ret=200 新增成功
// @router /add [post]
func (this *PptController) AddPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.AddPptReq
	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 {
		item, err := models.GetPptByTitle(req.FirstPage.Title)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取数据异常！"
			br.ErrMsg = "获取数据异常，Err:" + err.Error()
			return
		}
		if item != nil {
			br.Msg = "标题已存在，不可重复添加"
			return
		}
		ppt := new(models.Ppt)
		ppt.Title = req.FirstPage.Title
		ppt.PptDate = req.FirstPage.PptDate
		ppt.ReportType = req.FirstPage.ReportType
		ppt.CreateTime = time.Now()
		ppt.ModifyTime = time.Now()
		ppt.AdminId = this.SysUser.AdminId
		ppt.AdminRealName = this.SysUser.RealName
		ppt.Version = 2
		newId, err = models.AddPpt(ppt)
		if err != nil {
			br.Msg = "新增失败"
			br.ErrMsg = "新增失败,Err:" + err.Error()
			return
		}

		firstPage := new(models.PptPages)
		firstPage.PptId = newId
		firstPage.Title = req.FirstPage.Title
		firstPage.ResourceId = "0"
		firstPage.Timestamp = 0
		firstPage.BackIndex = req.FirstPage.BackIndex
		_, err = models.AddPptPages(firstPage)

		if err != nil {
			br.Msg = "新增失败"
			br.ErrMsg = "新增章节失败,Err:" + err.Error()
			return
		}

		for _, v := range req.ContentPage {
			if v.ResourceId == "" {
				br.Msg = "图表参数错误"
				br.ErrMsg = "图表参数错误,ResourceId 等于0"
				return
			}

			count, _ := models.GetPptPagesContent(int(newId), v.ResourceId)
			if count <= 0 {
				page := new(models.PptPages)
				page.PptId = newId
				page.Title = v.Title
				page.ResourceId = v.ResourceId
				page.Timestamp = v.Timestamp
				page.CreateTime = time.Now()
				page.ModifyTime = time.Now()
				_, err = models.AddPptPages(page)
				if err != nil {
					br.Msg = "新增失败"
					br.ErrMsg = "新增章节失败,Err:" + err.Error()
					return
				}
			}
		}
		msg = "新增成功"
	} else {
		newId = req.PptId
		ppt := new(models.Ppt)
		ppt.PptId = int(req.PptId)
		ppt.Title = req.FirstPage.Title
		ppt.PptDate = req.FirstPage.PptDate
		ppt.ReportType = req.FirstPage.ReportType
		ppt.ModifyTime = time.Now()
		err = models.EditPpt(ppt)
		//删除ppt_pages
		err = models.DeletePptPages(req.PptId)
		if err != nil {
			br.Msg = "编辑失败"
			br.ErrMsg = "编辑失败,Err:" + err.Error()
			return
		}
		firstPage := new(models.PptPages)
		firstPage.PptId = newId
		firstPage.Title = req.FirstPage.Title
		firstPage.ResourceId = ""
		firstPage.Timestamp = 0
		firstPage.BackIndex = req.FirstPage.BackIndex
		_, err = models.AddPptPages(firstPage)

		if err != nil {
			br.Msg = "新增失败"
			br.ErrMsg = "新增章节失败,Err:" + err.Error()
			return
		}
		for _, v := range req.ContentPage {
			if v.ResourceId == "" {
				br.Msg = "图表参数错误"
				br.ErrMsg = "图表参数错误,ResourceId 等于 empty"
				return
			}
			count, _ := models.GetPptPagesContent(int(newId), v.ResourceId)
			if count <= 0 {
				page := new(models.PptPages)
				page.PptId = newId
				page.Title = v.Title
				page.ResourceId = v.ResourceId
				page.Timestamp = v.Timestamp
				page.CreateTime = time.Now()
				page.ModifyTime = time.Now()
				_, err = models.AddPptPages(page)
				if err != nil {
					br.Msg = "新增失败"
					br.ErrMsg = "新增章节失败,Err:" + err.Error()
					return
				}
			}
		}
		msg = "保存成功"
	}
	resp := new(models.AddPptResp)
	resp.PptId = newId
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = resp
}

// @Title 编辑ppt
// @Description 编辑ppt接口
// @Param	request	body models.EditPptReq true "type json string"
// @Success 200 Ret=200 编辑成功
// @router /edit [post]
func (this *PptController) EditPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.EditPptReq
	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.GetPptByTitle(req.FirstPage.Title)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取数据异常！"
		br.ErrMsg = "获取数据异常，Err:" + err.Error()
		return
	}
	if item != nil && item.PptId != int(req.PptId) {
		br.Msg = "标题已存在，不可重复添加"
		return
	}

	ppt := new(models.Ppt)
	ppt.PptId = int(req.PptId)
	ppt.Title = req.FirstPage.Title
	ppt.PptDate = req.FirstPage.PptDate
	ppt.ReportType = req.FirstPage.ReportType
	ppt.ModifyTime = time.Now()
	err = models.EditPpt(ppt)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑失败,Err:" + err.Error()
		return
	}
	newId := req.PptId
	//删除ppt_pages
	err = models.DeletePptPages(newId)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑失败,Err:" + err.Error()
		return
	}
	firstPage := new(models.PptPages)
	firstPage.PptId = newId
	firstPage.Title = req.FirstPage.Title
	firstPage.ResourceId = "0"
	firstPage.Timestamp = 0
	firstPage.BackIndex = req.FirstPage.BackIndex
	_, err = models.AddPptPages(firstPage)

	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "新增章节失败,Err:" + err.Error()
		return
	}

	for _, v := range req.ContentPage {
		if v.ResourceId == "" {
			br.Msg = "图表参数错误"
			br.ErrMsg = "图表参数错误,ResourceId 等于 empty"
			return
		}
		count, _ := models.GetPptPagesContent(int(newId), v.ResourceId)
		if count <= 0 {
			page := new(models.PptPages)
			page.PptId = newId
			page.Title = v.Title
			page.ResourceId = v.ResourceId
			page.Timestamp = v.Timestamp
			page.CreateTime = time.Now()
			page.ModifyTime = time.Now()
			_, err = models.AddPptPages(page)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "新增章节失败,Err:" + err.Error()
				return
			}
		}
	}

	resp := new(models.AddPptResp)
	resp.PptId = req.PptId
	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
	br.Data = resp
}

// @Title 删除ppt
// @Description 删除ppt接口
// @Param	request	body models.DeletePptReq true "type json string"
// @Success 200 Ret=200 编辑成功
// @router /delete [post]
func (this *PptController) DeletePpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DeletePptReq
	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
	}
	err = models.DeletePpt(req.PptId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "删除成功"
}

// @Title 新增ppt章节
// @Description 新增ppt章节接口
// @Param	request	body models.ContentPageItems true "type json string"
// @Success 200 Ret=200 编辑成功
// @router /addPptPages [post]
func (this *PptController) AddPptPages() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.ContentPageItems
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	page := new(models.PptPages)
	page.PptId = req.PptId
	page.Title = req.Title
	page.CreateTime = time.Now()
	page.ModifyTime = time.Now()
	page.ResourceId = req.ResourceId
	_, err = models.AddPptPages(page)
	if err != nil {
		br.Msg = "新增失败"
		br.ErrMsg = "新增失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "新增成功"
}

// @Title 获取ppt详情
// @Description 获取ppt详情接口
// @Param   PptId   query   int  true       "ppt_id"
// @Success 200 {object} models.ReportListResp
// @router /detail [get]
func (this *PptController) DetailPpt() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pptId, _ := this.GetInt("PptId")
	ppt, err := models.GetPptById(pptId)
	if err != nil {
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + err.Error()
		return
	}
	pptPages, err := models.GetPptPagesById(pptId)
	if err != nil {
		br.Msg = "信息获取失败"
		br.ErrMsg = "信息获取失败,Err:" + err.Error()
		return
	}
	resp := new(models.PptDetailResp)
	resp.Ppt = ppt
	resp.PptPages = pptPages
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 图片上传
// @Description 图片上传接口
// @Param   Img   query   string  true       "图片base64字符串"
// @Param   ResourceId   query   int  true       "策略组提供的资源id"
// @Param   PptId   query   int  true       "PptId"
// @Param   PptPagesId   query   int  true       "PptPagesId"
// @Success 200 新增成功
// @router /base64Upload [post]
func (this *PptCommonController) Base64Upload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	imgData := this.GetString("Img")
	resourceId := this.GetString("ResourceId")
	pptId, err := this.GetInt("PptId")
	if err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "获取，pptId，Err:" + err.Error()
		return
	}

	pptPagesId, err := this.GetInt("PptPagesId")
	if err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "获取，策略组提供的资源id失败，Err:" + err.Error()
		return
	}

	uploadDir := "static/images/"
	if !utils.FileIsExist(uploadDir) {
		err = os.MkdirAll(uploadDir, 777)
		if err != nil {
			br.Msg = "存储目录创建失败"
			br.ErrMsg = "存储目录创建失败,Err:" + err.Error()
			return
		}
	}

	var saveToOssPath string
	randStr := utils.GetRandStringNoSpecialChar(28)
	var fileName, savePath, outFileName, resourceUrl string
	if resourceId == "0" { //首页
		imgData = strings.Replace(imgData, "data:image/png;base64,", "", -1)
		fileName = randStr + ".png"
		savePath = uploadDir + "/" + fileName
		err = utils.SaveBase64ToFile(imgData, savePath)
		if err != nil {
			br.Msg = "图片保存失败"
			br.ErrMsg = "图片保存失败,Err:" + err.Error()
			return
		}
		hzUploadDir := "static/images/"
		saveToOssPath = hzUploadDir + time.Now().Format("200601/20060102/")
		outFileName = randStr + ".png"
		saveToOssPath += outFileName
		//上传到阿里云
		err = services.UploadFileToAliyun("", savePath, saveToOssPath)
		if err != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + err.Error()
			return
		}
		fileHost := "https://hzstatic.hzinsights.com/"
		resourceUrl = fileHost + saveToOssPath
	} else if resourceId == "-1" {
		resourceUrl = "https://hzstatic.hzinsights.com/static/ppt_default.png"
	} else {
		//param := url.Values{}
		//param.Add("Sign", "dIGi2M0VN21s3dKS")
		//param.Add("Img", imgData)
		//svgToPngUrl := `http://images.hzinsights.com:8040/v1/image/svg_to_png`
		//respBody, err := http.Post(svgToPngUrl, param.Encode(), "")
		//if err != nil || strings.Contains(string(respBody), "<html>") {
		//	fmt.Println("post images:", string(respBody))
		//	if utils.RunMode == "debug" {
		//		svgToPngUrl = `http://139.196.136.213:8086/v1/image/svg_to_png`
		//	} else {
		//		svgToPngUrl = `http://172.19.173.231:8086/v1/image/svg_to_png`
		//	}
		//	respBody, err = http.Post(svgToPngUrl, param.Encode(), "")
		//	fmt.Println("post data_server:", string(respBody))
		//	if err != nil || strings.Contains(string(respBody), "<html>") {
		//		utils.FileLog.Info("svgToPngUrl:" + svgToPngUrl)
		//		utils.FileLog.Info("param:" + param.Encode())
		//		utils.FileLog.Info("svgToPngUrl Err:" + err.Error())
		//		utils.FileLog.Info("respBody:" + string(respBody))
		//		br.Msg = "文件上传失败"
		//		br.ErrMsg = "图片格式转换失败，Err:" + err.Error()
		//		return
		//	}
		//}
		//respItem := new(models.ImageSvgToPngResp)
		//err = json.Unmarshal(respBody, &respItem)
		//if err != nil {
		//	br.Msg = "文件上传失败"
		//	br.ErrMsg = "图片格式转换失败，Unmarshal Err:" + err.Error() + " respBody:" + string(respBody)
		//	return
		//}
		//resourceUrl = respItem.Data.ResourceURL

		var saveToOssPath string
		randStr := utils.GetRandStringNoSpecialChar(28)
		var fileName, outFileName string
		fileName = randStr + ".txt"
		//saveSvgPath = uploadDir + fileName
		err = utils.SaveToFile(imgData, fileName)
		if err != nil {
			br.Msg = "图片保存失败"
			br.ErrMsg = "图片保存失败,Err:" + err.Error()
			return
		}
		//outFileName = uploadDir + randStr + ".png"
		//outFileName = randStr + ".png"
		//fmt.Println("start convert", time.Now())
		//fmt.Println("line 575:", fileName, outFileName)
		//cd := exec.Command("highcharts-export-server", "--infile", fileName, "--constr", "Chart", "--scale", "2", "--outfile", outFileName)
		//str, err := cd.Output()
		//fmt.Println(string(str))
		//if err != nil {
		//	fmt.Println("Command Err:" + err.Error())
		//	return
		//}
		//fmt.Println("end convert", time.Now())

		//fileName=`90xUNVFMjUAvsQN6iLACda2Ik98d.txt`
		outFileName = randStr + ".png"
		cd := exec.Command("highcharts-export-server", "--infile", fileName, "--constr", "Chart", "--scale", "2", "--workers", "5", "--workLimit", "5", "--outfile", outFileName)
		str, err := cd.Output()
		fmt.Println(string(str))
		if err != nil {
			fmt.Println("Command Err:" + err.Error())
			return
		}
		fmt.Println("end convert", time.Now())

		defer func() {
			os.Remove(fileName)
			os.Remove(outFileName)
		}()
		saveToOssPath = uploadDir + time.Now().Format("200601/20060102/")
		saveToOssPath += outFileName
		//上传到阿里云
		fmt.Println("upload:", outFileName, saveToOssPath)
		err = services.UploadFileToAliyun("", outFileName, saveToOssPath)
		if err != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + err.Error()
			return
		}
		fileHost := "https://hzstatic.hzinsights.com/"
		resourceUrl = fileHost + saveToOssPath
	}
	//修改路径
	err = models.ModifyPptPages(resourceUrl, pptId, pptPagesId, 0, 0)
	if err != nil {
		br.Msg = "资源上传失败"
		br.ErrMsg = "资源上传失败,Err:" + err.Error()
		return
	}
	resp := new(models.ResourceResp)
	resp.ResourceUrl = resourceUrl
	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

// @Title 批量图片上传
// @Description 批量图片上传接口
// @Param	request	body models.Base64UploadBatchReq true "type json string"
// @Success 200 {object} models.PptResourceResp
// @router /base64Upload/batch [post]
func (this *PptCommonController) Base64UploadBatch() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	//
	var req []models.Base64UploadBatchReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	var urlArr []string
	for _, v := range req {
		imgData := v.Img
		if imgData == "" {
			br.Msg = "图片参数错误"
			br.ErrMsg = "图片参数错误,Img Is Empty"
			return
		}
		resourceId := v.ResourceId
		if resourceId == "" {
			br.Msg = "参数错误"
			br.ErrMsg = "资源id 为空"
			return
		}
		pptId := v.PptId
		pptPagesId := v.PptPagesId
		dateDir := time.Now().Format("20060102")
		uploadDir := utils.STATIC_DIR + "hongze/" + dateDir
		if !utils.FileIsExist(uploadDir) {
			err = os.MkdirAll(uploadDir, 777)
			if err != nil {
				br.Msg = "存储目录创建失败"
				br.ErrMsg = "存储目录创建失败,Err:" + err.Error()
				return
			}
		}

		imgData = strings.Replace(imgData, "data:image/png;base64,", "", -1)
		imgData = strings.Replace(imgData, "data:image/svg+xml;base64,", "", -1)

		randStr := utils.GetRandStringNoSpecialChar(28)
		fileName := randStr + ".png"
		savePath := uploadDir + "/" + fileName

		err = utils.SaveBase64ToFile(imgData, savePath)
		if err != nil {
			br.Msg = "图片保存失败"
			br.ErrMsg = "图片保存失败,Err:" + err.Error()
			return
		}
		file, err := os.Open(savePath)
		if err != nil {
			br.Msg = "获取图片信息失败"
			br.ErrMsg = "获取图片信息失败,Err:" + err.Error()
			return
		}
		config, _, err := image.DecodeConfig(file)
		if err != nil {
			br.Msg = "获取图片信息失败"
			br.ErrMsg = "获取图片信息失败,Err:" + err.Error()
			return
		}
		width := config.Width
		height := config.Height
		//上传到阿里云
		resourceUrl, err := services.UploadAliyun(fileName, savePath)
		if err != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + err.Error()
			return
		}
		defer func() {
			os.Remove(savePath)
		}()
		//修改路径
		err = models.ModifyPptPages(resourceUrl, pptId, pptPagesId, width, height)
		if err != nil {
			br.Msg = "资源上传失败"
			br.ErrMsg = "资源上传失败,Err:" + err.Error()
			return
		}
		urlArr = append(urlArr, resourceUrl)
	}

	resp := new(models.PptResourceResp)
	resp.ResourceUrl = urlArr
	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

type PptCommonController struct {
	BaseCommonController
}

// @Title ppt下载
// @Description ppt下载
// @Param   PptId   query   int  true       "PptId"
// @Success 200 下载成功
// @router /download [get]
func (this *PptCommonController) Download() {
	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
	}
	ppt, err := models.GetPptById(pptId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	filePath := ppt.PptUrl + ".ppt"
	fileName := ppt.Title + ".ppt"
	this.Ctx.Output.Download(filePath, fileName)
	br.Success = true
	br.Ret = 200
	br.Msg = "下载成功"
	return
}

// @Title ppt下载
// @Description ppt下载
// @Param   PptId   query   int  true       "PptId"
// @Success 200 下载成功
// @router /downloadpptx [get]
func (this *PptCommonController) 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
	}
	ppt, err := models.GetPptById(pptId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	filePath := ppt.PptUrl + ".pptx"
	fileName := ppt.Title + ".pptx"
	this.Ctx.Output.Download(filePath, fileName)
	br.Success = true
	br.Ret = 200
	br.Msg = "下载成功"
	return
}

// @Title 获取首页背景模板接口
// @Description 获取首页背景模板接口
// @Success 200 {object} models.PptImagesResp
// @router /getImages [get]
func (this *PptController) GetImages() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	imageType := 0
	ppt, err := models.GetImages(imageType)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}

	resp := new(models.PptImagesResp)
	resp.List = ppt
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	return
}

// @Title 发布接口
// @Description 发布接口
// @Param	request	body models.PptPublishReq true "type json string"
// @Success 200 {object} models.PptImagesResp
// @router /publish [post]
func (this *PptController) Publish() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req models.PptPublishReq
	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
	}
	pptItem, err := models.GetPptById(pptId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取PPT详情失败，Err:" + err.Error()
		return
	}
	fmt.Println("line 585")
	fmt.Println("pptId:", pptId)
	pptFirstPages, err := models.GetPptFirstPage(pptId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	pptContentPages, err := models.GetPptContentPages(pptId, pptFirstPages.PptPagesId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	dataMap := make(map[string]interface{})
	dataMap["FirstPage"] = pptFirstPages
	dataMap["ContentPage"] = pptContentPages
	dataMap["ScreenHeight"] = req.ScreenHeight

	var postUrl string
	//if utils.RunMode == "debug" {
	//	postUrl = "http://127.0.0.1:6002/publish_ppt/"
	//} else {
	//	postUrl = "http://127.0.0.1:5000/publish_ppt/"
	//}

	postUrl = "http://127.0.0.1:5000/publish_ppt/"

	fmt.Println("postUrl:", postUrl)
	postData, err := json.Marshal(dataMap)
	if err != nil {
		br.Msg = "获取postData数据失败"
		br.ErrMsg = "解析，Marshal，Err:" + err.Error()
		return
	}
	fmt.Println("publish ppt param:", string(postData))
	result, err := http.Post(postUrl, string(postData))
	if err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "Marshal，Err:" + err.Error()
		return
	}
	fmt.Println("publish ppt result:", string(result))
	var pptResult PublishPptResult
	err = json.Unmarshal(result, &pptResult)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "Unmarshal，Err:" + err.Error() + " result:" + string(result)
		return
	}

	//randStr := utils.GetRandStringNoSpecialChar(28)

	pptxFilePath := pptResult.PptFullPath + ".pptx"
	pptFilePath := pptResult.PptFullPath + ".ppt"

	hzUploadDir := "ppt/"
	savePptxToOssPath := hzUploadDir + time.Now().Format("200601/20060102/")
	savePptxToOssPath += pptItem.Title + ".pptx"

	//上传到阿里云
	err = services.UploadFileToAliyun("", pptxFilePath, savePptxToOssPath)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	fileHost := "https://hzstatic.hzinsights.com/"
	pptxUrl := fileHost + savePptxToOssPath

	savePptToOssPath := hzUploadDir + time.Now().Format("200601/20060102/")
	savePptToOssPath += pptItem.Title + ".ppt"

	//上传到阿里云
	err = services.UploadFileToAliyun("", pptFilePath, savePptToOssPath)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}
	pptUrl := fileHost + savePptToOssPath

	err = models.EditPptPath(pptId, pptxUrl, pptUrl)
	if err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "发布失败，Err:" + err.Error()
		return
	}
	//添加发布记录
	{
		record := new(models.PptPublishRecord)
		record.CreateTime = time.Now()
		record.PptId = pptId
		record.PptUrl = pptResult.PptFullPath
		go models.AddPptPublishRecord(record)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "发布成功"
	return
}

type PublishPptResult struct {
	Result      string `json:"result"`
	PptPath     string `json:"ppt_path"`
	PptName     string `json:"ppt_name"`
	PptFullPath string `json:"ppt_full_path"`
}

/*
func init() {
	fmt.Println("start")
	var err error
	defer func() {
		if err != nil {
			fmt.Println("err:", err.Error())
		}
	}()
	pptId := 111
	if pptId <= 0 {
		return
	}

	pptFirstPages, err := models.GetPptFirstPage(pptId)
	if err != nil {
		return
	}
	pptContentPages, err := models.GetPptContentPages(pptId, pptFirstPages.PptPagesId)
	if err != nil {
		return
	}
	dataMap := make(map[string]interface{})
	dataMap["FirstPage"] = pptFirstPages
	dataMap["ContentPage"] = pptContentPages
	dataMap["ScreenHeight"] = 12000

	postUrl := "http://127.0.0.1:5000/publish_ppt/" //随便写的
	postData, err := json.Marshal(dataMap)
	if err != nil {
		return
	}
	utils.FileLog.Info("%s",string(postData))
	result, err := http.Post(postUrl, string(postData))
	fmt.Println("result:", string(result))
	if err != nil {
		return
	}
	var pptResult PublishPptResult
	err = json.Unmarshal(result, &pptResult)
	if err != nil {
		return
	}
	fmt.Println("ppt:", pptResult.PptFullPath)
	fmt.Println("end")
}
*/

/*func init() {
	fmt.Println("start")
	fmt.Println(time.Now())
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ".png"
	savePath := "./b1.jpg"
	resourceUrl, err := services.UploadAliyun(fileName, savePath)
	if err != nil {
		fmt.Println("err:", err)
	}
	fmt.Println(resourceUrl)
	fmt.Println(time.Now())
	fmt.Println("end")
}
*/