eta_mobile/controllers/report.go

package controllers

import (
	"encoding/json"
	"eta/eta_mobile/models"
	"eta/eta_mobile/services"
	"eta/eta_mobile/services/alarm_msg"
	"eta/eta_mobile/utils"
	"fmt"
	"github.com/beego/beego/v2/server/web"
	"github.com/rdlucklib/rdluck_tools/paging"
	"html"
	"os"
	"path"
	"strconv"
	"strings"
	"time"
)

// ReportController 报告
type ReportController struct {
	BaseAuthController
}

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

// @Title 获取报告列表接口
// @Description 获取报告列表
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   TimeType     query string true  "筛选的时间类别：publish_time(发布时间)，modify_time（更新时间）"
// @Param   StartDate   query   string  true       "开始时间"
// @Param   EndDate   query   string  true       "结束时间"
// @Param   Frequency   query   string  true       "频度"
// @Param   ClassifyNameFirst   query   string  true       "一级分类名称"
// @Param   ClassifyNameSecond   query   string  true       "二级分类名称"
// @Param   State   query   int  true       "状态"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Param   PublishSort   query   string  true       "desc:降序，asc 升序（预留）"
// @Param   CompanyType   query   string  false       "产品类型，枚举值：'ficc','权益';不传默认返回全部"
// @Success 200 {object} models.ReportListResp
// @router /list [get]
func (this *ReportController) ListReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	timeType := this.GetString("TimeType")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	frequency := this.GetString("Frequency")
	classifyNameFirst := this.GetString("ClassifyNameFirst")
	classifyNameSecond := this.GetString("ClassifyNameSecond")
	state, _ := this.GetInt("State")
	keyWord := this.GetString("KeyWord")
	companyType := this.GetString("CompanyType")
	msgIsSend, _ := this.GetInt("MsgIsSend")

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

	if timeType == "" {
		timeType = "publish_time"
	}
	if timeType != "publish_time" && timeType != "modify_time" {
		br.Msg = "请选择正确的时间"
		br.ErrMsg = "请选择正确的时间"
		return
	}

	var condition string
	var pars []interface{}

	if keyWord != "" {
		condition += ` AND (title LIKE '%` + keyWord + `%' OR admin_real_name LIKE '%` + keyWord + `%' ) `
	}
	if startDate != "" {
		condition += ` AND ` + timeType + ` >= ? `
		pars = append(pars, startDate)
	}
	if endDate != "" {
		condition += ` AND ` + timeType + ` <= ? `
		pars = append(pars, endDate)
	}
	if frequency != "" {
		condition += ` AND frequency = ? `
		pars = append(pars, frequency)
	}
	if classifyNameFirst != "" {
		condition += ` AND classify_name_first = ? `
		pars = append(pars, classifyNameFirst)
	}

	if classifyNameSecond != "" {
		condition += ` AND classify_name_second = ? `
		pars = append(pars, classifyNameSecond)
	}
	if state > 0 {
		condition += ` AND state = ? `
		pars = append(pars, state)
	}
	// 消息是否已推送 1-未推送; 2-已推送
	if msgIsSend == 1 {
		condition += ` AND (msg_is_send = 0 OR ths_msg_is_send = 0) `
	}
	if msgIsSend == 2 {
		condition += ` AND msg_is_send = 1 AND ths_msg_is_send = 1 `
	}
	total, err := models.GetReportListCount(condition, pars, companyType)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, err := models.GetReportList(condition, pars, companyType, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	listLen := len(list)
	if listLen > 0 {
		reportIdArr := make([]string, 0)
		syncReportIdArr := make([]string, 0) // 同步过来的报告IDs
		for i := 0; i < listLen; i++ {
			reportIdArr = append(reportIdArr, strconv.Itoa(list[i].Id))
			if list[i].OldReportId > 0 {
				syncReportIdArr = append(syncReportIdArr, strconv.Itoa(list[i].OldReportId))
			}
		}
		reportIds := strings.Join(reportIdArr, ",")
		syncReportIds := strings.Join(syncReportIdArr, ",")

		// 查询同步过来的报告对应的老报告PV+UV
		pvMap := make(map[int]int, 0)
		uvMap := make(map[int]int, 0)
		if syncReportIds != "" {
			puvList, e := models.GetPUVByResearchReportIds(syncReportIds)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取同步报告对应的PV、UV失败, Err: " + e.Error()
				return
			}
			puvLen := len(puvList)
			for i := 0; i < puvLen; i++ {
				pvMap[puvList[i].ResearchReportId] = puvList[i].Pv
				uvMap[puvList[i].ResearchReportId] = puvList[i].Uv
			}
		}
		// 晨周报音频列表
		videoList, err := models.GetReportChapterVideoListByReportIds(reportIds)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取报告音频文件失败，Err:" + err.Error()
			return
		}
		for i := 0; i < listLen; i++ {
			list[i].Content = html.UnescapeString(list[i].Content)
			list[i].ContentSub = html.UnescapeString(list[i].ContentSub)
			// 除周报外其余报告均可推送客群
			list[i].NeedThsMsg = 1
			//if list[i].HasChapter == 1 && list[i].ChapterType == utils.REPORT_TYPE_WEEK {
			//	list[i].NeedThsMsg = 0
			//}
			chapterList := make([]*models.ReportChapterVideoList, 0)
			for ii := 0; ii < len(videoList); ii++ {
				if list[i].Id == videoList[ii].ReportId {
					chapterList = append(chapterList, videoList[ii])
				}
			}
			list[i].ChapterVideoList = chapterList
			list[i].Pv += pvMap[list[i].OldReportId]
			list[i].Uv += uvMap[list[i].OldReportId]
		}
	}

	for _, item := range list {
		/*key := fmt.Sprint(`crm:report:edit:`, item.Id)
		opUserId, _ := utils.Rc.RedisInt(key)
		//如果当前没有人操作，获取当前操作人是本人，那么编辑按钮可用
		if opUserId <= 0 || (opUserId == this.SysUser.AdminId) || item.ClassifyNameFirst == "周报" || item.ClassifyNameFirst == "晨报" {
			item.CanEdit = true
		} else {
			adminInfo, errAdmin := system.GetSysUserById(opUserId)
			if errAdmin != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败，Err:" + errAdmin.Error()
				return
			}
			item.Editor = adminInfo.RealName
		}*/
		if item.ClassifyNameFirst == "周报" || item.ClassifyNameFirst == "晨报" {
			item.CanEdit = true
		} else {
			markStatus, err := services.UpdateReportEditMark(item.Id, this.SysUser.AdminId, 2, this.SysUser.RealName)
			if err != nil {
				br.Msg = "查询标记状态失败"
				br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
				return
			}
			if markStatus.Status == 0 {
				item.CanEdit = true
			} else {
				item.Editor = markStatus.Editor
			}
		}
	}

	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.ReportListResp)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @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
		}
		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
			}
			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)
			}()
		}
	}
	// 发布晨周报部分章节未发布的提示
	if tips != "" {
		br.Data = tips
	}

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

// @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
	}
	err = models.PublishCancleReport(req.ReportIds, publishTimeNullFlag)
	if err != nil {
		br.Msg = "取消发布失败"
		br.ErrMsg = "取消发布失败,Err:" + err.Error()
		return
	}
	// 更新ES禁用
	{
		go services.UpdateReportEs(req.ReportIds, 1)
	}

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

// @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 = "删除成功"
}

// @Title 新增报告接口
// @Description 新增报告
// @Param	request	body models.AddReq true "type json string"
// @Success 200 {object} models.AddResp
// @router /add [post]
func (this *ReportController) Add() {
	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.AddReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	var contentSub string
	if req.Content != "" {
		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)
		}
	}
	maxStage, err := models.GetReportStage(req.ClassifyIdFirst, req.ClassifyIdSecond)
	if err != nil {
		br.Msg = "期数获取失败！"
		br.ErrMsg = "期数获取失败，Err:" + err.Error()
		return
	}

	item := new(models.Report)
	item.AddType = req.AddType
	item.ClassifyIdFirst = req.ClassifyIdFirst
	item.ClassifyNameFirst = req.ClassifyNameFirst
	item.ClassifyIdSecond = req.ClassifyIdSecond
	item.ClassifyNameSecond = req.ClassifyNameSecond
	item.Title = req.Title
	item.Abstract = req.Abstract
	item.Author = req.Author
	item.Frequency = req.Frequency
	item.State = req.State
	item.Content = html.EscapeString(req.Content)
	item.Stage = maxStage + 1
	item.ContentSub = html.EscapeString(contentSub)
	item.CreateTime = req.CreateTime
	item.ModifyTime = time.Now()
	item.ReportVersion = req.ReportVersion
	item.AdminId = sysUser.AdminId
	item.AdminRealName = sysUser.RealName
	newReportId, err := models.AddReport(item)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	//处理权限
	{
		permissionItems, err := models.GetPermission(req.ClassifyNameSecond)
		if err != nil {
			go alarm_msg.SendAlarmMsg("获取权限失败，Err："+err.Error(), 3)
			//utils.SendEmail(utils.APPNAME+"失败提醒", "获取权限失败，Err:"+err.Error(), utils.EmailSendToUsers)
		}
		for _, v := range permissionItems {
			err = models.AddChartPermissionChapterMapping(v.ChartPermissionId, newReportId)
			if err != nil {
				go alarm_msg.SendAlarmMsg("新增权限失败，Err："+err.Error(), 3)
				//utils.SendEmail(utils.APPNAME+"失败提醒", "新增权限失败，Err:"+err.Error()+strconv.FormatInt(newReportId, 10), utils.EmailSendToUsers)
			}
		}
	}
	reportCode := utils.MD5(strconv.Itoa(int(newReportId)))
	//修改唯一编码
	{
		go models.ModifyReportCode(newReportId, reportCode)
	}
	resp := new(models.AddResp)
	resp.ReportId = newReportId
	resp.ReportCode = reportCode
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
}

// @Title 编辑报告接口
// @Description 编辑报告
// @Param	request	body models.EditReq true "type json string"
// @Success 200 {object} models.EditResp
// @router /edit [post]
func (this *ReportController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	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 != "" {
		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)
		}
	}

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	//更新标记key
	markStatus, err := services.UpdateReportEditMark(int(req.ReportId), sysUser.AdminId, 1, sysUser.RealName)
	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, _ := models.GetReportById(int(req.ReportId))
	if report != nil {
		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
		}
	}

	item := new(models.Report)
	item.ClassifyIdFirst = req.ClassifyIdFirst
	item.ClassifyNameFirst = req.ClassifyNameFirst
	item.ClassifyIdSecond = req.ClassifyIdSecond
	item.ClassifyNameSecond = req.ClassifyNameSecond
	item.Title = req.Title
	item.Abstract = req.Abstract
	item.Author = req.Author
	item.Frequency = req.Frequency
	item.State = req.State
	item.Stage = stage
	item.Content = html.EscapeString(req.Content)
	item.ContentSub = html.EscapeString(contentSub)
	item.CreateTime = req.CreateTime
	err = models.EditReport(item, req.ReportId)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	//处理权限
	{
		err = models.RemoveChartPermissionChapterMapping(req.ReportId)
		if err != nil {
			go alarm_msg.SendAlarmMsg("修改删除报告权限失败，Err："+err.Error(), 3)
			//utils.SendEmail(utils.APPNAME+"失败提醒", "修改删除报告权限失败，Err:"+err.Error(), utils.EmailSendToUsers)
		}
		permissionItems, err := models.GetPermission(req.ClassifyNameSecond)
		if err != nil {
			go alarm_msg.SendAlarmMsg("获取权限失败，Err："+err.Error(), 3)
			//utils.SendEmail(utils.APPNAME+"失败提醒", "获取权限失败，Err:"+err.Error(), utils.EmailSendToUsers)
		}
		for _, v := range permissionItems {
			err = models.AddChartPermissionChapterMapping(v.ChartPermissionId, req.ReportId)
			if err != nil {
				go alarm_msg.SendAlarmMsg("新增权限失败，Err："+err.Error(), 3)
				//utils.SendEmail(utils.APPNAME+"失败提醒", "新增权限失败，Err:"+err.Error()+strconv.FormatInt(req.ReportId, 10), utils.EmailSendToUsers)
			}
		}
	}
	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
}

// @Title 获取报告详情接口
// @Description 获取报告详情
// @Param	request	body models.ReportDetailReq true "type json string"
// @Success 200 {object} models.Report
// @router /detail [get]
func (this *ReportController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	/*var req models.ReportDetailReq
	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 = "参数错误"
		return
	}*/
	reportId, err := this.GetInt("ReportId")
	if err != nil {
		br.Msg = "获取参数失败！"
		br.ErrMsg = "获取参数失败，Err:" + err.Error()
		return
	}
	if reportId <= 0 {
		br.Msg = "参数错误"
		return
	}
	item, err := models.GetReportById(reportId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	chapterList := make([]*models.ReportChapter, 0)
	if item.HasChapter == 1 && (item.ChapterType == utils.REPORT_TYPE_DAY || item.ChapterType == utils.REPORT_TYPE_WEEK) {
		// 获取章节内容
		tmpChapterList, err := models.GetPublishedChapterListByReportId(item.Id)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取晨/周报章节列表失败, Err: " + err.Error()
			return
		}

		if len(tmpChapterList) > 0 {
			// 获取更新规则
			researchType := tmpChapterList[0].ReportType
			chapterTypeList, tmpErr := models.GetAllReportChapterTypeListByResearchType(researchType)
			if tmpErr != nil {
				br.Msg = "获取更新规则失败"
				br.ErrMsg = "获取更新规则失败, Err: " + tmpErr.Error()
				return
			}
			// 调整章节更新
			nowTime := time.Now().Local()
			for _, item := range tmpChapterList {
				stop := false
				for _, rule := range chapterTypeList {
					if rule.ReportChapterTypeId == item.TypeId {
						//fmt.Println("rule.Enabled :", rule.Enabled, ";name=", rule.ReportChapterTypeName, "item.IsEdit:", item.IsEdit, "rule.IsSet:", rule.IsSet)
						// 如果被永久暂停更新了
						if rule.Enabled == 0 && item.IsEdit == 0 { //该章节已被永久禁用，同时未被操作过
							stop = true
						} else if rule.PauseStartTime != "" && rule.PauseEndTime != "" && rule.PauseStartTime != utils.EmptyDateStr && rule.PauseEndTime != utils.EmptyDateStr {
							startTime, timeErr := time.ParseInLocation(utils.FormatDate, rule.PauseStartTime, time.Local)
							if timeErr != nil {
								br.Msg = "获取更新规则失败"
								br.ErrMsg = "更新规则时间转换失败4001, Err: " + timeErr.Error()
								return
							}
							endTime, timeErr := time.ParseInLocation(utils.FormatDate, rule.PauseEndTime, time.Local)
							if timeErr != nil {
								br.Msg = "获取更新规则失败"
								br.ErrMsg = "更新规则时间转换失败4002, Err: " + timeErr.Error()
								return
							}
							// 暂停更新
							if nowTime.After(startTime) && nowTime.Before(endTime.AddDate(0, 0, 1)) {
								stop = true
							}
							break
						}
					}
				}
				if !stop {
					item.Content = html.UnescapeString(item.Content)
					item.ContentSub = html.UnescapeString(item.ContentSub)
					chapterList = append(chapterList, item)
				}
			}
		}

		item.Abstract = item.Title
	}
	item.Content = html.UnescapeString(item.Content)
	item.ContentSub = html.UnescapeString(item.ContentSub)

	resp := &models.ReportDetailView{
		ReportDetail: item,
		ChapterList:  chapterList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @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
	}
	ext := path.Ext(h.Filename)
	dateDir := time.Now().Format("20060102")
	uploadDir := utils.STATIC_DIR + "hongze/" + dateDir
	err = os.MkdirAll(uploadDir, 777)
	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, err := services.UploadAliyun(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
}

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

// 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, "%"+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
}

// @Title 保存草稿
// @Description 保存草稿
// @Param	request	body models.SaveReportContent true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /saveReportContent [post]
func (this *ReportController) SaveReportContent() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	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.SaveReportContent
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportId := req.ReportId
	noChangeFlag := req.NoChange
	fmt.Println("reportId:", reportId)
	if reportId > 0 {
		markStatus, err := services.UpdateReportEditMark(int(req.ReportId), sysUser.AdminId, 1, sysUser.RealName)
		if err != nil {
			br.Msg = err.Error()
			return
		}
		if markStatus.Status == 1 {
			br.Msg = markStatus.Msg
			return
		}
	}
	if reportId > 0 && noChangeFlag != 1 {
		fmt.Println("line 617")
		content := req.Content
		if content == "" {
			content = this.GetString("Content")
		}
		if content != "" {
			contentClean, e := services.FilterReportContentBr(req.Content)
			if e != nil {
				br.Msg = "内容去除前后空格失败"
				br.ErrMsg = "内容去除前后空格失败, Err: " + e.Error()
				return
			}
			content = contentClean

			contentSub, err := services.GetReportContentSub(content)
			if err != nil {
				go alarm_msg.SendAlarmMsg("解析 ContentSub 失败，Err："+err.Error(), 3)
				//utils.SendEmail(utils.APPNAME+"失败提醒", "解析 ContentSub 失败，Err:"+err.Error(), utils.EmailSendToUsers)
			}
			content = html.EscapeString(content)
			contentSub = html.EscapeString(contentSub)
			err = models.EditReportContent(reportId, content, contentSub)
			if err != nil {
				br.Msg = "保存失败"
				br.ErrMsg = "保存失败，Err:" + err.Error()
				return
			}
			go models.AddReportSaveLog(reportId, this.SysUser.AdminId, content, contentSub, this.SysUser.AdminName)
		}
	}
	resp := new(models.SaveReportContentResp)
	resp.ReportId = reportId
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功成功"
	br.Data = resp
}

// @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
	}
	ext := path.Ext(h.Filename)
	dateDir := time.Now().Format("20060102")
	uploadDir := utils.STATIC_DIR + "hongze/" + dateDir
	err = os.MkdirAll(uploadDir, 777)
	if err != nil {
		return
	}
	randStr := utils.GetRandStringNoSpecialChar(28)
	fileName := randStr + ext
	fpath := uploadDir + "/" + fileName
	defer f.Close() //关闭上传文件
	err = this.SaveToFile("file", fpath)
	if err != nil {
		return
	}
	//上传到阿里云
	resourceUrl, err := services.UploadAliyun(fileName, fpath)
	if err != nil {
		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 {
		return
	}
	resp := new(models.ResourceResp)
	resp.Id = newId
	resp.ResourceUrl = resourceUrl
	this.Data["json"] = map[string]string{"link": resourceUrl}
	this.ServeJSON()
}

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

	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
}

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

	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 = "保存成功"
}

// @Title 获取报告章节列表
// @Description 获取报告章节列表
// @Param   ReportId	query	string	true	"报告ID"
// @Success 200 {object} company.CompanyListResp
// @router /getReportChapterList [get]
func (this *ReportController) GetReportChapterList() {
	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
	}
	typeList, err := models.GetReportChapterTypeList()
	if err != nil {
		br.Msg = "获取章节类型列表失败"
		br.ErrMsg = "获取章节类型列表失败, Err: " + err.Error()
		return
	}
	typeIdImg := make(map[int]string, 0)
	for i := 0; i < len(typeList); i++ {
		typeIdImg[typeList[i].ReportChapterTypeId] = typeList[i].EditImgUrl
	}

	resp := make([]*models.ReportChapterResp, 0)
	if len(chapterList) > 0 {
		// 获取更新规则
		researchType := chapterList[0].ReportType
		chapterTypeList, tmpErr := models.GetAllReportChapterTypeListByResearchType(researchType)
		if tmpErr != nil {
			br.Msg = "获取更新规则失败"
			br.ErrMsg = "获取更新规则失败, Err: " + tmpErr.Error()
			return
		}
		// 调整章节更新
		nowTime := time.Now().Local()
		for _, item := range chapterList {
			stop := false
			for _, rule := range chapterTypeList {
				if rule.ReportChapterTypeId == item.TypeId {
					//fmt.Println("rule.Enabled :", rule.Enabled, ";name=", rule.ReportChapterTypeName, "item.IsEdit:", item.IsEdit, "rule.IsSet:", rule.IsSet)
					// 如果被永久暂停更新了
					if rule.Enabled == 0 && item.IsEdit == 0 { //该章节已被永久禁用，同时未被操作过
						stop = true
					} else if rule.PauseStartTime != "" && rule.PauseEndTime != "" && rule.PauseStartTime != utils.EmptyDateStr && rule.PauseEndTime != utils.EmptyDateStr {
						startTime, timeErr := time.ParseInLocation(utils.FormatDate, rule.PauseStartTime, time.Local)
						if timeErr != nil {
							br.Msg = "获取更新规则失败"
							br.ErrMsg = "更新规则时间转换失败4001, Err: " + timeErr.Error()
							return
						}
						endTime, timeErr := time.ParseInLocation(utils.FormatDate, rule.PauseEndTime, time.Local)
						if timeErr != nil {
							br.Msg = "获取更新规则失败"
							br.ErrMsg = "更新规则时间转换失败4002, Err: " + timeErr.Error()
							return
						}
						// 暂停更新
						if nowTime.After(startTime) && nowTime.Before(endTime.AddDate(0, 0, 1)) {
							stop = true
						}
						break
					}
				}
			}
			if !stop {
				resp = append(resp, &models.ReportChapterResp{
					ReportChapterId:  item.ReportChapterId,
					ReportId:         item.ReportId,
					ReportType:       item.ReportType,
					TypeId:           item.TypeId,
					TypeName:         item.TypeName,
					TypeEditImg:      typeIdImg[item.TypeId],
					Title:            item.Title,
					IsEdit:           item.IsEdit,
					Trend:            item.Trend,
					Sort:             item.Sort,
					PublishState:     item.PublishState,
					VideoUrl:         item.VideoUrl,
					VideoName:        item.VideoName,
					VideoPlaySeconds: item.VideoPlaySeconds,
					VideoSize:        item.VideoSize,
					VideoKind:        item.VideoKind,
					ModifyTime:       item.ModifyTime.Format(utils.FormatDate),
				})
			}
		}
	}

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

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

	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
}

// @Title 获取晨周报章节信息
// @Description 获取晨周报章节信息
// @Param	ReportChapterId  query  int  true  "报告章节ID"
// @Success 200 Ret=200 保存成功
// @router /getDayWeekChapter [get]
func (this *ReportController) GetDayWeekChapter() {
	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
	}

	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
	}
	if chapterInfo != nil {
		chapterInfo.Content = html.UnescapeString(chapterInfo.Content)
		chapterInfo.ContentSub = html.UnescapeString(chapterInfo.ContentSub)
	}

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

// @Title 编辑晨周报章节内容
// @Description 编辑晨周报章节内容
// @Param	request	body models.EditReportChapterReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /editDayWeekChapter [post]
func (this *ReportController) EditDayWeekChapter() {
	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.EditReportChapterReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportChapterId := req.ReportChapterId
	if reportChapterId <= 0 {
		br.Msg = "报告章节ID有误"
		return
	}
	//if req.Title == "" {
	//	br.Msg = "请输入标题"
	//	return
	//}
	if req.Content == "" {
		br.Msg = "请输入内容"
		return
	}
	if req.AddType == 0 {
		br.Msg = "请选择新增方式"
		return
	}
	reportChapterInfo, err := models.GetReportChapterInfoById(reportChapterId)
	if err != nil {
		br.Msg = "报告章节信息有误"
		br.ErrMsg = "报告章节信息有误, Err: " + err.Error()
		return
	}
	reqTickerList := req.TickerList
	newContent := req.Content
	// 更新章节及指标
	contentSub := ""
	if req.Content != "" {
		contentClean, e := services.FilterReportContentBr(req.Content)
		if e != nil {
			br.Msg = "内容去除前后空格失败"
			br.ErrMsg = "内容去除前后空格失败, Err: " + e.Error()
			return
		}
		req.Content = contentClean

		contentSub, err = services.GetReportContentSub(req.Content)
		if err != nil {
			br.Msg = "内容分段解析失败"
			br.ErrMsg = "编辑报告章节-解析 ContentSub 失败, Err: " + err.Error()
			return
		}
	}
	if req.Content == "" {
		req.Content = newContent
	}
	reportChapterInfo.Title = req.Title
	reportChapterInfo.AddType = req.AddType
	reportChapterInfo.Author = req.Author
	reportChapterInfo.Content = html.EscapeString(req.Content)
	reportChapterInfo.ContentSub = html.EscapeString(contentSub)
	reportChapterInfo.IsEdit = 1
	reportChapterInfo.CreateTime = req.CreateTime
	reportChapterInfo.VideoUrl = req.VideoUrl
	reportChapterInfo.VideoName = req.VideoName
	reportChapterInfo.VideoPlaySeconds = req.VideoPlaySeconds
	reportChapterInfo.VideoSize = req.VideoSize
	reportChapterInfo.VideoKind = 1
	updateCols := make([]string, 0)
	updateCols = append(updateCols, "Title", "AddType", "Author", "Content", "ContentSub", "IsEdit", "CreateTime")
	if req.VideoUrl != "" {
		updateCols = append(updateCols, "VideoUrl", "VideoName", "VideoSize", "VideoPlaySeconds", "VideoKind")
	}
	// 晨报更新指标
	tickerList := make([]*models.ReportChapterTicker, 0)
	if reportChapterInfo.ReportType == "day" && len(reqTickerList) > 0 {
		nowTime := time.Now()
		for i := 0; i < len(reqTickerList); i++ {
			tickerList = append(tickerList, &models.ReportChapterTicker{
				ReportChapterId: reportChapterInfo.ReportChapterId,
				Sort:            reqTickerList[i].Sort,
				Ticker:          reqTickerList[i].Ticker,
				CreateTime:      nowTime,
				UpdateTime:      nowTime,
			})
		}
	}
	err = models.UpdateChapterAndTicker(reportChapterInfo, updateCols, tickerList)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "报告章节内容保存失败, Err: " + err.Error()
		return
	}

	// 备份关键数据
	chapters := make([]*models.ReportChapter, 0)
	chapters = append(chapters, reportChapterInfo)
	go services.SaveReportLogs(nil, chapters, sysUser.AdminId, sysUser.RealName)

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

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

// @Title 编辑章节趋势标签
// @Description 编辑章节趋势标签
// @Param	request	body models.EditReportChapterReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /editChapterTrendTag [post]
func (this *ReportController) EditChapterTrendTag() {
	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.EditChapterTrendTagReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportChapterId <= 0 {
		br.Msg = "章节ID有误"
		return
	}
	if req.Trend == "" {
		br.Msg = "请输入标签"
		return
	}

	chapterInfo, err := models.GetReportChapterInfoById(req.ReportChapterId)
	if err != nil {
		br.Msg = "获取章节信息失败"
		br.ErrMsg = "获取章节信息失败, Err: " + err.Error()
		return
	}

	// 更新章节标签
	chapterInfo.Trend = req.Trend
	updateCols := make([]string, 0)
	updateCols = append(updateCols, "Trend")
	if err = chapterInfo.UpdateChapter(updateCols); err != nil {
		br.Msg = "更新标签失败"
		br.ErrMsg = "更新标签失败, Err: " + err.Error()
		return
	}

	// 添加关键词
	if err = models.AddTrendTagKeyWord(req.Trend); err != nil {
		br.Msg = "添加标签关键词失败"
		br.ErrMsg = "添加标签关键词失败, Err: " + err.Error()
		return
	}

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

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

	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
}

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

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

	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
}

// @Title 发布晨周报章节
// @Description 发布晨周报章节
// @Param	request	body models.PublishReportChapterReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /publishDayWeekReportChapter [post]
func (this *ReportController) PublishDayWeekReportChapter() {
	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.PublishReportChapterReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ReportChapterId <= 0 {
		br.Msg = "参数有误"
		return
	}
	if req.Title == "" {
		br.Msg = "请输入标题"
		return
	}
	if req.Content == "" {
		br.Msg = "请输入内容"
		return
	}
	if req.AddType == 0 {
		br.Msg = "请选择新增方式"
		return
	}

	reqTickerList := req.TickerList

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

	reportInfo, err := models.GetReportById(chapterInfo.ReportId)
	if err != nil {
		br.Msg = "查询报告有误"
		br.ErrMsg = "查询报告信息失败, Err: " + err.Error()
		return
	}

	// 获取规则配置
	reportChapterTypeRule, err := models.GetReportChapterTypeById(chapterInfo.TypeId)
	if err != nil {
		br.Msg = "获取配置信息异常"
		br.ErrMsg = "获取配置信息异常, Err: " + err.Error()
		return
	}
	if reportChapterTypeRule.Enabled == 0 {
		br.Msg = "该章节已永久停更"
		br.ErrMsg = "该章节已永久停更 "
		br.IsSendEmail = false
		return
	}

	updateCols := make([]string, 0)
	updateCols = append(updateCols, "Title", "AddType", "Author", "Content", "ContentSub", "IsEdit", "CreateTime", "PublishState", "PublishTime")

	nowTime := time.Now()
	var publishTime time.Time
	if reportInfo.MsgIsSend == 1 && reportInfo.PublishTime != "" { //如果报告曾经发布过，并且已经发送过模版消息，则章节的发布时间为报告的发布时间
		publishTime, _ = time.ParseInLocation(utils.FormatDateTime, reportInfo.PublishTime, time.Local)
	} else {
		publishTime = time.Now()
	}
	if req.VideoUrl != "" {
		chapterInfo.VideoUrl = req.VideoUrl
		chapterInfo.VideoName = req.VideoName
		chapterInfo.VideoSize = req.VideoSize
		chapterInfo.VideoPlaySeconds = req.VideoPlaySeconds
		chapterInfo.VideoKind = 1

		updateCols = append(updateCols, "VideoUrl", "VideoName", "VideoSize", "VideoPlaySeconds", "VideoKind")
	} else {
		if chapterInfo.VideoUrl == "" {
			// 生成video
			videoUrl, videoName, videoSize, videoPlaySeconds, err := services.CreateReportVideo(req.Title, req.Content, publishTime.Format(utils.FormatDateTime))
			if err != nil {
				br.Msg = "生成video失败"
				br.ErrMsg = "生成video失败, Err: " + err.Error()
				return
			}
			chapterInfo.VideoUrl = videoUrl
			chapterInfo.VideoName = videoName
			chapterInfo.VideoSize = videoSize
			chapterInfo.VideoPlaySeconds = fmt.Sprintf("%.2f", videoPlaySeconds)
			chapterInfo.VideoKind = 2
			updateCols = append(updateCols, "VideoUrl", "VideoName", "VideoSize", "VideoPlaySeconds", "VideoKind")
		}
	}

	// 更新章节信息
	contentSub := ""
	if req.Content != "" {
		contentClean, e := services.FilterReportContentBr(req.Content)
		if e != nil {
			br.Msg = "内容去除前后空格失败"
			br.ErrMsg = "内容去除前后空格失败, Err: " + e.Error()
			return
		}
		req.Content = contentClean

		contentSub, err = services.GetReportContentSub(req.Content)
		if err != nil {
			br.Msg = "内容分段解析失败"
			br.ErrMsg = "编辑报告章节-解析 ContentSub 失败, Err: " + err.Error()
			return
		}
	}
	chapterInfo.Title = req.Title
	chapterInfo.AddType = req.AddType
	chapterInfo.Author = req.Author
	chapterInfo.Content = html.EscapeString(req.Content)
	chapterInfo.ContentSub = html.EscapeString(contentSub)
	chapterInfo.IsEdit = 1
	chapterInfo.CreateTime = req.CreateTime
	chapterInfo.PublishState = 2
	chapterInfo.PublishTime = publishTime

	// 晨报更新指标
	tickerList := make([]*models.ReportChapterTicker, 0)
	if chapterInfo.ReportType == "day" && len(reqTickerList) > 0 {
		for i := 0; i < len(reqTickerList); i++ {
			tickerList = append(tickerList, &models.ReportChapterTicker{
				ReportChapterId: chapterInfo.ReportChapterId,
				Sort:            reqTickerList[i].Sort,
				Ticker:          reqTickerList[i].Ticker,
				CreateTime:      nowTime,
				UpdateTime:      nowTime,
			})
		}
	}
	if err = models.UpdateChapterAndTicker(chapterInfo, updateCols, tickerList); err != nil {
		br.Msg = "发布失败"
		br.ErrMsg = "报告章节内容保存失败, Err: " + err.Error()
		return
	}
	// 更新章节ES
	{
		go services.UpdateReportChapterEs(chapterInfo.ReportChapterId)
	}

	// 同时发布报告
	if req.PublishReport == 1 {
		if _, e := services.PublishDayWeekReport(chapterInfo.ReportId); e != nil {
			br.Msg = "章节发布成功，报告发布失败，请手动发布报告"
			br.ErrMsg = "发布晨/周报失败, Err: " + e.Error()
			return
		}
	}

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

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

	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
	}
	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 = "操作成功"
}

// GetSunCode 获取太阳码
// @Title 公共模块
// @Description 获取分享海报
// @Param	request	body models.SunCodeReq true "type json string"
// @Success 200 {object} string "获取成功"
// @failure 400 {string} string "获取失败"
// @router /getSunCode [post]
func (this *ReportController) GetSunCode() {
	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.SunCodeReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	var sunCodeUrl string
	//先查，查不到再去生成上传
	item, err := models.GetYbPcSunCode(req.CodeScene, req.CodePage)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "查询太阳码失败！"
		br.ErrMsg = "查询太阳码失败，Err:" + err.Error()
		return
	}
	if item != nil {
		sunCodeUrl = item.SuncodeURL
	}

	if sunCodeUrl == "" {
		sunCodeUrl, err = services.PcCreateAndUploadSunCode(req.CodeScene, req.CodePage)
		if err != nil {
			br.Msg = "生成太阳码失败！"
			br.ErrMsg = "生成太阳码失败，Err:" + err.Error()
			return
		}
	}

	br.Data = sunCodeUrl
	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
	}

	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, sysUser.AdminId, req.Status, sysUser.RealName)
	if err != nil {
		br.Msg = err.Error()
		return
	}

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

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

// GetStopDayWeekReportChapterTypeList
// @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
	}

	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
	}

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