eta_api/controllers/report.go

package controllers

import (
	"encoding/json"
	"eta/eta_api/models"
	"eta/eta_api/models/report_approve"
	"eta/eta_api/services"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data"
	"eta/eta_api/utils"
	"fmt"
	"github.com/beego/beego/v2/server/web"
	"github.com/h2non/filetype"
	"github.com/tealeg/xlsx"
	"html"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

// ReportController 报告
type ReportController struct {
	BaseAuthController
}

// ReportCommonController 报告
type ReportCommonController struct {
	BaseCommonController
}

// ReportUploadCommonController 报告上传
type ReportUploadCommonController struct {
	web.Controller
}

// PublishReport
// @Title 发布报告接口
// @Description 发布报告
// @Param	request	body models.PublishReq true "type json string"
// @Success 200 Ret=200 发布成功
// @router /publish [post]
func (this *ReportController) PublishReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.PublishReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportIds := req.ReportIds
	if reportIds == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id不可为空"
		return
	}

	// 这里实际上不会批量发布了...
	reportArr := strings.Split(reportIds, ",")
	tips := ""
	for _, v := range reportArr {
		vint, err := strconv.Atoi(v)
		if err != nil {
			br.Msg = "参数错误"
			br.ErrMsg = "参数错误,Err:" + err.Error()
			return
		}
		report, err := models.GetReportById(vint)
		if err != nil {
			br.Msg = "获取报告信息失败"
			br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
			return
		}
		if report == nil {
			br.Msg = "报告不存在"
			return
		}

		refreshResult := data.CheckBatchChartRefreshResult("report", vint, 0)
		if !refreshResult {
			br.Msg = "图表刷新未完成，请稍后操作"
			br.ErrMsg = "图表刷新未完成，请稍后操作"
			br.IsSendEmail = false
			return
		}

		var publishTime time.Time
		if report.MsgIsSend == 1 && report.PublishTime != "" { //如果报告曾经发布过，并且已经发送过模版消息，则章节的发布时间为报告的发布时间
			publishTime, _ = time.ParseInLocation(utils.FormatDateTime, report.PublishTime, time.Local)
		} else {
			publishTime = time.Now()
		}
		var tmpErr error
		if report.HasChapter == 1 && (report.ChapterType == utils.REPORT_TYPE_DAY || report.ChapterType == utils.REPORT_TYPE_WEEK) {
			// 发布晨周报
			if tips, tmpErr = services.PublishDayWeekReport(vint); tmpErr != nil {
				br.Msg = "报告发布失败"
				br.ErrMsg = "晨周报发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
				return
			}
		} else {
			if report.Content == "" {
				br.Msg = "报告内容为空，不可发布"
				br.ErrMsg = "报告内容为空，不需要生成,report_id:" + strconv.Itoa(report.Id)
				return
			}

			// 根据审批开关及审批流判断当前报告状态
			state, e := services.CheckReportCurrState(report_approve.FlowReportTypeChinese, report.ClassifyIdFirst, report.ClassifyIdSecond, models.ReportOperatePublish)
			if e != nil {
				br.Msg = "操作失败"
				br.ErrMsg = "校验报告当前状态失败, Err: " + e.Error()
				return
			}

			if state == models.ReportStatePublished {
				// 发布报告
				if tmpErr = models.PublishReportById(report.Id, publishTime); tmpErr != nil {
					br.Msg = "报告发布失败"
					br.ErrMsg = "报告发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
					return
				}
				go func() {
					// 生成音频
					if report.VideoUrl == "" {
						_ = services.CreateVideo(report)
					}
					//// 推送找钢网
					//if utils.RunMode == "release" && (report.ClassifyNameSecond == "知白守黑日评" || report.ClassifyNameSecond == "股债日评") {
					//	_ = services.ZhaoGangSend(report)
					//}
					// 更新报告Es
					_ = services.UpdateReportEs(report.Id, 2)
				}()
			} else {
				// 从无审批切换为有审批, 状态重置
				if e = models.ResetReportById(report.Id, state); tmpErr != nil {
					br.Msg = "操作失败"
					br.ErrMsg = fmt.Sprintf("重置报告状态失败, Err: %s, ReportId: %d", e.Error(), report.Id)
					return
				}
			}

			recordItem := &models.ReportStateRecord{
				ReportId:   vint,
				ReportType: 1,
				State:      state,
				AdminId:    this.SysUser.AdminId,
				AdminName:  this.SysUser.AdminName,
				CreateTime: time.Now(),
			}
			go func() {
				_, _ = models.AddReportStateRecord(recordItem)
			}()

			// 生成报告pdf和长图
			if req.ReportUrl != "" {
				go services.Report2pdfAndJpeg(req.ReportUrl, report.Id, 1)
			}
		}

	}
	// 发布晨周报部分章节未发布的提示
	if tips != "" {
		br.Data = tips
	}

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

// PublishCancleReport
// @Title 取消发布报告接口
// @Description 取消发布报告
// @Param	request	body models.PublishCancelReq true "type json string"
// @Success 200 Ret=200 取消发布成功
// @router /publish/cancle [post]
func (this *ReportController) PublishCancleReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.PublishCancelReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportIds <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id不可为空"
		return
	}
	publishTimeNullFlag := true
	reportInfo, err := models.GetReportById(req.ReportIds)
	if err != nil {
		br.Msg = "获取报告信息失败"
		br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
		return
	}
	if reportInfo.MsgIsSend == 1 {
		publishTimeNullFlag = false
	}

	// 根据审批开关及审批流判断当前报告状态
	state, e := services.CheckReportCurrState(report_approve.FlowReportTypeChinese, reportInfo.ClassifyIdFirst, reportInfo.ClassifyIdSecond, models.ReportOperateCancelPublish)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "校验报告当前状态失败, Err: " + e.Error()
		return
	}

	err = models.PublishCancelReport(req.ReportIds, state, publishTimeNullFlag)
	if err != nil {
		br.Msg = "取消发布失败"
		br.ErrMsg = "取消发布失败,Err:" + err.Error()
		return
	}
	// 更新ES禁用
	{
		go services.UpdateReportEs(req.ReportIds, 1)
	}

	//// 获取审批流设置
	//confKey := "approval_flow"
	//confTmp, e := company.GetConfigDetailByCode(confKey)
	//if e != nil {
	//	br.Msg = "获取审批流配置失败"
	//	br.ErrMsg = "获取审批流配置失败, Err: " + e.Error()
	//	return
	//}
	//if confTmp.ConfigValue == "1" || confTmp.ConfigValue == "2" || confTmp.ConfigValue == "3" {
	//	br.Msg = "撤销成功"
	//} else {
	//	br.Msg = "取消发布成功"
	//}

	recordItem := &models.ReportStateRecord{
		ReportId:   req.ReportIds,
		ReportType: 1,
		State:      state,
		AdminId:    this.SysUser.AdminId,
		AdminName:  this.SysUser.AdminName,
		CreateTime: time.Now(),
	}
	go func() {
		_, _ = models.AddReportStateRecord(recordItem)
	}()
	br.Ret = 200
	br.Success = true
}

// Delete
// @Title 删除报告接口
// @Description 删除报告
// @Param	request	body models.DeleteReq true "type json string"
// @Success 200 Ret=200 删除成功
// @router /delete [post]
func (this *ReportController) Delete() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DeleteReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportIds <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id不可为空"
		return
	}

	if err := services.DeleteReportAndChapter(req.ReportIds); err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除报告失败, Err: " + err.Error()
		return
	}

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

//func (this *ReportController) Edit() {
//	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.EditReq
//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
//	if err != nil {
//		br.Msg = "参数解析异常！"
//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
//		return
//	}
//	if req.Content == "" {
//		br.Msg = "报告内容不能为空"
//		return
//	}
//	var contentSub string
//	if req.Content != "" {
//		e := utils.ContentXssCheck(req.Content)
//		if e != nil {
//			br.Msg = "存在非法标签"
//			br.ErrMsg = "存在非法标签, Err: " + e.Error()
//			return
//		}
//		content, e := services.FilterReportContentBr(req.Content)
//		if e != nil {
//			br.Msg = "内容去除前后空格失败"
//			br.ErrMsg = "内容去除前后空格失败, Err: " + e.Error()
//			return
//		}
//		req.Content = content
//
//		contentSub, err = services.GetReportContentSub(req.Content)
//		if err != nil {
//			go alarm_msg.SendAlarmMsg("解析 ContentSub 失败，Err："+err.Error(), 3)
//			//utils.SendEmail(utils.APPNAME+"失败提醒", "解析 ContentSub 失败，Err:"+err.Error(), utils.EmailSendToUsers)
//		}
//	}
//
//	//更新标记key
//	markStatus, err := services.UpdateReportEditMark(int(req.ReportId), sysUser.AdminId, 1, sysUser.RealName, this.Lang)
//	if err != nil {
//		br.Msg = err.Error()
//		return
//	}
//	if markStatus.Status == 1 {
//		br.Msg = markStatus.Msg
//		//br.Ret = 202 //202 服务器已接受请求，但尚未处理。
//		return
//	}
//
//	var stage int
//	report, e := models.GetReportByReportId(int(req.ReportId))
//	if e != nil {
//		if e.Error() == utils.ErrNoRow() {
//			br.Msg = "报告已被删除, 请刷新页面"
//			return
//		}
//		br.Msg = "操作失败"
//		br.ErrMsg = "获取报告失败, Err: " + e.Error()
//		return
//	}
//	if report.State == models.ReportStatePublished || report.State == models.ReportStatePass {
//		br.Msg = "该报告已发布，不允许编辑"
//		br.ErrMsg = "该报告已发布，不允许编辑"
//		return
//	}
//	if report.ClassifyNameFirst != req.ClassifyNameFirst || report.ClassifyNameSecond != req.ClassifyNameSecond {
//		maxStage, _ := models.GetReportStageEdit(req.ClassifyIdFirst, req.ClassifyIdSecond, int(req.ReportId))
//		maxStage = maxStage + 1
//		stage = maxStage
//	} else {
//		stage = report.Stage
//	}
//	//if req.State != report.State {
//	//	recordItem := &models.ReportStateRecord{
//	//		ReportId:   int(req.ReportId),
//	//		ReportType: 1,
//	//		State:      req.State,
//	//		AdminId:    this.SysUser.AdminId,
//	//		AdminName:  this.SysUser.AdminName,
//	//		CreateTime: time.Now(),
//	//	}
//	//	go func() {
//	//		_, _ = models.AddReportStateRecord(recordItem)
//	//	}()
//	//}
//
//	//item := new(models.Report)
//	report.ClassifyIdFirst = req.ClassifyIdFirst
//	report.ClassifyNameFirst = req.ClassifyNameFirst
//	report.ClassifyIdSecond = req.ClassifyIdSecond
//	report.ClassifyNameSecond = req.ClassifyNameSecond
//	report.ClassifyIdThird = req.ClassifyIdThird
//	report.ClassifyNameThird = req.ClassifyNameThird
//	report.Title = req.Title
//	report.Abstract = req.Abstract
//	report.Author = req.Author
//	report.Frequency = req.Frequency
//	//report.State = report.State // 编辑不变更状态
//	report.Stage = stage
//	report.Content = html.EscapeString(req.Content)
//	report.ContentSub = html.EscapeString(contentSub)
//	report.CreateTime = req.CreateTime
//	//report.CollaborateType = req.CollaborateType
//	//report.ReportLayout = req.ReportLayout
//	if req.IsPublicPublish <= 0 {
//		req.IsPublicPublish = 1
//	}
//	report.IsPublicPublish = req.IsPublicPublish
//	err = report.Update([]string{"ClassifyIdFirst", "ClassifyNameFirst", "ClassifyIdSecond", "ClassifyNameSecond", "ClassifyIdThird", "ClassifyNameThird", "Title", "Abstract", "Author", "Frequency", "Stage", "Content", "ContentSub", "CreateTime", "IsPublicPublish"})
//	if err != nil {
//		br.Msg = "保存失败"
//		br.ErrMsg = "保存失败,Err:" + err.Error()
//		return
//	}
//
//	//处理权限
//	//if utils.BusinessCode == utils.BusinessCodeRelease || utils.BusinessCode == utils.BusinessCodeSandbox {
//	go func() {
//		e := models.RemoveChartPermissionChapterMapping(req.ReportId)
//		if e != nil {
//			alarm_msg.SendAlarmMsg("修改删除报告权限失败，Err："+e.Error(), 3)
//			return
//		}
//		permissionItems, e := models.GetPermission(req.ClassifyNameSecond)
//		if e != nil {
//			alarm_msg.SendAlarmMsg("获取权限失败，Err："+e.Error(), 3)
//			return
//		}
//		for _, v := range permissionItems {
//			e = models.AddChartPermissionChapterMapping(v.ChartPermissionId, req.ReportId)
//			if e != nil {
//				alarm_msg.SendAlarmMsg("新增权限失败，Err："+e.Error(), 3)
//				return
//			}
//		}
//		// 同步crm权限
//		_ = services.EditReportPermissionSync(req.ReportId, req.ClassifyNameSecond)
//	}()
//	//}
//
//	reportCode := utils.MD5(strconv.Itoa(int(req.ReportId)))
//	resp := new(models.EditResp)
//	resp.ReportId = req.ReportId
//	resp.ReportCode = reportCode
//	br.Ret = 200
//	br.Success = true
//	br.Msg = "保存成功"
//	br.Data = resp
//}

// Upload
// @Title 图片上传
// @Description 图片上传接口
// @Param   file   query   file  true       "文件"
// @Success 200 新增成功
// @router /upload [post]
func (this *ReportController) Upload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	f, h, err := this.GetFile("file")
	if err != nil {
		br.Msg = "获取资源信息失败"
		br.ErrMsg = "获取资源信息失败,Err:" + err.Error()
		return
	}

	fileData, e := ioutil.ReadAll(f)
	if e != nil {
		br.Msg = "上传失败"
		br.ErrMsg = "读取文件失败, Err: " + e.Error()
		return
	}
	pass := filetype.IsImage(fileData)
	if !pass {
		br.Msg = "文件格式有误"
		br.ErrMsg = "文件格式有误"
		return
	}

	ext := path.Ext(h.Filename)
	dateDir := time.Now().Format("20060102")
	uploadDir := utils.STATIC_DIR + "hongze/" + 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
	defer f.Close() //关闭上传文件
	err = this.SaveToFile("file", fpath)
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}

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

	defer func() {
		os.Remove(fpath)
	}()

	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
	}
	resp := new(models.ResourceResp)
	resp.Id = newId
	resp.ResourceUrl = resourceUrl
	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

// ClassifyIdDetail
// @Title 根据分类获取最近一次报告详情接口
// @Description 根据分类获取最近一次报告详情
// @Param	request	body models.ClassifyIdDetailReq true "type json string"
// @Success 200 {object} models.Report
// @router /classifyIdDetail [get]
func (this *ReportController) ClassifyIdDetail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	//classify_id_first=34&classify_id_second=36

	/*var req models.ClassifyIdDetailReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}*/
	classifyIdFirst, _ := this.GetInt("classify_id_first")
	if classifyIdFirst <= 0 {
		classifyIdFirst, _ = this.GetInt("ClassifyIdFirst")
	}
	classifyIdSecond, _ := this.GetInt("classify_id_second")
	if classifyIdSecond <= 0 {
		classifyIdSecond, _ = this.GetInt("ClassifyIdSecond")
	}
	item, err := models.GetReportDetailByClassifyId(classifyIdFirst, classifyIdSecond)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if item != nil {
		item.Content = html.UnescapeString(item.Content)
		item.ContentSub = html.UnescapeString(item.ContentSub)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = item
}

// SendTemplateMsg
// @Title 模板消息推送接口
// @Description 模板消息推送
// @Param	request	body models.SendTemplateMsgReq true "type json string"
// @Success 200 Ret=200 推送成功
// @router /sendTemplateMsg [post]
func (this *ReportController) SendTemplateMsg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var req models.SendTemplateMsgReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}
	report, _ := models.GetReportById(req.ReportId)
	if report.MsgIsSend == 1 {
		br.Msg = "消息已推送，请勿重复操作"
		br.ErrMsg = "模板消息已推送，请勿重复操作"
		return
	}

	videoNameDate := `(` + time.Now().Format("0102") + `)`
	err = models.UpdateReportPublishTime(req.ReportId, videoNameDate)
	if err != nil {
		br.Msg = "修改报告发布时间失败"
		br.ErrMsg = "修改发布时间失败,Err:" + err.Error()
		return
	}
	err = models.UpdateReportChapterPublishTime(req.ReportId, videoNameDate)
	if err != nil {
		br.Msg = "修改章节发布时间失败"
		br.ErrMsg = "修改发布时间失败,Err:" + err.Error()
		return
	}

	services.SendMiniProgramReportWxMsg(req.ReportId)
	err = models.ModifyReportMsgIsSend(req.ReportId)
	if err != nil {
		br.Msg = "发送失败"
		br.ErrMsg = "发送失败,Err:" + err.Error()
		return
	}

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

// Author
// @Title 获取报告作者接口
// @Description 获取报告作者
// @Param   AuthorType   query   int  true       "来源类型，1：中文，2：英文"
// @Param   StartDate   query   string  true       "开始时间"
// @Success 200 {object} models.ReportAuthorResp
// @router /author [get]
func (this *ReportController) Author() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	keyword := this.GetString("Keyword")

	var condition string
	var pars []interface{}
	condition += ` AND author_type = 1 AND enable = 1`

	if keyword != `` {
		condition += ` AND report_author like ? `
		pars = append(pars, utils.GetLikeKeyword(keyword))
	}

	_, items, err := models.GetReportAuthorList(condition, pars, 0, 10000)
	if err != nil {
		br.Msg = "获取失败！"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	resp := models.ReportAuthorResp{
		List: items,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// UploadImg
// @Title 图片上传
// @Description 图片上传接口
// @Param   File   query   file  true       "文件"
// @Success 200 上传成功
// @router /uploadImg [post]
func (this *ReportUploadCommonController) UploadImg() {
	var err error
	defer func() {
		if err != nil {
			fmt.Println("文件上传失败:", err.Error())
			go alarm_msg.SendAlarmMsg("URI:"+this.Ctx.Input.URI()+" 文件上传失败:"+err.Error(), 3)
			//go utils.SendEmail(utils.APPNAME+"失败提醒", "URI:"+this.Ctx.Input.URI()+" 文件上传失败:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	f, h, err := this.GetFile("file")
	if err != nil {
		return
	}
	defer f.Close() //关闭上传文件

	// 不依赖于文件扩展名检查文件格式
	fileData, e := ioutil.ReadAll(f)
	if e != nil {
		err = fmt.Errorf("读取文件失败, Err: %s", e.Error())
		return
	}
	pass := filetype.IsImage(fileData)
	if !pass {
		kind, _ := filetype.Match(fileData)
		if kind.Extension != "pdf" {
			err = fmt.Errorf("文件格式有误")
			return
		}
		fmt.Printf("File type: %s. MIME: %s\n", kind.Extension, kind.MIME.Value)
	}

	ext := path.Ext(h.Filename)
	dateDir := time.Now().Format("20060102")
	uploadDir := utils.STATIC_DIR + "hongze/" + dateDir
	err = os.MkdirAll(uploadDir, utils.DIR_MOD)
	if err != nil {
		return
	}
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ext
	fpath := uploadDir + "/" + fileName
	err = this.SaveToFile("file", fpath)
	if err != nil {
		return
	}
	defer func() {
		os.Remove(fpath)
	}()

	// 上传至对象存储
	resourceUrl := ``
	ossClient := services.NewOssClient()
	if ossClient == nil {
		err = fmt.Errorf("初始化OSS服务失败")
		return
	}
	resourceUrl, err = ossClient.UploadFile(fileName, fpath, "")
	if err != nil {
		err = fmt.Errorf("文件上传失败, Err: %s", err.Error())
		return
	}

	item := new(models.Resource)
	item.ResourceUrl = resourceUrl
	item.ResourceType = 1
	item.CreateTime = time.Now()
	newId, err := models.AddResource(item)
	if err != nil {
		return
	}
	resp := new(models.ResourceResp)
	resp.Id = newId
	resp.ResourceUrl = resourceUrl
	this.Data["json"] = map[string]string{"link": resourceUrl}
	this.ServeJSON()
}

// Export
// @Title 研报浏览数据导出
// @Description 研报浏览数据导出接口
// @Param   ReportIds   query   string  true       "报告id，多个报告用英文,隔开"
// @Success 200 {object} company.CompanyListResp
// @router /report_view_record/export [get]
func (this *ReportController) Export() {
	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
	}

	reportIds := this.GetString("ReportIds")
	if reportIds == "" {
		br.Msg = "请选择需要下载的报告"
		br.ErrMsg = "请选择需要下载的报告"
		return
	}

	//生成excel文件
	dir, err := os.Executable()
	exPath := filepath.Dir(dir)
	downLoadnFilePath := exPath + "/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	xlsxFile := xlsx.NewFile()
	if err != nil {
		br.Msg = "生成文件失败"
		br.ErrMsg = "生成文件失败"
		return
	}

	//只有权益研究员，以及超管可以下载
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_RAI_RESEARCHR && sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		br.Msg = "没有下载权限"
		br.ErrMsg = "没有下载权限"
		return
	}

	//普通样式
	style := xlsx.NewStyle()
	alignment := xlsx.Alignment{
		Horizontal: "center",
		Vertical:   "center",
		WrapText:   true,
	}
	//设置默认字体和文字大小
	xlsx.SetDefaultFont(12, "宋体")

	style.Alignment = alignment
	style.ApplyAlignment = true

	//标题样式
	titleStyle := xlsx.NewStyle()
	titleFont := xlsx.NewFont(20, "宋体")
	titleFont.Bold = true
	titleStyle.Font = *titleFont
	titleStyle.Alignment = alignment
	//titleStyle.ApplyAlignment = true

	//表头
	headerStyle := xlsx.NewStyle()
	headerFont := xlsx.NewFont(12, "宋体")
	headerFont.Bold = true
	headerStyle.Font = *headerFont
	headerStyle.Alignment = alignment
	headerStyle.ApplyAlignment = true

	defer func() {
		os.Remove(downLoadnFilePath)
	}()

	//记录已经命名了的表单名称
	sheetNameMap := make(map[string]int)

	reportSlice := strings.Split(reportIds, ",")
	for _, reportIdStr := range reportSlice {
		reportId, convErr := strconv.Atoi(reportIdStr)
		if convErr != nil {
			br.Msg = "报告传参异常"
			br.ErrMsg = "报告传参异常"
			return
		}

		report, reportErr := models.GetReportById(reportId)
		if reportErr != nil {
			br.Msg = "查询报告异常"
			br.ErrMsg = "查询报告异常：" + reportErr.Error()
			return
		}

		//查询浏览记录
		_, viewList, err := models.GetViewListByReportId(reportId)
		//fmt.Println(total)
		//fmt.Println(viewList)
		//fmt.Println(err)
		if err != nil {
			br.Msg = "查询报告浏览记录异常"
			br.ErrMsg = "查询报告浏览记录异常：" + err.Error()
			return
		}

		//导入报表
		//报表名称
		createTime, _ := time.Parse(utils.FormatDateTime, report.CreateTime)
		timeStr := createTime.Format("0102")
		reportName := report.Title + "(" + timeStr + ")"

		//表单名称
		sheetName := reportName

		//判断当前sheet表单map中是否已经存在该表单名称，如果存在，那么需要添加后缀，并给sheet表单map中赋值次数加1处理；不存在，那么还是使用当前名称，并给sheet表单map中赋值次数为1
		if n, ok := sheetNameMap[sheetName]; ok == true {
			n++
			sheetName = sheetName + "_" + strconv.Itoa(n)
			sheetNameMap[sheetName] = n
		} else {
			sheetNameMap[sheetName] = 1
		}

		sheel, err := xlsxFile.AddSheet(sheetName)
		if err != nil {
			br.Msg = "新增Sheet失败"
			br.ErrMsg = "新增Sheet失败,Err:" + err.Error()
			return
		}
		//设置列宽
		sheel.SetColWidth(0, 0, 28)
		sheel.SetColWidth(1, 1, 18)
		sheel.SetColWidth(2, 2, 18)
		sheel.SetColWidth(3, 3, 18)
		sheel.SetColWidth(4, 4, 40)

		//标题行
		titleRow := sheel.AddRow()
		titleRow.SetHeight(40)

		//标题列
		titleCell := titleRow.AddCell()
		titleCell.HMerge = 4 //向右合并列数，不包括自身列

		//报表标题名称
		titleCell.SetValue(reportName)
		titleCell.SetStyle(titleStyle)

		//表头
		headerRow := sheel.AddRow()
		headerRow.SetHeight(18)

		timeHeaderCell := headerRow.AddCell()
		timeHeaderCell.SetValue("浏览时间")
		timeHeaderCell.SetStyle(headerStyle)

		nameHeaderCell := headerRow.AddCell()
		nameHeaderCell.SetValue("用户名称")
		nameHeaderCell.SetStyle(headerStyle)

		mobileHeaderCell := headerRow.AddCell()
		mobileHeaderCell.SetValue("手机号")
		mobileHeaderCell.SetStyle(headerStyle)

		emailHeaderCell := headerRow.AddCell()
		emailHeaderCell.SetValue("邮箱")
		emailHeaderCell.SetStyle(headerStyle)

		companyHeaderCell := headerRow.AddCell()
		companyHeaderCell.SetValue("所属企业客户名称")
		companyHeaderCell.SetStyle(headerStyle)

		for _, v := range viewList {
			dataRow := sheel.AddRow()
			dataRow.SetHeight(18)

			timeCell := dataRow.AddCell()
			timeCell.SetString(v.CreateTime.Format(utils.FormatDateTime))
			timeCell.SetStyle(style)

			nameCell := dataRow.AddCell()
			nameCell.SetString(v.RealName)
			nameCell.SetStyle(style)

			mobileCell := dataRow.AddCell()
			mobileCell.SetString(v.Mobile)
			mobileCell.SetStyle(style)

			emailCell := dataRow.AddCell()
			emailCell.SetString(v.Email)
			emailCell.SetStyle(style)

			companyCell := dataRow.AddCell()
			companyCell.SetString(v.CompanyName)
			companyCell.SetStyle(style)
		}
	}

	err = xlsxFile.Save(downLoadnFilePath)
	if err != nil {
		br.Msg = "保存文件失败"
		br.ErrMsg = "保存文件失败"
		return
	}
	randStr := time.Now().Format(utils.FormatDateTimeUnSpace)
	downloadFileName := "研报浏览记录" + randStr + ".xlsx"
	this.Ctx.Output.Download(downLoadnFilePath, downloadFileName)
	br.Ret = 200
	br.Success = true
	br.Msg = "导出成功"
}

// ThsSendTemplateMsg
// @Title 客群消息推送接口
// @Description 客群消息推送接口
// @Param	request	body models.SendTemplateMsgReq true "type json string"
// @Success 200 Ret=200 推送成功
// @router /ths/sendTemplateMsg [post]
func (this *ReportController) ThsSendTemplateMsg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.ThsSendTemplateMsgReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	for _, v := range req.ReportId {
		if v <= 0 {
			br.Msg = "参数错误"
			br.ErrMsg = "参数错误"
			return
		}

		//加锁，避免重复点击造成的多次推送
		{
			redisKey := fmt.Sprint("report:send:ths:", v)
			ok := utils.Rc.SetNX(redisKey, 1, time.Second*300)
			if !ok {
				br.Msg = "报告已推送客群，请勿重复推送"
				return
			}
			defer func() {
				utils.Rc.Delete(redisKey)
			}()
		}

		report, err := models.GetReportById(v)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "报告已经被删除，请刷新页面"
				br.ErrMsg = "报告已经被删除，请刷新页面,req：" + string(this.Ctx.Input.RequestBody)
				return
			}
			br.Msg = "获取报告信息失败"
			br.ErrMsg = "获取报告信息失败,req：" + string(this.Ctx.Input.RequestBody)
			return
		}
		if report.ThsMsgIsSend == 1 {
			br.Msg = "消息已推送，请勿重复操作"
			br.ErrMsg = "模板消息已推送，请勿重复操作1"
			return
		}
		// 周报无客群
		if report.HasChapter == 1 && report.ChapterType == utils.REPORT_TYPE_WEEK {
			br.Msg = "周报无需推送客群消息"
			return
		}
		err = services.SendReportMiniToThs(report)
		if err != nil {
			br.Msg = "消息已推送，请勿重复操作"
			br.ErrMsg = "模板消息已推送，请勿重复操作2, Err: " + err.Error()
			return
		}
		err = models.ModifyReportThsMsgIsSend(report)
		if err != nil {
			br.Msg = "发送失败"
			br.ErrMsg = "发送失败,Err:" + err.Error()
			return
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "发送成功"
}

// GetDayWeekReportChapterTypeList
// @Title 获取晨报周报章节类型列表
// @Description 获取晨报周报章节类型列表
// @Param	StopType	query	string	true	"停更类型 stop; disable;"
// @Success 200 {object} models.ReportListResp
// @router /getDayWeekReportChapterTypeList [get]
func (this *ReportController) GetDayWeekReportChapterTypeList() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var condition string
	var pars []interface{}
	// 停更类型
	stopType := this.GetString("StopType")
	switch stopType {
	case "", "stop":
		condition += ` AND enabled = ? `
		pars = append(pars, 1)
	case "disable":
	default:
		br.Msg = "停更类型异常"
		br.IsSendEmail = false
		return
	}

	dayList := make([]*models.ReportChapterType, 0)
	weekList := make([]*models.ReportChapterType, 0)

	// 晨报
	{
		tmpCondition := condition
		tmpPars := pars
		// 报告类型
		tmpCondition += ` AND research_type = ? `
		tmpPars = append(tmpPars, "day")

		list, err := models.GetAllReportChapterTypeList(tmpCondition, tmpPars)
		if err != nil {
			br.Msg = "获取报告章节类型列表失败"
			br.ErrMsg = "获取报告章节类型列表失败, Err: " + err.Error()
			return
		}
		nowTime := time.Now()
		for _, v := range list {
			if v.IsSet == 1 {
				endTime, _ := time.Parse(utils.FormatDate, v.PauseEndTime)
				if nowTime.After(endTime.AddDate(0, 0, 1)) { //设置过期了已经
					v.IsSet = 0
					v.PauseStartTime = ``
					v.PauseEndTime = ``
				}
			}
			dayList = append(dayList, v)
		}
	}

	// 周报
	{
		tmpCondition := condition
		tmpPars := pars
		// 报告类型
		tmpCondition += ` AND research_type = ? `
		tmpPars = append(tmpPars, "week")

		list, err := models.GetAllReportChapterTypeList(tmpCondition, tmpPars)
		if err != nil {
			br.Msg = "获取报告章节类型列表失败"
			br.ErrMsg = "获取报告章节类型列表失败, Err: " + err.Error()
			return
		}
		nowTime := time.Now()
		for _, v := range list {
			if v.IsSet == 1 {
				endTime, _ := time.Parse(utils.FormatDate, v.PauseEndTime)
				if nowTime.After(endTime.AddDate(0, 0, 1)) { //设置过期了已经
					v.IsSet = 0
					v.PauseStartTime = ``
					v.PauseEndTime = ``
				}
			}
			weekList = append(weekList, v)
		}
	}

	resp := models.UpdateReportChapterTypeResp{
		Day:  dayList,
		Week: weekList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// GetDayWeekReportPauseTime
// @Title 获取晨报周报的更新暂停时间
// @Description 获取晨报周报的更新暂停时间
// @Success 200 {object} models.ReportListResp
// @router /getDayWeekReportPauseTime [get]
func (this *ReportController) GetDayWeekReportPauseTime() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	list, err := models.GetDayWeekReportPauseTimeList()
	if err != nil {
		br.Msg = "获取晨报周报的更新暂停时间失败"
		br.ErrMsg = "获取晨报周报的更新暂停时间失败, Err: " + err.Error()
		return
	}

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

// SetDayWeekReportUpdateRule
// @Title 设置晨报周报的更新规则
// @Description 设置晨报周报的更新规则
// @Param	request	body models.SetDayWeekReportUpdateRuleReq true "type json string"
// @Success 200 string "操作成功"
// @router /setDayWeekReportUpdateRule [post]
func (this *ReportController) SetDayWeekReportUpdateRule() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var req models.SetDayWeekReportUpdateRuleReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	researchType := req.ResearchType
	if researchType == "" {
		br.Msg = "报告类型不能为空"
		return
	}

	// 设置章节类型的暂停时间
	if err := models.SetDayWeekReportUpdateRule(researchType, req.List); err != nil {
		br.Msg = "设置暂停时间失败"
		br.ErrMsg = "设置暂停时间失败, Err: " + err.Error()
		return
	}
	// 同步到crm数据库
	go func() {
		var syncReq services.ChapterTypeSyncReq
		_, _ = services.ReportChapterTypeSync(&syncReq)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// SetDayWeekReportEnableRule
// @Title 设置晨报周报的永久暂停更新规则
// @Description 设置晨报周报的永久暂停更新规则
// @Param	request	body models.SetDayWeekReportEnableUpdateRuleReq true "type json string"
// @Success 200 string "操作成功"
// @router /setDayWeekReportEnableUpdateRule [post]
func (this *ReportController) SetDayWeekReportEnableRule() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var req models.SetDayWeekReportEnableUpdateRuleReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	dayReportChapterTypeIdList := strings.Split(req.DayReportChapterTypeId, ",")
	weekReportChapterTypeIdList := strings.Split(req.WeekReportChapterTypeId, ",")
	//if len(reportChapterTypeIdList) <= 0 {
	//	br.Msg = "报告类型选择异常"
	//	br.IsSendEmail = false
	//	return
	//}

	// 设置章节类型的禁用状态
	if err := models.SetDayWeekReportEnableUpdateRule(dayReportChapterTypeIdList, weekReportChapterTypeIdList); err != nil {
		br.Msg = "设置永久停更失败"
		br.ErrMsg = "设置永久停更失败, Err: " + err.Error()
		return
	}
	go func() {
		var syncReq services.ChapterTypeSyncReq
		_, _ = services.ReportChapterTypeSync(&syncReq)
	}()

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

// AddDayWeekReport
// @Title 新增晨报周报
// @Description 新增晨报周报
// @Param	request	body models.SaveDayWeekReportReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /addDayWeekReport [post]
//func (this *ReportController) AddDayWeekReport() {
//	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
//	}
//	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
//		br.Ret = 200
//		br.Success = true
//		br.Msg = "操作成功"
//		return
//	}
//
//	var req models.SaveDayWeekReportReq
//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
//	if err != nil {
//		br.Msg = "参数解析异常！"
//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
//		return
//	}
//
//	reportType := req.ReportType
//	if reportType == "" {
//		br.Msg = "请选择报告类型"
//		return
//	}
//	if reportType != utils.REPORT_TYPE_DAY && reportType != utils.REPORT_TYPE_WEEK {
//		br.Msg = "报告类型有误"
//		return
//	}
//	if req.Title == "" {
//		br.Msg = "请输入报告标题"
//		return
//	}
//	if req.CreateTime == "" {
//		br.Msg = "请选择发布时间"
//		return
//	}
//
//	// 报告
//	var frequency, classifyName string
//	var classifyId int
//	if reportType == utils.REPORT_TYPE_DAY {
//		frequency = "日度"
//		classify, err := models.GetClassifyByKeyword("晨报")
//		if err == nil {
//			classifyId = classify.Id
//			classifyName = "晨报"
//		}
//	} else if reportType == utils.REPORT_TYPE_WEEK {
//		frequency = "周度"
//		classify, err := models.GetClassifyByKeyword("周报")
//		if err == nil {
//			classifyId = classify.Id
//			classifyName = "周报"
//		}
//	} else {
//		br.Msg = "报告类型有误"
//		return
//	}
//
//	// 获取晨周报期数
//	yearStart := time.Date(time.Now().Local().Year(), 1, 1, 0, 0, 0, 0, time.Local)
//	maxStage, err := models.GetDayWeekReportStage(classifyId, yearStart)
//	if err != nil {
//		br.Msg = "获取报告期数失败"
//		br.ErrMsg = "获取报告期数失败，Err:" + err.Error()
//		return
//	}
//	stage := maxStage + 1
//
//	item := new(models.Report)
//	item.AddType = 1
//	item.ClassifyIdFirst = classifyId
//	item.ClassifyNameFirst = classifyName
//	item.Title = req.Title
//	item.Author = req.Author
//	item.Frequency = frequency
//	item.State = 1
//	item.Stage = stage
//	item.CreateTime = req.CreateTime
//	item.ModifyTime = time.Now()
//	item.HasChapter = 1
//	item.ChapterType = reportType
//
//	// 章节类型列表
//	typeList, err := models.GetReportChapterTypeListByResearchType(reportType)
//	if err != nil {
//		br.Msg = "获取报告章节类型列表失败"
//		br.ErrMsg = "获取报告章节类型列表失败，Err:" + err.Error()
//		return
//	}
//	var chapterList []*models.ReportChapter
//	// 晨报自动继承上一期内容
//	skip := false
//	if reportType == utils.REPORT_TYPE_DAY {
//		lastDayReport, err := models.GetLastPublishDayWeekReport(utils.REPORT_TYPE_DAY)
//		if err != nil && err.Error() != utils.ErrNoRow() {
//			br.Msg = "获取上一期晨报失败"
//			br.ErrMsg = "获取上一期晨报失败，Err:" + err.Error()
//			return
//		}
//		if lastDayReport != nil {
//			// 继承上一篇章节内容
//			lastReportChapters, err := models.GetPublishedChapterListByReportId(lastDayReport.Id)
//			if err != nil {
//				br.Msg = "获取上一期晨报章节失败"
//				br.ErrMsg = "获取上一期晨报章节失败，Err:" + err.Error()
//				return
//			}
//			chapterMap := make(map[int]*models.ReportChapter)
//			for i := 0; i < len(lastReportChapters); i++ {
//				chapterMap[lastReportChapters[i].TypeId] = lastReportChapters[i]
//			}
//			for _, typeItem := range typeList {
//				v := chapterMap[typeItem.ReportChapterTypeId]
//				chapterItem := new(models.ReportChapter)
//				if v != nil {
//					chapterItem.AddType = 2
//					chapterItem.Title = v.Title
//					chapterItem.ReportType = reportType
//					chapterItem.ClassifyIdFirst = classifyId
//					chapterItem.ClassifyNameFirst = classifyName
//					chapterItem.TypeId = typeItem.ReportChapterTypeId
//					chapterItem.TypeName = typeItem.ReportChapterTypeName
//					chapterItem.Content = v.Content
//					chapterItem.ContentSub = v.ContentSub
//					chapterItem.Stage = stage
//					chapterItem.PublishState = 1
//					chapterItem.Sort = typeItem.Sort
//					chapterItem.CreateTime = req.CreateTime
//					chapterItem.ModifyTime = time.Now()
//				} else {
//					chapterItem.AddType = 1
//					chapterItem.ReportType = reportType
//					chapterItem.ClassifyIdFirst = classifyId
//					chapterItem.ClassifyNameFirst = classifyName
//					chapterItem.TypeId = typeItem.ReportChapterTypeId
//					chapterItem.TypeName = typeItem.ReportChapterTypeName
//					chapterItem.Stage = stage
//					chapterItem.PublishState = 1
//					chapterItem.Sort = typeItem.Sort
//					chapterItem.CreateTime = req.CreateTime
//					chapterItem.ModifyTime = time.Now()
//				}
//				chapterList = append(chapterList, chapterItem)
//			}
//			skip = true
//		}
//	}
//	if !skip {
//		// 空白章节
//		for _, typeItem := range typeList {
//			chapterItem := new(models.ReportChapter)
//			chapterItem.AddType = 1
//			chapterItem.ReportType = reportType
//			chapterItem.ClassifyIdFirst = classifyId
//			chapterItem.ClassifyNameFirst = classifyName
//			chapterItem.TypeId = typeItem.ReportChapterTypeId
//			chapterItem.TypeName = typeItem.ReportChapterTypeName
//			chapterItem.Stage = stage
//			chapterItem.PublishState = 1
//			chapterItem.Sort = typeItem.Sort
//			chapterItem.CreateTime = req.CreateTime
//			chapterItem.ModifyTime = time.Now()
//			chapterList = append(chapterList, chapterItem)
//		}
//	}
//
//	// 新增报告及章节
//	var reportId int64
//	if reportId, err = models.AddReportAndChapter(item, chapterList); err != nil {
//		br.Msg = "保存失败"
//		br.ErrMsg = "新增报告及章节失败, Err: " + err.Error()
//		return
//	}
//	reportCode := utils.MD5(strconv.Itoa(int(reportId)))
//	// 修改唯一编码
//	{
//		go models.ModifyReportCode(reportId, reportCode)
//	}
//
//	// 备份关键数据
//	go services.SaveReportLogs(item, chapterList, sysUser.AdminId, sysUser.RealName)
//
//	resp := new(models.AddResp)
//	resp.ReportId = reportId
//	resp.ReportCode = reportCode
//	br.Ret = 200
//	br.Success = true
//	br.Msg = "保存成功"
//	br.Data = resp
//}

// EditDayWeekReport
// @Title 编辑晨周报
// @Description 编辑晨周报
// @Param	request	body models.SaveDayWeekReportReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /editDayWeekReport [post]
func (this *ReportController) EditDayWeekReport() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var req models.SaveDayWeekReportReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ReportId == 0 {
		br.Msg = "报告ID有误"
		return
	}
	if req.ReportType == "" {
		br.Msg = "请选择报告类型"
		return
	}
	if req.ReportType != utils.REPORT_TYPE_DAY && req.ReportType != utils.REPORT_TYPE_WEEK {
		br.Msg = "报告类型有误"
		return
	}
	if req.Title == "" {
		br.Msg = "请输入报告标题"
		return
	}
	if req.CreateTime == "" {
		br.Msg = "请选择发布时间"
		return
	}

	reportInfo, err := models.GetReportByReportId(req.ReportId)
	if err != nil {
		br.Msg = "获取报告信息失败"
		br.ErrMsg = "获取报告信息失败, Err: " + err.Error()
		return
	}
	if req.ReportType != reportInfo.ChapterType {
		br.Msg = "暂不允许修改晨周报类型"
		return
	}

	reportInfo.Title = req.Title
	reportInfo.CreateTime = req.CreateTime
	reportInfo.Author = req.Author
	err = models.EditReport(reportInfo, int64(req.ReportId))

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
}

// GetLastDayWeekReportChapter
// @Title 获取上一篇已发表的晨周报章节内容
// @Description 获取上一篇已发表的晨周报章节内容
// @Param   TypeId		query	int		true	"品种ID"
// @Param   ReportType	query   string  true	"报告类型 day-晨报; week-周报; "
// @Success 200 {object} company.CompanyListResp
// @router /getLastDayWeekReportChapter [get]
func (this *ReportController) GetLastDayWeekReportChapter() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	typeId, _ := this.GetInt("TypeId")
	reportType := this.GetString("ReportType")
	item, err := models.GetLastPublishedReportChapter(typeId, reportType)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取上一篇晨周报失败, Err: " + err.Error()
		return
	}
	if item != nil {
		item.Content = html.UnescapeString(item.Content)
		item.ContentSub = html.UnescapeString(item.ContentSub)
	}

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

// GetChapterTrendTag
// @Title 获取章节趋势标签列表
// @Description 获取章节趋势标签列表
// @Success 200 Ret=200 获取成功
// @router /getChapterTrendTag [get]
func (this *ReportController) GetChapterTrendTag() {
	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
	}

	list, err := models.GetKeyWordListByFrom("trend")
	if err != nil {
		br.Msg = "获取章节趋势标签列表失败"
		br.ErrMsg = "获取章节趋势标签列表失败, Err: " + err.Error()
		return
	}

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

// GetDayReportTickerList
// @Title 获取晨报数据指标列表
// @Description 获取晨报数据指标列表
// @Param   ReportChapterId  query  int  true  "章节ID"
// @Success 200 Ret=200 保存成功
// @router /getDayReportTickerList [get]
func (this *ReportController) GetDayReportTickerList() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	reportChapterId, _ := this.GetInt("ReportChapterId")
	if reportChapterId <= 0 {
		br.Msg = "章节ID有误"
		return
	}
	chapterInfo, err := models.GetReportChapterInfoById(reportChapterId)
	if err != nil {
		br.Msg = "获取章节信息失败"
		br.ErrMsg = "获取章节信息失败, Err: " + err.Error()
		return
	}

	// 获取ticker列表
	tickerList, err := models.GetDailyBaseColumnList("", chapterInfo.TypeId)
	if err != nil {
		br.Msg = "获取指标列表失败"
		br.ErrMsg = "获取指标列表失败, Err: " + err.Error()
		return
	}
	// 获取章节ticker
	reportTicker, err := models.GetTickerListByReportChapterId(reportChapterId)
	if err != nil {
		br.Msg = "获取章节Ticker失败"
		br.ErrMsg = "获取章节Ticker失败, Err: " + err.Error()
		return
	}
	selectMap := make(map[string]int, 0)
	for i := 0; i < len(reportTicker); i++ {
		selectMap[reportTicker[i].Ticker] = 1
	}
	// 选中状态
	for _, item := range tickerList {
		if _, in := selectMap[item.BaseColumnTicker]; in {
			item.Selected = 1
		}
	}

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

// GetDayWeekReportVideoList
// @Title 获取晨周报音视频列表
// @Description 获取晨周报音视频列表
// @Param   ReportId  query  int  true  "报告ID"
// @Success 200 Ret=200 保存成功
// @router /getDayWeekReportVideoList [get]
func (this *ReportController) GetDayWeekReportVideoList() {
	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
	}

	reportId, _ := this.GetInt("ReportId")
	if reportId <= 0 {
		br.Msg = "参数有误"
		return
	}
	list, err := models.GetReportChapterVideoList(reportId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取报告音频列表失败, Err: " + err.Error()
		return
	}

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

// IsLastDayWeekReportChapter
// @Title 是否为晨周报本期最后一个发布的报告
// @Description 是否为晨周报本期最后一个发布的报告
// @Param	ReportChapterId  query  int  true  "报告章节ID"
// @Success 200 Ret=200 获取成功
// @router /isLastDayWeekReportChapter [get]
func (this *ReportController) IsLastDayWeekReportChapter() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	reportChapterId, _ := this.GetInt("ReportChapterId")
	if reportChapterId <= 0 {
		br.Msg = "参数有误"
		return
	}
	chapterInfo, err := models.GetReportChapterInfoById(reportChapterId)
	if err != nil {
		br.Msg = "章节信息有误"
		br.ErrMsg = "章节信息有误, Err: " + err.Error()
		return
	}
	// 获取已发布章节数及本期报告应发布数
	publishedNum, err := models.CountPublishedChapterNum(chapterInfo.ReportId)
	if err != nil {
		br.Msg = "获取已发布章节数失败"
		br.ErrMsg = "获取已发布章节数失败, Err: " + err.Error()
		return
	}
	enableTypeList, err := models.GetEnableReportChapterTypeList(chapterInfo.ReportType)
	if err != nil {
		br.Msg = "获取章节类型列表失败"
		br.ErrMsg = "获取章节类型列表失败, Err: " + err.Error()
		return
	}
	var isLast bool
	enableNum := len(enableTypeList)
	publishedNum += 1
	if publishedNum == enableNum {
		isLast = true
	}

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

// PublishDayWeekReport
// @Title 发布晨周报
// @Description 发布晨周报
// @Param	request	body models.PublishDayWeekReportReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /publishDayWeekReport [post]
func (this *ReportController) PublishDayWeekReport() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	var req models.PublishDayWeekReportReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportId := req.ReportId
	if reportId <= 0 {
		br.Msg = "参数有误"
		return
	}
	reportInfo, err := models.GetReportByReportId(reportId)
	if err != nil {
		br.Msg = "报告信息有误"
		br.ErrMsg = "报告信息有误, Err: " + err.Error()
		return
	}
	if reportInfo.State == 2 {
		br.Msg = "该报告已发布"
		return
	}

	// 图表刷新状态
	refreshResult := data.CheckBatchChartRefreshResult("report", reportId, 0)
	if !refreshResult {
		br.Msg = "图表刷新未完成，请稍后操作"
		br.ErrMsg = "图表刷新未完成，请稍后操作"
		br.IsSendEmail = false
		return
	}

	tips, err := services.PublishDayWeekReport(reportId)
	if err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "发布晨/周报失败, Err: " + err.Error()
		return
	}
	// 部分章节未发布的提示信息
	if tips != "" {
		br.Data = tips
	}

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

// GetStopDayWeekReportChapterTypeList
// @Title 获取暂停更新的晨报周报章节类型列表
// @Description 获取暂停更新的晨报周报章节类型列表
// @Success 200 {object} models.ReportListResp
// @router /getStopDayWeekReportChapterTypeList [get]
func (this *ReportController) GetStopDayWeekReportChapterTypeList() {
	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
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	stopDay := make([]*models.ReportChapterType, 0)
	stopWeek := make([]*models.ReportChapterType, 0)
	disableDay := make([]*models.ReportChapterType, 0)
	disableWeek := make([]*models.ReportChapterType, 0)

	stopList, err := models.GetStopUpdateReportChapterTypeListByResearchType()
	if err != nil {
		br.Msg = "获取暂停更新报告章节类型列表失败"
		br.ErrMsg = "获取暂停更新报告章节类型列表失败, Err: " + err.Error()
		return
	}

	for _, v := range stopList {
		if v.ResearchType == "day" {
			stopDay = append(stopDay, v)
		} else {
			stopWeek = append(stopWeek, v)
		}
	}

	disableList, err := models.GetDisableUpdateReportChapterTypeListByResearchType()
	if err != nil {
		br.Msg = "获取停止更新报告章节类型列表失败"
		br.ErrMsg = "获取停止更新报告章节类型列表失败, Err: " + err.Error()
		return
	}
	for _, v := range disableList {
		if v.ResearchType == "day" {
			disableDay = append(disableDay, v)
		} else {
			disableWeek = append(disableWeek, v)
		}
	}

	resp := models.StopUpdateReportChapterTypeResp{
		StopDay:     stopDay,
		StopWeek:    stopWeek,
		DisableDay:  disableDay,
		DisableWeek: disableWeek,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// MarkEditStatus
// @Title 标记报告编辑状态
// @Description 标记报告编辑状态接口
// @Param	request	body request.MarkEditEnReport true "type json string"
// @Success 200 标记成功 ；202 标记成功
// @router /mark [post]
func (this *ReportController) MarkEditStatus() {
	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.MarkEditReport
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ReportId <= 0 {
		br.Msg = "缺少报告Id"
		return
	}
	if req.Status <= 0 {
		br.Msg = "标记状态异常"
		return
	}
	//更新标记key
	data, err := services.UpdateReportEditMark(req.ReportId, req.ReportChapterId, sysUser.AdminId, req.Status, sysUser.RealName, this.Lang)
	if err != nil {
		br.Msg = err.Error()
		return
	}

	msg := "标记成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = data
}

// SendMsg
// @Title 模板消息/客群消息推送接口
// @Description 模板消息/客群消息推送接口
// @Param	request	body models.SendTemplateMsgReq true "type json string"
// @Success 200 Ret=200 推送成功
// @router /sendMsg [post]
func (this *ReportController) SendMsg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.SendTemplateMsgReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}
	if req.ReportId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误"
		return
	}

	// 加锁，避免重复点击造成的多次推送
	{
		redisKey := fmt.Sprint("report:send:ths:", req.ReportId)
		ok := utils.Rc.SetNX(redisKey, 1, time.Second*300)
		if !ok {
			br.Msg = "报告已推送, 请勿重复推送"
			return
		}
		defer func() {
			_ = utils.Rc.Delete(redisKey)
		}()
	}

	report, e := models.GetReportById(req.ReportId)
	if e != nil {
		br.Msg = "报告不存在或已被删除, 请刷新页面"
		br.ErrMsg = "获取报告失败, Err: " + e.Error()
		return
	}
	if report.MsgIsSend == 1 && report.ThsMsgIsSend == 1 {
		br.Msg = "消息已推送，请勿重复操作"
		br.ErrMsg = "消息已推送，请勿重复操作"
		return
	}

	// 更新报告发布时间
	videoNameDate := `(` + time.Now().Format("0102") + `)`
	if err = models.UpdateReportPublishTime(req.ReportId, videoNameDate); err != nil {
		br.Msg = "修改报告发布时间失败"
		br.ErrMsg = "修改发布时间失败,Err:" + err.Error()
		return
	}
	if err = models.UpdateReportChapterPublishTime(req.ReportId, videoNameDate); err != nil {
		br.Msg = "修改章节发布时间失败"
		br.ErrMsg = "修改发布时间失败,Err:" + err.Error()
		return
	}

	// 可能存在历史数据两个只推了一个所以此处加个判断
	// 推送模板消息
	if report.MsgIsSend == 0 {
		go func() {
			fmt.Println("推送模板消息:", req.ReportId)
			_ = services.SendMiniProgramReportWxMsg(req.ReportId)
		}()
	}
	// 推送客群消息
	if report.ThsMsgIsSend == 0 {
		go func() {
			// 周报无客群消息
			// 2023-3-19 15:19:24 现在开始周报又要推送了
			//if report.HasChapter == 1 && report.ChapterType == utils.REPORT_TYPE_WEEK {
			//	return
			//}
			_ = services.SendReportMiniToThs(report)
		}()
	}

	// 更新推送消息状态
	if err = models.ModifyReportMsgIsSendV2(req.ReportId); err != nil {
		br.Msg = "推送失败"
		br.ErrMsg = "更新报告消息状态失败, Err:" + err.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "推送成功"
	br.IsAddLog = true
}

// CheckDayWeekReportChapterVideo
// @Title 获取暂停更新的晨报周报章节类型列表
// @Description 获取暂停更新的晨报周报章节类型列表
// @Param   ReportId	query	string	true	"报告ID"
// @Success 200 {object} models.ReportListResp
// @router /CheckDayWeekReportChapterVideo [get]
func (this *ReportController) CheckDayWeekReportChapterVideo() {
	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
	}

	reqReportId := this.GetString("ReportId")
	reportId, _ := strconv.Atoi(reqReportId)
	if reportId <= 0 {
		br.Msg = "报告ID有误"
		return
	}

	// 获取章节列表
	chapterList, err := models.GetChapterListByReportId(reportId)
	if err != nil {
		br.Msg = "获取章节列表失败"
		br.ErrMsg = "获取章节列表失败, Err: " + err.Error()
		return
	}
	var typeNameArr []string
	for _, v := range chapterList {
		if v.VideoUrl == "" || (v.VideoUrl != "" && v.VideoKind == 2) {
			typeNameArr = append(typeNameArr, v.TypeName)
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = typeNameArr
}

// PrePublishReport
// @Title 设置定时发布接口
// @Description 设置定时发布接口
// @Param	request	body models.PrePublishReq true "type json string"
// @Success 200 Ret=200 发布成功
// @router /pre_publish [post]
func (this *ReportController) PrePublishReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.PrePublishReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportId := req.ReportId
	if reportId == 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，报告id不可为空"
		return
	}
	if req.PrePublishTime == "" {
		br.Msg = "发布时间不能为空"
		return
	}
	if req.PreMsgSend != 0 && req.PreMsgSend != 1 {
		br.Msg = "参数错误"
		br.ErrMsg = "是否发送模版消息标识错误"
		return
	}
	prePublishTime, err := time.ParseInLocation(utils.FormatDateTime, req.PrePublishTime, time.Local)
	if err != nil {
		br.Msg = "发布时间格式错误"
		br.ErrMsg = "发布时间格式错误，Err:" + err.Error()
		return
	}
	if prePublishTime.Before(time.Now()) {
		br.Msg = "发布时间不允许选择过去时间"
		return
	}
	if prePublishTime.Before(time.Now().Add(2 * time.Minute)) {
		br.Msg = "发布时间距离当前时间太近了"
		return
	}
	report, err := models.GetReportById(reportId)
	if err != nil {
		br.Msg = "获取报告信息失败"
		br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
		return
	}
	if report == nil {
		br.Msg = "报告不存在"
		return
	}
	if report.HasChapter == 1 && (report.ChapterType == utils.REPORT_TYPE_DAY || report.ChapterType == utils.REPORT_TYPE_WEEK) {
		br.Msg = "晨报周报不支持定时发布"
		return
	}
	if report.Content == "" {
		br.Msg = "报告内容为空，不可发布"
		br.ErrMsg = "报告内容为空，不需要生成,report_id:" + strconv.Itoa(report.Id)
		return
	}

	if report.State == 2 {
		br.Msg = "报告已发布，不可设置定时发布"
		return
	}

	// 校验是否开启了审批流
	opening, e := services.CheckReportOpenApprove(report_approve.FlowReportTypeChinese, report.ClassifyIdFirst, report.ClassifyIdSecond)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "校验报告是否开启审批流失败, Err: " + e.Error()
		return
	}
	if opening {
		br.Msg = "报告已开启审批流, 不可设置定时发布"
		return
	}

	var tmpErr error
	if tmpErr = models.SetPrePublishReportById(report.Id, req.PrePublishTime, req.PreMsgSend); tmpErr != nil {
		br.Msg = "设置定时发布失败"
		br.ErrMsg = "设置定时发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
		return
	}

	// 生成报告pdf和长图
	if report.HasChapter != 1 && report.ChapterType != utils.REPORT_TYPE_DAY && report.ChapterType != utils.REPORT_TYPE_WEEK && req.ReportUrl != "" {
		go services.Report2pdfAndJpeg(req.ReportUrl, report.Id, 1)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "定时发布成功"
}

// SubmitApprove
// @Title 提交审批
// @Description 提交审批接口
// @Param	request	body models.ReportSubmitApproveReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /approve/submit [post]
func (this *ReportController) SubmitApprove() {
	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"
		return
	}
	var req models.ReportSubmitApproveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	reportId := req.ReportId
	if reportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, ReportId: %d", req.ReportId)
		return
	}

	reportOb := new(models.Report)
	reportItem, e := reportOb.GetItemById(reportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告已被删除, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取报告失败, Err: " + e.Error()
		return
	}

	// 校验当前审批配置, 返回下一个状态
	state, e := services.CheckReportCurrState(report_approve.FlowReportTypeChinese, reportItem.ClassifyIdFirst, reportItem.ClassifyIdSecond, models.ReportOperateSubmitApprove)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "校验报告状态失败, Err: " + e.Error()
		return
	}

	// 下一个状态不为待审批时, 仅更新状态
	if state != models.ReportStateWaitApprove {
		reportItem.State = state
		e = reportItem.UpdateReport([]string{"State"})
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "更新报告状态失败, Err: " + e.Error()
			return
		}
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}

	// 提交审批
	approveId, e := services.SubmitReportApprove(report_approve.FlowReportTypeChinese, reportItem.Id, reportItem.Title, reportItem.ClassifyIdFirst, reportItem.ClassifyIdSecond, sysUser.AdminId, sysUser.RealName)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "提交审批失败, Err: " + e.Error()
		return
	}
	reportItem.ApproveId = approveId
	reportItem.State = models.ReportStateWaitApprove
	reportItem.ModifyTime = time.Now().Local()
	e = reportItem.UpdateReport([]string{"ApproveId", "State", "ModifyTime"})
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新报告状态失败, Err: " + e.Error()
		return
	}

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

// CancelApprove
// @Title 撤销审批
// @Description 撤销审批
// @Param	request	body models.ReportCancelApproveReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /approve/cancel [post]
func (this *ReportController) CancelApprove() {
	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"
		return
	}
	var req models.ReportCancelApproveReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数有误"
		br.ErrMsg = "参数解析失败, Err: " + e.Error()
		return
	}
	reportId := req.ReportId
	if reportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, ReportId: %d", req.ReportId)
		return
	}

	reportOb := new(models.Report)
	reportItem, e := reportOb.GetItemById(reportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告已被删除, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取报告失败, Err: " + e.Error()
		return
	}

	// 校验当前审批配置, 返回下一个状态
	state, e := services.CheckReportCurrState(report_approve.FlowReportTypeChinese, reportItem.ClassifyIdFirst, reportItem.ClassifyIdSecond, models.ReportOperateCancelApprove)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "校验报告状态失败, Err: " + e.Error()
		return
	}

	// 下一个状态不为待提交时, 仅更新状态
	if state != models.ReportStateWaitSubmit {
		reportItem.State = state
		e = reportItem.UpdateReport([]string{"State"})
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "更新报告状态失败, Err: " + e.Error()
			return
		}
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		return
	}
	//if reportItem.ApproveId <= 0 {
	//	br.Msg = "报告审批不存在"
	//	br.ErrMsg = fmt.Sprintf("报告审批不存在, ApproveId: %d", reportItem.ApproveId)
	//	return
	//}

	// 撤销审批
	e = services.CancelReportApprove(report_approve.FlowReportTypeChinese, reportItem.Id, reportItem.ApproveId, sysUser.AdminId, sysUser.RealName)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "撤销审批失败, Err: " + e.Error()
		return
	}
	//reportItem.ApproveId = 0
	//reportItem.State = models.ReportStateWaitSubmit
	//reportItem.ModifyTime = time.Now().Local()
	//e = reportItem.UpdateReport([]string{"ApproveId", "State", "ModifyTime"})
	//if e != nil {
	//	br.Msg = "操作失败"
	//	br.ErrMsg = "更新报告状态失败, Err: " + e.Error()
	//	return
	//}

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