hongze_api/controllers/ppt.go

package controllers

import (
	"encoding/base64"
	"encoding/json"
	"hongze/hongze_admin/models"
	"hongze/hongze_admin/services"
	"hongze/hongze_admin/utils"
	"image"
	"os"
	"rdluck_tools/http"
	"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()
	}()
	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 + `%' `
	}
	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
	}
	page := models.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
	}
	ppt := new(models.Ppt)
	ppt.Title = req.FirstPage.Title
	ppt.PptDate = req.FirstPage.PptDate
	ppt.ReportType = req.FirstPage.ReportType
	newId, err := models.AddPpt(ppt)
	if err != nil {
		br.Msg = "新增失败"
		br.ErrMsg = "新增失败,Err:" + err.Error()
		return
	}

	for _, v := range req.ContentPage {
		page := new(models.PptPages)
		page.PptId = newId
		page.Title = v.Title
		page.ResourceId = v.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	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
	}
	ppt := new(models.Ppt)
	ppt.Title = req.FirstPage.Title
	ppt.PptDate = req.FirstPage.PptDate
	ppt.ReportType = req.FirstPage.ReportType
	err = models.EditPpt(ppt)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑失败,Err:" + err.Error()
		return
	}

	page := new(models.PptPages)
	page.PptPagesId = req.FirstPage.PptPagesId
	page.Title = req.FirstPage.Title
	page.ImgUrl = req.FirstPage.ImgUrl
	err = models.EditPptPages(page)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑章节失败,Err:" + err.Error()
		return
	}
	for _, v := range req.ContentPage {
		page := new(models.PptPages)
		page.PptId = req.PptId
		page.Title = v.Title
		page.ResourceId = v.ResourceId
		page.CreateTime = time.Now()
		page.ModifyTime = time.Now()
		if v.PptPagesId <= 0 {
			_, err = models.AddPptPages(page)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "新增章节失败,Err:" + err.Error()
				return
			}
		} else {
			err = models.EditPptPages(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	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 *PptController) Base64Upload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	imgData := this.GetString("Image")
	if imgData == "" {
		br.Msg = "图片参数错误"
		br.ErrMsg = "图片参数错误,Img Is Empty"
		return
	}
	resourceId, err := this.GetInt("ResourceId")
	if err != nil {
		br.Msg = "参数错误"
		br.ErrMsg = "获取，策略组提供的资源id失败，Err:" + err.Error()
		return
	}

	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
	}

	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
		}
	}

	imgBase64 := base64.StdEncoding.EncodeToString([]byte(imgData))
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ".png"
	savePath := uploadDir + "/" + fileName
	err = utils.SaveBase64ToFile(imgBase64, 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)
	}()

	item := new(models.Resource)
	item.ResourceUrl = resourceUrl
	item.ResourceType = 1
	item.CreateTime = time.Now()
	newId, err := models.AddResource(item)
	if err != nil {
		br.Msg = "资源上传失败"
		br.ErrMsg = "资源上传失败,Err:" + err.Error()
		return
	}

	//修改路径
	err = models.ModifyPptPages(resourceUrl, resourceId, pptId, pptPagesId, width, height)
	if err != nil {
		br.Msg = "资源上传失败"
		br.ErrMsg = "资源上传失败,Err:" + err.Error()
		return
	}
	resp := new(models.ResourceResp)
	resp.Id = newId
	resp.ResourceUrl = resourceUrl
	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

// @Title ppt下载
// @Description ppt下载
// @Param   PptId   query   int  true       "PptId"
// @Success 200 下载成功
// @router /download [get]
func (this *PptController) 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)
	return
}

// @Title ppt下载
// @Description ppt下载
// @Param   PptId   query   int  true       "PptId"
// @Success 200 下载成功
// @router /downloadpptx [get]
func (this *PptController) 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)
	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
	}

	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

	postUrl := "http://127.0.0.1:5000/publish_ppt/" //随便写的
	postData, err := json.Marshal(dataMap)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "Marshal，Err:" + err.Error()
		return
	}

	result, err := http.Post(postUrl, string(postData))
	if err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "Marshal，Err:" + err.Error()
		return
	}
	var pptResult PublishPptResult
	err = json.Unmarshal(result, &pptResult)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "Marshal，Err:" + err.Error()
		return
	}
	err = models.EditPptPath(pptId, pptResult.PptFullPath)
	if err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "发布失败，Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "发布成功"
	return
}

type PublishPptResult struct {
	Result      string
	PptPath     string
	PptName     string
	PptFullPath string
}
/*
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")
}
*/