eta_mobile/controllers/english_report/report.go

package english_report

import (
	"encoding/json"
	"eta/eta_mobile/controllers"
	"eta/eta_mobile/models"
	"eta/eta_mobile/models/company"
	"eta/eta_mobile/services"
	"eta/eta_mobile/services/alarm_msg"
	"eta/eta_mobile/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"html"
	"sort"
	"strconv"
	"strings"
	"time"
)

// EnglishReportController 研报活动模块
type EnglishReportController struct {
	controllers.BaseAuthController
}

// @Title 新增报告接口
// @Description 新增报告
// @Param	request	body models.AddEnglishReportReq true "type json string"
// @Success 200 {object} models.AddEnglishReportResp
// @router /add [post]
func (this *EnglishReportController) 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.AddEnglishReportReq
	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
	}
	if req.Overview == "" {
		br.Msg = "请输入overview"
		return
	}
	if req.Abstract == "" {
		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)
		}
	}
	maxStage, err := models.GetEnglishReportStage(req.ClassifyIdFirst, req.ClassifyIdSecond)
	if err != nil {
		br.Msg = "期数获取失败！"
		br.ErrMsg = "期数获取失败，Err:" + err.Error()
		return
	}

	item := new(models.EnglishReport)
	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.Overview = req.Overview
	item.AdminId = sysUser.AdminId
	item.AdminRealName = sysUser.RealName
	newReportId, err := models.AddEnglishReport(item)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	reportCode := utils.MD5(strconv.Itoa(int(newReportId)))
	//修改唯一编码
	{
		go models.ModifyEnglishReportCode(newReportId, reportCode)
	}
	resp := new(models.AddEnglishReportResp)
	resp.ReportId = newReportId
	resp.ReportCode = reportCode
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
}

// @Title 编辑报告接口
// @Description 编辑报告
// @Param	request	body models.EditEnglishReportReq true "type json string"
// @Success 200 {object} models.EditEnglishReportResp
// @router /edit [post]
func (this *EnglishReportController) 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.EditEnglishReportReq
	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
	}
	if req.Overview == "" {
		br.Msg = "请输入overview"
		return
	}
	if req.Abstract == "" {
		br.Msg = "请输入摘要"
		return
	}

	markStatus, err := services.UpdateEnReportEditMark(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
	}
	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)
		}
	}

	var stage int
	report, _ := models.GetEnglishReportById(int(req.ReportId))
	if report != nil {
		if report.ClassifyNameFirst != req.ClassifyNameFirst || report.ClassifyNameSecond != req.ClassifyNameSecond {
			maxStage, _ := models.GetEnglishReportStageEdit(req.ClassifyIdFirst, req.ClassifyIdSecond, int(req.ReportId))
			maxStage = maxStage + 1
			stage = maxStage
		} else {
			stage = report.Stage
		}
	}

	item := new(models.EnglishReport)
	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
	item.Overview = req.Overview
	err = models.EditEnglishReport(item, req.ReportId)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}

	reportCode := utils.MD5(strconv.Itoa(int(req.ReportId)))
	resp := new(models.EditEnglishReportResp)
	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.EnglishReportDetailView
// @router /detail [get]
func (this *EnglishReportController) Detail() {
	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, err := this.GetInt("ReportId")
	if err != nil {
		br.Msg = "获取参数失败！"
		br.ErrMsg = "获取参数失败，Err:" + err.Error()
		return
	}
	if reportId <= 0 {
		br.Msg = "参数错误"
		return
	}

	item, err := models.GetEnglishReportById(reportId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	item.Content = html.UnescapeString(item.Content)
	item.ContentSub = html.UnescapeString(item.ContentSub)
	classifyNameMap := make(map[int]*models.EnglishClassifyFullName)
	if item.ClassifyIdSecond > 0 {
		nameList, tErr := models.GetEnglishClassifyFullNameByIds([]int{item.ClassifyIdSecond})
		if tErr != nil {
			br.Msg = "获取分类名称失败"
			br.ErrMsg = "获取分类名称失败, ERR:" + tErr.Error()
			return
		}
		for _, v := range nameList {
			classifyNameMap[v.Id] = v
		}
		//处理分类名
		if n, ok := classifyNameMap[item.ClassifyIdSecond]; ok {
			item.ClassifyNameRoot = n.RootName
			item.ClassifyIdRoot = n.RootId
		}
	}

	// 获取邮件配置-是否有权限群发
	conf := new(models.EnglishReportEmailConf)
	authKey := "english_report_email_conf"
	confAuth, e := company.GetConfigDetailByCode(authKey)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取群发邮件权限失败, Err: " + e.Error()
		return
	}
	if confAuth.ConfigValue == "" {
		br.Msg = "获取失败"
		br.ErrMsg = "群发邮件配置为空"
		return
	}
	if e := json.Unmarshal([]byte(confAuth.ConfigValue), &conf); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "群发邮件配置有误"
		return
	}
	authOk := false
	authArr := strings.Split(conf.SendAuthGroup, ",")
	if utils.InArrayByStr(authArr, sysUser.RoleTypeCode) {
		authOk = true
	}
	item.EmailAuth = authOk

	// 是否有群发邮件失败的记录，标记红点
	failList, e := models.GetEnglishReportEmailLogFailList(0)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取群发邮件记录失败, Err: " + e.Error()
		return
	}
	failMap := make(map[int]bool, 0)
	for i := range failList {
		failMap[failList[i].ReportId] = true
	}
	item.EmailHasFail = failMap[item.Id]

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

// ListReport
// @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 *EnglishReportController) ListReport() {
	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
	}

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	timeType := this.GetString("TimeType")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	frequency := this.GetString("Frequency")
	classifyIdFirst, _ := this.GetInt("ClassifyIdFirst")
	classifyIdSecond, _ := this.GetInt("ClassifyIdSecond")
	classifyIdRoot, _ := this.GetInt("ClassifyIdRoot")
	state, _ := this.GetInt("State")
	keyWord := this.GetString("KeyWord")
	companyType := this.GetString("CompanyType")
	// 群发邮件状态筛选
	emailState, _ := this.GetInt("EmailState")

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

	var condition string
	var pars []interface{}

	if keyWord != "" {
		condition += ` AND (title LIKE '%` + keyWord + `%' OR admin_real_name LIKE '%` + keyWord + `%' ) `
	}
	if timeType == "" {
		timeType = "publish_time"
	}
	if timeType != "publish_time" && timeType != "modify_time" {
		br.Msg = "请选择正确的时间"
		br.ErrMsg = "请选择正确的时间"
		return
	}

	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 classifyIdFirst != 0 {
		condition += ` AND classify_id_first = ? `
		pars = append(pars, classifyIdFirst)
	}

	if classifyIdSecond != 0 {
		condition += ` AND classify_id_second = ? `
		pars = append(pars, classifyIdSecond)
	}
	if state > 0 {
		condition += ` AND state = ? `
		pars = append(pars, state)
	}

	if classifyIdRoot > 0 && classifyIdFirst == 0 && classifyIdSecond == 0 {
		//查询顶级分类下的所有二级分类ID
		childClassify, err := models.GetEnglishSecondClassifyList([]int{classifyIdRoot})
		if err != nil {
			br.Msg = "查询子分类出错"
			br.ErrMsg = "查询子分类出错， Err:" + err.Error()
			return
		}
		var childClassifyIds []int
		if len(childClassify) > 0 {
			for _, v := range childClassify {
				childClassifyIds = append(childClassifyIds, v.Id)
			}
			condition += ` AND classify_id_first IN (` + utils.GetOrmInReplace(len(childClassifyIds)) + `)`
			pars = append(pars, childClassifyIds)
		} else {
			//一级分类下没有子分类，直接返回空列表
			page := paging.GetPaging(currentIndex, pageSize, 0)
			resp := new(models.EnglishReportListResp)
			resp.Paging = page
			resp.List = make([]*models.EnglishReportList, 0)
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			br.Data = resp
			return
		}
	}
	// 未群发邮件(包含推送邮件失败的)
	if emailState == 1 {
		failIds, e := models.GetHasFailEmailLogReportIds()
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取存在邮件推送失败记录的英文报告IDs失败, Err:" + e.Error()
			return
		}
		condition += ` AND email_state = 0`
		if len(failIds) > 0 {
			condition += ` OR id IN (` + utils.GetOrmInReplace(len(failIds)) + `)`
			pars = append(pars, failIds)
		}
	}
	// 已群发邮件
	if emailState == 2 {
		successIds, e := models.GetSuccessEmailLogReportIds()
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取邮件推送记录均为成功的英文报告IDs失败, Err:" + e.Error()
			return
		}
		condition += ` AND email_state = 1`
		if len(successIds) > 0 {
			condition += ` AND id IN (` + utils.GetOrmInReplace(len(successIds)) + `)`
			pars = append(pars, successIds)
		}
	}

	total, err := models.GetEnglishReportListCount(condition, pars, companyType)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, err := models.GetEnglishReportList(condition, pars, companyType, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	// 获取邮件配置-是否有权限群发
	conf := new(models.EnglishReportEmailConf)
	authKey := "english_report_email_conf"
	confAuth, e := company.GetConfigDetailByCode(authKey)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取群发邮件权限失败, Err: " + e.Error()
		return
	}
	if confAuth.ConfigValue == "" {
		br.Msg = "获取失败"
		br.ErrMsg = "群发邮件配置为空"
		return
	}
	if e := json.Unmarshal([]byte(confAuth.ConfigValue), &conf); e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "群发邮件配置有误"
		return
	}
	authOk := false
	authArr := strings.Split(conf.SendAuthGroup, ",")
	if utils.InArrayByStr(authArr, sysUser.RoleTypeCode) {
		authOk = true
	}

	// 是否有群发邮件失败的记录，标记红点
	failList, e := models.GetEnglishReportEmailLogFailList(0)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取群发邮件记录失败, Err: " + e.Error()
		return
	}
	failMap := make(map[int]bool, 0)
	for i := range failList {
		failMap[failList[i].ReportId] = true
	}
	// 查询分类信息
	var classifyIdSecondSlice []int
	for _, item := range list {
		classifyIdSecondSlice = append(classifyIdSecondSlice, item.ClassifyIdSecond)
	}
	classifyNameMap := make(map[int]*models.EnglishClassifyFullName)
	if len(classifyIdSecondSlice) > 0 {
		nameList, err := models.GetEnglishClassifyFullNameByIds(classifyIdSecondSlice)
		if err != nil {
			br.Msg = "获取分类名称失败"
			br.ErrMsg = "获取分类名称失败, ERR:" + err.Error()
			return
		}
		for _, v := range nameList {
			classifyNameMap[v.Id] = v
		}
	}
	for _, item := range list {
		if item.State == 2 {
			item.ShareUrl = "https://share.hzinsights.com/reportEn?code=" + item.ReportCode
		}
		item.EmailAuth = authOk
		item.EmailHasFail = failMap[item.Id]
		// 邮箱PV大于0的时候, 不展示最初版本的PV
		if item.PvEmail > 0 {
			item.Pv = 0
		}

		/*key := fmt.Sprint(`crm:enReport:edit:`, item.Id)
		opUserId, _ := utils.Rc.RedisInt(key)
		//如果当前没有人操作，获取当前操作人是本人，那么编辑按钮可用
		if opUserId <= 0 || (opUserId == this.SysUser.AdminId) {
			item.CanEdit = true
		} else {
			adminInfo, errAdmin := system.GetSysUserById(opUserId)
			if errAdmin != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败，Err:" + errAdmin.Error()
				return
			}
			item.Editor = adminInfo.RealName
		}*/
		markStatus, err := services.UpdateEnReportEditMark(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
		}
		//处理分类名
		if n, ok := classifyNameMap[item.ClassifyIdSecond]; ok {
			if n.RootId == 0 {
				item.FullClassifyName = strings.Join([]string{n.ParentName, n.ClassifyName}, "/")
			} else {
				item.FullClassifyName = strings.Join([]string{n.RootName, n.ParentName, n.ClassifyName}, "/")
			}
			item.ClassifyIdRoot = n.RootId
			item.ClassifyNameRoot = n.RootName
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.EnglishReportListResp)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ListClassify
// @Title 获取分类列表
// @Description 获取分类列表
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   KeyWord   query   string  true       "检索关键词"
// @Param   CompanyType   query   string  false       "产品类型，枚举值：'ficc','权益';不传默认返回全部"
// @Success 200 {object} models.EnglishClassifyListResp
// @router /classify/list [get]
func (this *EnglishReportController) ListClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyWord := this.GetString("KeyWord")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}

	startSize = utils.StartIndex(currentIndex, pageSize)

	page := paging.GetPaging(currentIndex, pageSize, 0)
	resp := new(models.EnglishClassifyListResp)

	// 处理一级分类分页的情况
	rootList, err := models.GetEnglishClassifyRootId(startSize, pageSize, keyWord)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	var ids []int
	var rootIds []int
	rootMap := make(map[int]struct{}, 0)
	for _, v := range rootList {
		rootIds = append(rootIds, v.Id)
		rootMap[v.Id] = struct{}{}
	}
	total, err := models.GetEnglishClassifyListCount(keyWord)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	if total == 0 {
		resp.List = make([]*models.EnglishClassifyList, 0)
		resp.Paging = page

		br.Data = resp
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}
	page = paging.GetPaging(currentIndex, pageSize, total)

	//获取相关的分类ID
	idList, err := models.GetEnglishClassifyListByRootId(rootIds, keyWord)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	secondListMap := make(map[int][]*models.EnglishClassifyList)
	thirdListMap := make(map[int][]*models.EnglishClassifyList)
	var thirdIds []int
	var sortChildList models.RSChildClassifyList
	// 三级分类-品种权限
	permissionMap := make(map[int][]int)

	if len(idList) > 0 {
		childIdMap := make(map[int]struct{}, 0)
		for _, v := range idList {
			if _, ok := childIdMap[v.ParentId]; !ok {
				ids = append(ids, v.ParentId)
			}
			if _, ok := childIdMap[v.Id]; !ok {
				ids = append(ids, v.Id)
			}
		}
		tmpList, err := models.GetEnglishClassifyChildByIds(ids)
		if err != nil {
			br.Msg = "获取二级分类失败"
			br.ErrMsg = "获取二级分类失败，Err:" + err.Error()
			return
		}
		for _, v := range tmpList {
			if _, ok := rootMap[v.ParentId]; !ok {
				thirdIds = append(thirdIds, v.Id)
			}
		}
		{
			classifyIds := thirdIds
			if len(classifyIds) > 0 {
				cond := fmt.Sprintf(` AND %s IN (%s)`, models.EnClassifyPermissionColumns.EnClassifyId, utils.GetOrmInReplace(len(classifyIds)))
				pars := make([]interface{}, 0)
				pars = append(pars, classifyIds)
				ob := new(models.EnClassifyPermission)
				items, e := ob.GetItemsByCondition(cond, pars, []string{}, "")
				if e != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取客户权限列表失败, Err: " + e.Error()
					return
				}
				for _, v := range items {
					if permissionMap[v.EnClassifyId] == nil {
						permissionMap[v.EnClassifyId] = make([]int, 0)
					}
					permissionMap[v.EnClassifyId] = append(permissionMap[v.EnClassifyId], v.EnPermissionId)
				}
			}
		}
		// 处理三级分类
		for _, v := range tmpList {
			if _, ok := rootMap[v.ParentId]; !ok {
				if p, ok1 := permissionMap[v.Id]; ok1 {
					v.EnPermissions = p
				}
				thirdListMap[v.ParentId] = append(thirdListMap[v.ParentId], v)
			}
		}

		//处理二级分类
		for _, v := range tmpList {
			if _, ok := rootMap[v.ParentId]; ok {
				if child, ok1 := thirdListMap[v.Id]; ok1 {
					sortChildList = child
					sort.Sort(sortChildList)
					v.Child = sortChildList
				}
				secondListMap[v.ParentId] = append(secondListMap[v.ParentId], v)
			}
		}
	}

	//处理一级分类
	var sortList models.RSClassifyList
	for _, v := range rootList {
		if child, ok := secondListMap[v.Id]; ok {
			sortChildList = child
			sort.Sort(sortChildList)
			v.Child = sortChildList
		}
		sortList = append(sortList, v)
	}

	sort.Sort(sortList)

	resp.List = sortList
	resp.Paging = page

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

// @Title 删除分类列表
// @Description 删除分类列表
// @Param   ClassifyId   int  true       "分类名称"
// @Param   ParentId   query   int  true   "父级Id"
// @Success 200 保存成功
// @router /classify/delete [get]
func (this *EnglishReportController) DelClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	classifyId, _ := this.GetInt("ClassifyId")
	//parentId, _ := this.GetInt("ParentId")

	classifyInfo, err := models.GetEnglishReportClassifyById(classifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "当前分类不存在"
			br.ErrMsg = "当前分类不存在"
			return
		}
		br.Msg = "获取分类信息失败"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}

	count, err := models.GetEnglishClassifyChildCounts(classifyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	if count > 0 {
		br.Msg = "请先删除该分类下关联分类"
		br.Ret = 403
		return
	}

	reportCount, e := models.GetEnglishReportCounts(classifyId, classifyInfo.ParentId)
	if e != nil && e.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取失败，Err:" + e.Error()
		return
	}

	if reportCount > 0 {
		br.Msg = "该分类有关联报告，不允许删除"
		br.Ret = 403
		return
	}

	videoCount, e := models.GetEnglishVideoCounts(classifyId, classifyInfo.ParentId)
	if e != nil && e.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取失败，Err:" + e.Error()
		return
	}

	if videoCount > 0 {
		br.Msg = "该分类有关联的路演视频，不允许删除"
		br.Ret = 403
		return
	}

	if err = models.DeleteEnglishClassify(classifyId); err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除报告失败, Err: " + err.Error()
		return
	}

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

// @Title 发布报告接口
// @Description 发布报告
// @Param	request	body models.PublishReq true "type json string"
// @Success 200 Ret=200 发布成功
// @router /publish [post]
func (this *EnglishReportController) 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, ",")
	for _, v := range reportArr {
		vint, err := strconv.Atoi(v)
		if err != nil {
			br.Msg = "参数错误"
			br.ErrMsg = "参数错误,Err:" + err.Error()
			return
		}
		report, err := models.GetEnglishReportById(vint)
		if err != nil {
			br.Msg = "获取报告信息失败"
			br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
			return
		}
		if report == nil {
			br.Msg = "报告不存在"
			return
		}

		var tmpErr error

		if report.Content == "" {
			br.Msg = "报告内容为空，不可发布"
			br.ErrMsg = "报告内容为空，不需要生成,report_id:" + strconv.Itoa(report.Id)
			return
		}
		var publishTime string
		if report.PublishTime != "" {
			// 发布时间固定为首次发布时间
			publishTime = report.PublishTime
		} else {
			publishTime = time.Now().Format(utils.FormatDateTime)
		}
		if tmpErr = models.PublishEnglishReportById(report.Id, publishTime); tmpErr != nil {
			br.Msg = "报告发布失败"
			br.ErrMsg = "报告发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
			return
		}
		go func() {
			_ = services.UpdateEnglishReportEs(report.Id, 2)
		}()
	}

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

// PrePublishReport
// @Title 设置定时发布接口
// @Description 设置定时发布接口
// @Param	request	body models.PrePublishReq true "type json string"
// @Success 200 Ret=200 发布成功
// @router /pre_publish [post]
func (this *EnglishReportController) 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
	}
	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.GetEnglishReportById(reportId)
	if err != nil {
		br.Msg = "获取报告信息失败"
		br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
		return
	}
	if report == nil {
		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.SetPrePublishEnglishReportById(report.Id, req.PrePublishTime); tmpErr != nil {
		br.Msg = "设置定时发布失败"
		br.ErrMsg = "设置定时发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
		return
	}

	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/cancel [post]
func (this *EnglishReportController) 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
	}
	err = models.PublishCancelEnglishReport(req.ReportIds)
	if err != nil {
		br.Msg = "取消发布失败"
		br.ErrMsg = "取消发布失败,Err:" + err.Error()
		return
	}
	// 更新es里的报告状态
	go func() {
		_ = services.UpdateEnglishReportEs(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 *EnglishReportController) 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
	}
	reportInfo, err := models.GetEnglishReportById(req.ReportIds)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在"
			return
		}
		br.Msg = "查询报告信息失败"
		br.ErrMsg = "查询报告信息失败, Err" + err.Error()
		return
	}

	// 更新es里的报告状态
	_ = services.UpdateEnglishReportEs(req.ReportIds, 1)
	if err = models.DeleteEnglishReportAndChapter(reportInfo); err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除报告失败, Err: " + err.Error()
		return
	}

	// 重置PPT关联报告
	go func() {
		_ = services.ResetPPTReport(req.ReportIds, true)
	}()

	go func() {
		_ = services.EnglishPolicyReportSyncCancel(reportInfo)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "删除成功"
}

// @Title 保存草稿
// @Description 保存草稿
// @Param	request	body models.SaveReportContent true "type json string"
// @Success 200 {object} models.ReportAuthorResp
// @router /saveReportContent [post]
func (this *EnglishReportController) SaveReportContent() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.SaveReportContent
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

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

	reportId := req.ReportId
	noChangeFlag := req.NoChange
	fmt.Println("reportId:", reportId)
	if reportId <= 0 {
		br.Msg = "请输入报告ID"
		return
	}
	markStatus, err := services.UpdateEnReportEditMark(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 noChangeFlag != 1 {
		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.EditEnglishReportContent(reportId, content, contentSub)
			if err != nil {
				br.Msg = "保存失败"
				br.ErrMsg = "保存失败，Err:" + err.Error()
				return
			}
			go models.AddEnglishReportSaveLog(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	request	body models.ClassifyIdDetailReq true "type json string"
// @Success 200 {object} models.Report
// @router /classifyIdDetail [get]
func (this *EnglishReportController) 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.GetEnglishReportDetailByClassifyId(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)
		classifyNameMap := make(map[int]*models.EnglishClassifyFullName)
		if item.ClassifyIdSecond > 0 {
			nameList, tErr := models.GetEnglishClassifyFullNameByIds([]int{item.ClassifyIdSecond})
			if tErr != nil {
				br.Msg = "获取分类名称失败"
				br.ErrMsg = "获取分类名称失败, ERR:" + tErr.Error()
				return
			}
			for _, v := range nameList {
				classifyNameMap[v.Id] = v
			}
			//处理分类名
			if n, ok := classifyNameMap[item.ClassifyIdSecond]; ok {
				item.ClassifyNameRoot = n.RootName
				item.ClassifyIdRoot = n.RootId
			}
		}
	}

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

// Author
// @Title 获取报告作者接口
// @Description 获取报告作者
// @Param   AuthorType   query   int  true       "来源类型，1：中文，2：英文"
// @Param   Keyword   query   string  true       "搜索关键词"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   StartDate   query   string  true       "开始时间"
// @Success 200 {object} models.ReportAuthorResp
// @router /author [get]
func (this *EnglishReportController) 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 = 2 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
}

// MarkEditStatus
// @Title 标记报告编辑状态
// @Description 标记报告编辑状态接口
// @Param	request	body request.MarkEditEnReport true "type json string"
// @Success 200 标记成功 ；202 标记成功
// @router /mark [post]
func (this *EnglishReportController) 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.MarkEditEnReport
	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.UpdateEnReportEditMark(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.EditEnglishReportFromPolicyReq true "type json string"
// @Success 200 {object} models.EditEnglishReportResp
// @router /edit_policy [post]
func (this *EnglishReportController) EditPolicy() {
	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.EditEnglishReportFromPolicyReq
	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.Title == "" {
		br.Msg = "请输入标题"
		return
	}
	if req.Abstract == "" {
		br.Msg = "请输入摘要"
		return
	}

	if req.Frequency == "" {
		br.Msg = "请输入频度"
		return
	}
	if req.Author == "" {
		br.Msg = "请输入作者"
		return
	}

	if req.CreateTime == "" {
		br.Msg = "请输入创建时间"
		return
	}
	//查询报告是否存在
	reportInfo, err := models.GetEnglishReportItemById(int(req.ReportId))
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "报告不存在"
			return
		}
		br.Msg = "查询报告信息失败"
		br.ErrMsg = "查询报告信息失败, Err" + err.Error()
		return
	}
	if reportInfo.State == 2 {
		br.Msg = "报告已发布不允许编辑"
		return
	}
	markStatus, err := services.UpdateEnReportEditMark(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
	}

	item := reportInfo
	item.Title = req.Title
	item.Abstract = req.Abstract
	item.Author = req.Author
	item.Frequency = req.Frequency
	item.CreateTime = req.CreateTime
	item.ModifyTime = time.Now()
	err = item.Update([]string{"Title", "Abstract", "Author", "Frequency", "CreateTime", "ModifyTime"})
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	reportCode := reportInfo.ReportCode
	resp := new(models.EditEnglishReportResp)
	resp.ReportId = req.ReportId
	resp.ReportCode = reportCode
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
}