eta_api/controllers/smart_report/smart_report.go

package smart_report

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/smart_report"
	"eta/eta_api/models/system"
	"eta/eta_api/services"
	smartReportService "eta/eta_api/services/smart_report"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"html"
	"strings"
	"time"
)

// SmartReportController 智能研报
type SmartReportController struct {
	controllers.BaseAuthController
}

// Add
// @Title 新增
// @Description 新增
// @Param	request	body smart_report.SmartReportAddReq true "type json string"
// @Success 200 {object} smart_report.SmartReportItem
// @router /add [post]
func (this *SmartReportController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportAddReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.AddType != 1 && req.AddType != 2 {
		br.Msg = "请选择新增方式"
		return
	}
	if req.ClassifyIdFirst <= 0 || req.ClassifyIdSecond <= 0 {
		br.Msg = "请选择分类"
		return
	}
	req.Title = strings.TrimSpace(req.Title)
	if req.Title == "" {
		br.Msg = "请输入标题"
		return
	}

	reportOB := new(smart_report.SmartReport)
	stageMax, e := reportOB.GetMaxStageByClassifyId(req.ClassifyIdSecond)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取期数失败, Err: " + e.Error()
		return
	}
	stageMax += 1

	item := new(smart_report.SmartReport)
	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.Stage = stageMax
	item.AdminId = sysUser.AdminId
	item.AdminRealName = sysUser.RealName
	item.CreateTime = time.Now().Local()
	item.ModifyTime = time.Now().Local()
	if e = item.Create(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "新增研报失败, Err: " + e.Error()
		return
	}
	uniqueCode := utils.MD5(fmt.Sprint("smart_", item.SmartReportId))
	item.ReportCode = uniqueCode
	if e = item.Update([]string{"ReportCode"}); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新研报编码失败, Err: " + e.Error()
		return
	}
	resp := smart_report.FormatSmartReport2Item(item)

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

// Edit
// @Title 编辑
// @Description 编辑
// @Param	request	body smart_report.SmartReportEditReq true "type json string"
// @Success 200 {object} smart_report.SmartReportItem
// @router /edit [post]
func (this *SmartReportController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportEditReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.SmartReportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "报告ID为空"
		return
	}
	if req.ClassifyIdFirst <= 0 || req.ClassifyIdSecond <= 0 {
		br.Msg = "请选择分类"
		return
	}
	req.Title = strings.TrimSpace(req.Title)
	if req.Title == "" {
		br.Msg = "请输入标题"
		return
	}
	var subContent string
	if req.Content != "" {
		req.Content = html.EscapeString(req.Content)
		// 前两个章节
		sub, e := services.GetReportContentSub(req.Content)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "读取报告前两个章节内容失败, Err: " + e.Error()
			return
		}
		subContent = html.EscapeString(sub)
	}
	req.ContentStruct = html.EscapeString(req.ContentStruct)

	ob := new(smart_report.SmartReport)
	item, e := ob.GetItemById(req.SmartReportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取研报失败, Err: " + e.Error()
		return
	}

	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.Content = req.Content
	item.ContentSub = subContent
	item.ContentStruct = req.ContentStruct
	item.ModifyTime = time.Now().Local()
	cols := []string{"ClassifyIdFirst", "ClassifyNameFirst", "ClassifyIdSecond", "ClassifyNameSecond", "Title", "Abstract", "Author",
		"Frequency", "Content", "ContentSub", "ContentStruct", "ModifyTime"}
	if e := item.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新报告失败, Err: " + e.Error()
		return
	}
	resp := smart_report.FormatSmartReport2Item(item)

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

// Remove
// @Title 删除
// @Description 删除
// @Param	request	body smart_report.SmartReportRemoveReq true "type json string"
// @Success 200 string "操作成功"
// @router /remove [post]
func (this *SmartReportController) Remove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportRemoveReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.SmartReportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "报告ID为空"
		return
	}

	ob := new(smart_report.SmartReport)
	item, e := ob.GetItemById(req.SmartReportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Ret = 200
			br.Success = true
			br.Msg = "操作成功"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取研报失败, Err: " + e.Error()
		return
	}
	if e = item.Del(); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "删除报告失败, Err: " + e.Error()
		return
	}

	// ES更新报告为未发布
	go func() {
		_ = smartReportService.SmartReportElasticUpsert(item.SmartReportId, 1)
	}()

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

// Detail
// @Title 详情
// @Description 详情
// @Param   SmartReportId	query	int	true	"智能研报ID"
// @Success 200 {object} smart_report.SmartReportItem
// @router /detail [get]
func (this *SmartReportController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	reportId, _ := this.GetInt("SmartReportId")
	if reportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "报告ID有误"
		return
	}

	ob := new(smart_report.SmartReport)
	item, e := ob.GetItemById(reportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取研报失败, Err: " + e.Error()
		return
	}
	resp := smart_report.FormatSmartReport2Item(item)

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

// Publish
// @Title 发布/取消发布
// @Description 发布/取消发布
// @Param	request	body smart_report.SmartReportPublishReq true "type json string"
// @Success 200 string "操作成功"
// @router /edit [post]
func (this *SmartReportController) Publish() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportPublishReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.SmartReportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = "报告ID为空"
		return
	}
	if req.PublishState != 1 && req.PublishState != 2 {
		br.Msg = "参数有误"
		return
	}

	ob := new(smart_report.SmartReport)
	item, e := ob.GetItemById(req.SmartReportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取研报失败, Err: " + e.Error()
		return
	}

	item.State = req.PublishState
	item.ModifyTime = time.Now().Local()
	cols := []string{"State", "ModifyTime"}
	if e = item.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新研报失败, Err: " + e.Error()
		return
	}

	// 生成音频
	if req.PublishState == smart_report.SmartReportStatePublished && item.VideoUrl == "" {
		go smartReportService.SmartReportBuildVideoAndUpdate(item)
	}

	// ES更新报告
	go func() {
		_ = smartReportService.SmartReportElasticUpsert(item.SmartReportId, req.PublishState)
	}()

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

// PrePublish
// @Title 设置定时发布
// @Description 设置定时发布
// @Param	request	body smart_report.SmartReportPrePublishReq true "type json string"
// @Success 200 string "操作成功"
// @router /pre_publish [post]
func (this *SmartReportController) PrePublish() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportPrePublishReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	reportId := req.SmartReportId
	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
	//}
	preTime, e := time.ParseInLocation(utils.FormatDateTime, req.PrePublishTime, time.Local)
	if e != nil {
		br.Msg = "发布时间格式错误"
		br.ErrMsg = "发布时间格式错误，Err:" + e.Error()
		return
	}
	if preTime.Before(time.Now()) {
		br.Msg = "发布时间不允许选择过去时间"
		return
	}
	if preTime.Before(time.Now().Add(2 * time.Minute)) {
		br.Msg = "发布时间距离当前时间太近了"
		return
	}

	reportOB := new(smart_report.SmartReport)
	item, e := reportOB.GetItemById(reportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "获取报告失败"
		br.ErrMsg = "获取报告失败, Err:" + e.Error()
		return
	}
	if item.Content == "" {
		br.Msg = "报告内容为空, 不可发布"
		return
	}
	if item.State == 2 {
		br.Msg = "报告已发布, 不可设置定时发布"
		return
	}

	item.PrePublishTime = preTime
	item.PreMsgSend = req.PreMsgSend
	cols := []string{"PrePublishTime", "PreMsgSend"}
	if e = item.Update(cols); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新报告预发布失败, Err: " + e.Error()
		return
	}

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

// SendMsg
// @Title 消息推送
// @Description 消息推送
// @Param	request	body models.SendTemplateMsgReq true "type json string"
// @Success 200 Ret=200 推送成功
// @router /send_msg [post]
func (this *SmartReportController) SendMsg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportSendMsgReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.SmartReportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, SmartReportId: %d", req.SmartReportId)
		return
	}

	// 避免重复推送
	{
		redisKey := fmt.Sprint(utils.CACHE_SMART_REPORT_SEND_MSG, req.SmartReportId)
		ok := utils.Rc.SetNX(redisKey, 1, time.Second*300)
		if !ok {
			br.Msg = "报告已推送, 请勿重复推送"
			return
		}
		defer func() {
			_ = utils.Rc.Delete(redisKey)
		}()
	}

	reportOB := new(smart_report.SmartReport)
	item, e := reportOB.GetItemById(req.SmartReportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取报告失败, Err: " + e.Error()
		return
	}
	if item.MsgIsSend == 1 {
		br.Msg = "消息已推送，请勿重复操作"
		return
	}

	item.MsgIsSend = 1
	item.ModifyTime = time.Now().Local()
	if e = item.Update([]string{"MsgIsSend", "ModifyTime"}); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新报告推送状态失败, Err: " + e.Error()
		return
	}

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

// SaveContent
// @Title 保存草稿
// @Description 保存草稿
// @Param	request	body smart_report.SmartReportSaveContentReq true "type json string"
// @Success 200 {object} smart_report.SmartReportSaveContentResp
// @router /save_content [post]
func (this *SmartReportController) SaveContent() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req smart_report.SmartReportSaveContentReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	resp := new(smart_report.SmartReportSaveContentResp)
	if req.SmartReportId <= 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		br.Data = resp
		return
	}

	reportOB := new(smart_report.SmartReport)
	item, _ := reportOB.GetItemById(req.SmartReportId)
	if item == nil {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		br.Data = resp
		return
	}
	if item.State == smart_report.SmartReportStatePublished {
		br.Msg = "报告已发布, 不允许编辑"
		return
	}

	// 更新编辑状态
	adminIdName := make(map[int]string)
	admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取系统用户列表失败, Err: " + e.Error()
		return
	}
	for _, ad := range admins {
		adminIdName[ad.AdminId] = ad.RealName
	}
	editing, e := smartReportService.UpdateSmartReportEditing(req.SmartReportId, 1, sysUser.AdminId, sysUser.RealName, adminIdName)
	if e != nil {
		br.Msg = e.Error()
		return
	}
	if editing.Status == 1 {
		br.Msg = editing.Msg
		return
	}

	// 内容有改动
	if req.NoChange != 1 && req.Content != "" && req.ContentStruct != "" {
		req.Content = html.EscapeString(req.Content)
		req.ContentStruct = html.EscapeString(req.ContentStruct)
		sub, e := services.GetReportContentSub(req.Content)
		if e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "读取报告前两个章节内容失败, Err: " + e.Error()
			return
		}
		subContent := html.EscapeString(sub)

		item.Content = req.Content
		item.ContentSub = subContent
		item.ContentStruct = req.ContentStruct
		item.ModifyTime = time.Now().Local()
		cols := []string{"Content", "ContentSub", "ContentStruct", "ModifyTime"}
		if e = item.Update(cols); e != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "更新报告内容失败"
			return
		}

		go func() {
			saveLog := new(smart_report.SmartReportSaveLog)
			saveLog.SmartReportId = item.SmartReportId
			saveLog.Content = item.Content
			saveLog.ContentSub = item.ContentSub
			saveLog.ContentStruct = item.ContentStruct
			saveLog.AdminId = sysUser.AdminId
			saveLog.AdminName = sysUser.AdminName
			saveLog.CreateTime = time.Now().Local()
			_ = saveLog.Create()
		}()
	}

	resp.SmartReportId = item.SmartReportId
	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 *SmartReportController) MarkEditStatus() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req models.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
	}

	// 获取系统用户列表-用于匹配编辑中的用户
	adminIdName := make(map[int]string)
	admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取系统用户列表失败, Err: " + e.Error()
		return
	}
	for _, ad := range admins {
		adminIdName[ad.AdminId] = ad.RealName
	}

	data, e := smartReportService.UpdateSmartReportEditing(req.ReportId, req.Status, sysUser.AdminId, sysUser.RealName, adminIdName)
	if e != nil {
		br.Msg = e.Error()
		return
	}

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

// List
// @Title 报告列表
// @Description 报告列表
// @Param   PageSize			query	int		true	"每页数据条数"
// @Param   CurrentIndex		query	int		true	"当前页页码"
// @Param   TimeType			query	string	false	"筛选的时间类别: publish_time-发布时间, modify_time-更新时间"
// @Param   StartDate			query   string  false	"开始时间"
// @Param   EndDate				query   string  false	"结束时间"
// @Param   Frequency			query   string  false	"频度"
// @Param   ClassifyIdFirst		query	int		false	"一级分类ID"
// @Param   ClassifyIdSecond	query	int		false	"二级分类ID"
// @Param   State				query	int		false	"发布状态: 1-待发布; 2-已发布"
// @Param   Keyword				query	string	false	"搜索关键词"
// @Success 200 {object} smart_report.SmartReportListResp
// @router /list [get]
func (this *SmartReportController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	type SmartReportListReq struct {
		PageSize         int    `form:"PageSize"`
		CurrentIndex     int    `form:"CurrentIndex"`
		TimeType         string `form:"TimeType"`
		StartDate        string `form:"StartDate"`
		EndDate          string `form:"EndDate"`
		Frequency        string `form:"Frequency"`
		ClassifyIdFirst  int    `form:"ClassifyIdFirst"`
		ClassifyIdSecond int    `form:"ClassifyIdSecond"`
		State            int    `form:"State"`
		Keyword          string `form:"Keyword"`
	}
	params := new(SmartReportListReq)
	if e := this.ParseForm(&params); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "入参解析失败, Err: " + e.Error()
		return
	}
	if params.TimeType == "" {
		params.TimeType = "publish_time"
	}
	if params.TimeType != "publish_time" && params.TimeType != "modify_time" {
		br.Msg = "请选择正确的时间类型"
		return
	}

	var condition string
	var pars []interface{}
	// 筛选项
	{
		keyword := strings.TrimSpace(params.Keyword)
		if keyword != "" {
			kw := fmt.Sprint("%", keyword, "%")
			condition += fmt.Sprintf(` AND (title LIKE ? OR admin_real_name LIKE ?)`)
			pars = append(pars, kw, kw)
		}
		if params.StartDate != "" && params.EndDate != "" {
			condition += fmt.Sprintf(` AND %s >= ? AND %s <= ?`, params.TimeType, params.TimeType)
			pars = append(pars, params.StartDate, params.EndDate)
		}
		if params.Frequency != "" {
			condition += ` AND frequency = ?`
			pars = append(pars, params.Frequency)
		}
		if params.ClassifyIdFirst > 0 {
			condition += ` AND classify_id_first = ?`
			pars = append(pars, params.ClassifyIdFirst)
		}
		if params.ClassifyIdSecond > 0 {
			condition += ` AND classify_id_second = ?`
			pars = append(pars, params.ClassifyIdSecond)
		}
		if params.State > 0 {
			condition += ` AND state = ?`
			pars = append(pars, params.State)
		}
	}

	resp := new(smart_report.SmartReportListResp)
	reportOB := new(smart_report.SmartReport)
	total, e := reportOB.GetCountByCondition(condition, pars)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取报告总数失败, Err:" + e.Error()
		return
	}
	if total <= 0 {
		page := paging.GetPaging(params.CurrentIndex, params.PageSize, total)
		resp.Paging = page
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		return
	}

	// 分页列表
	var startSize int
	if params.PageSize <= 0 {
		params.PageSize = utils.PageSize20
	}
	if params.CurrentIndex <= 0 {
		params.CurrentIndex = 1
	}
	startSize = utils.StartIndex(params.CurrentIndex, params.PageSize)

	// 列表查询过滤掉富文本内容
	fields := []string{
		"SmartReportId", "ReportCode", "ClassifyIdFirst", "ClassifyNameFirst", "ClassifyIdSecond", "ClassifyNameSecond", "AddType",
		"Title", "Author", "Frequency", "Stage", "VideoUrl", "VideoName", "VideoPlaySeconds", "VideoSize", "AdminId", "AdminRealName", "State",
		"PublishTime", "PrePublishTime", "PreMsgSend", "MsgIsSend", "MsgSendTime", "CreateTime", "ModifyTime",
	}
	list, e := reportOB.GetPageItemsByCondition(condition, pars, fields, "", startSize, params.PageSize)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取报告分页列表失败, Err:" + e.Error()
		return
	}

	// 获取系统用户列表-用于匹配编辑中的用户
	adminIdName := make(map[int]string)
	admins, e := system.GetSysAdminList(``, make([]interface{}, 0), []string{}, "")
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取系统用户列表失败, Err: " + e.Error()
		return
	}
	for _, ad := range admins {
		adminIdName[ad.AdminId] = ad.RealName
	}

	for _, v := range list {
		item := smart_report.FormatSmartReport2Item(v)
		mark, e := smartReportService.UpdateSmartReportEditing(v.SmartReportId, 2, sysUser.AdminId, sysUser.RealName, adminIdName)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "查询编辑中标记失败, Err:" + e.Error()
			return
		}
		if mark.Status == 0 {
			item.CanEdit = true
		} else {
			item.Editor = mark.Editor
		}
		resp.List = append(resp.List, item)
	}

	page := paging.GetPaging(params.CurrentIndex, params.PageSize, total)
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// DetailImg
// @Title 生成长图
// @Description 生成长图
// @Param   SmartReportId	query	int	true	"智能研报ID"
// @Success 200 {object} smart_report.SmartReportSaveContentResp
// @router /detail_img [get]
func (this *SmartReportController) DetailImg() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	reportId, _ := this.GetInt("SmartReportId", 0)
	if reportId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, SmartReportId: %d", reportId)
		return
	}

	reportOB := new(smart_report.SmartReport)
	_, e := reportOB.GetItemById(reportId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在, 请刷新页面"
			return
		}
		br.Msg = "操作失败"
		br.ErrMsg = "获取报告失败, Err: " + e.Error()
		return
	}

	// TODO:调用python服务生成长图

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