hongze_yb/services/report/report.go

package report

import (
	"encoding/json"
	"errors"
	"fmt"
	"hongze/hongze_yb/global"
	"hongze/hongze_yb/models/response"
	"hongze/hongze_yb/models/response/purchase"
	"hongze/hongze_yb/models/tables/chart_permission"
	"hongze/hongze_yb/models/tables/chart_permission_chapter_mapping"
	"hongze/hongze_yb/models/tables/chart_permission_search_key_word_mapping"
	"hongze/hongze_yb/models/tables/daily_base_column"
	"hongze/hongze_yb/models/tables/rddp/classify"
	"hongze/hongze_yb/models/tables/rddp/report"
	"hongze/hongze_yb/models/tables/rddp/report_chapter"
	"hongze/hongze_yb/models/tables/rddp/report_chapter_ticker"
	"hongze/hongze_yb/models/tables/report_chapter_type"
	"hongze/hongze_yb/models/tables/report_chapter_type_permission"
	"hongze/hongze_yb/services/company"
	elasticService "hongze/hongze_yb/services/elastic"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/task"
	"hongze/hongze_yb/utils"
	"html"
	"sort"
	"strconv"
	"time"
)

func GetLatestClassReport(permissionIds []int, userId uint64) (purchaseList []*purchase.PurchaseListItem, err error)  {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetLatestClassReport: userId=%d, err:%s， errMsg:%s", userId, err.Error(), errMsg))
		}
	}()

	//获取所有分类信息
	classifys, err := classify.GetSimpleAll()
	if err != nil {
		errMsg = err.Error()
		err = errors.New("分类查询出错")
		return
	}
	classifyFirstIconMap := make(map[int]string)
	classifySecondNameMap := make(map[string]int)
	for _, v := range classifys{
		if v.ParentId == 0 {
			classifyFirstIconMap[v.Id] = v.YbIconUrl
		}else{
			classifySecondNameMap[v.ClassifyName] = v.Id
		}
	}
	//获取最新的晨报
	dayReport, err := report.GetLatestDay()
	if err != nil {
		errMsg = err.Error()
		err = errors.New("晨报查询出错")
		return
	}
	//获取最新的有权限的周报
	typeIds, err := report_chapter_type.GetEffectTypeID()
	if err != nil {
		errMsg = err.Error()
		err = errors.New("晨报查询出错")
		return
	}
	weekReport, err := GetLatestWeek(permissionIds, typeIds)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("周报查询出错")
		return
	}
	// 有权限的二级分类
	var reports []*report.Report
	var classifyIdSeconds []int
	classifyIdSecondMap := make(map[int]bool)
	// 获取晨报和周报以外的其他报告
	// 获取有权限的二级分类
	chartPermissions, err := chart_permission_search_key_word_mapping.GetChartPermissionByFrom("rddp")
	if err != nil {
		errMsg = err.Error()
		err = errors.New("分类权限查询出错")
		return
	}
	if len(chartPermissions) > 0 {
		for _, v := range chartPermissions {
			for _, myPerId := range permissionIds {
				if v.ChartPermissionId == myPerId {
					if classifyIdSecond, ok := classifySecondNameMap[v.KeyWord]; ok {
						if _, ok2 := classifyIdSecondMap[classifyIdSecond]; !ok2 {
							classifyIdSeconds = append(classifyIdSeconds, classifyIdSecond)
							classifyIdSecondMap[classifyIdSecond] = true
						}
					}
					break
				}
			}
		}
	}
	reports, err = report.GetLatestClassReportsByClassifyIdSeconds(classifyIdSeconds)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("二级分类最新报告查询出错")
		return
	}
	if dayReport.Id > 0 {
		reports = append(reports, dayReport)
	}
	if weekReport != nil {
		reports = append(reports, weekReport)
	}
	//获取未读数
	unReadItem, tErr := GetUnRead(classifyIdSeconds, userId)
	if tErr != nil {
		err = tErr
		return
	}
	if len(reports) > 0 {
		otherLatestItem := new(purchase.PurchaseListItem)
		// 处理其他报告（）
		for _, v := range reports {
			temp := new(purchase.PurchaseListItem)
			temp.ReportId = v.Id
			temp.ClassifyIdFirst = v.ClassifyIdFirst
			temp.ClassifyNameFirst = v.ClassifyNameFirst
			temp.Stage = v.Stage
			temp.Title = v.Title
			temp.ClassifyIdSecond = v.ClassifyIdSecond
			temp.ClassifyNameSecond = v.ClassifyNameSecond
			temp.Time = v.PublishTime
			if temp.ClassifyNameFirst == "大事点评" ||  temp.ClassifyNameFirst == "会议纪要" || temp.ClassifyNameFirst == "年报合集"{
				if otherLatestItem.Time.Format(utils.FormatDateTime) > v.PublishTime.Format(utils.FormatDateTime) {
					continue
				}
				temp.Unread = unReadItem["大事点评"] + unReadItem["会议纪要"] + unReadItem["年报合集"]
				temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.ClassifyNameFirst)
				otherLatestItem = temp
			}
		}
		for _, v := range reports {
			temp := new(purchase.PurchaseListItem)
			temp.ReportId = v.Id
			temp.ClassifyIdFirst = v.ClassifyIdFirst
			temp.ClassifyNameFirst = v.ClassifyNameFirst
			temp.Stage = v.Stage
			temp.Title = v.Title
			temp.ClassifyIdSecond = v.ClassifyIdSecond
			temp.ClassifyNameSecond = v.ClassifyNameSecond
			temp.Time = v.PublishTime
			temp.Unread = unReadItem[temp.ClassifyNameFirst]
			if imgUrl, ok := classifyFirstIconMap[temp.ClassifyIdFirst]; ok {
				temp.ImgUrl = imgUrl
			}
			if temp.ClassifyNameFirst == "晨报" || temp.ClassifyNameFirst == "周报" {  //晨报或者周报，查询最新的章节信息
				temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.Title)
			}else if temp.ClassifyNameFirst == "大事点评" ||  temp.ClassifyNameFirst == "会议纪要" || temp.ClassifyNameFirst == "年报合集"{
				continue
			}else{
				if temp.ClassifyNameFirst != temp.ClassifyNameSecond {     //包含二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC| %s】%s", temp.Stage, temp.ClassifyNameSecond, temp.ClassifyNameFirst)
				} else {                   //无二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.ClassifyNameFirst)
				}
			}

			purchaseList = append(purchaseList, temp)
		}
		purchaseList = append(purchaseList, otherLatestItem)
	}
	return
}



// GetPurchaseDetail 已购详情页面
func GetPurchaseDetail(permissionIds []int, userId uint64, classifyIdFirst int, pageIndex, pageSize int) (ret *purchase.DetailResp, err error)  {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetPurchaseDetail: userId=%d, err:%s， errMsg:%s", userId, err.Error(), errMsg))
		}
	}()
	var reports []*report.Report
	var weekReportIds []int

	classifyInfo, err := classify.GetByClassifyId(classifyIdFirst)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("分类查询出错")
		return
	}

	if classifyInfo.Id == 0 {
		err = errors.New("分类不存在")
		return
	}


	classifyNameFirst := classifyInfo.ClassifyName
	offset := (pageIndex - 1) * pageSize
	var total int64
	var classifyIdSeconds []int

	if classifyNameFirst == "晨报" {
		//分类获取
		reports, err = report.GetListByClassifyIdFirst(classifyIdFirst, offset, pageSize)
		if err != nil {
			errMsg = err.Error()
			err = errors.New("晨报查询出错")
			return
		}
		total, err = report.GetListCountByClassifyIdFirst(classifyIdFirst)
		if err != nil {
			errMsg = err.Error()
			err = errors.New("查询报告总数出错")
			return
		}
	}else {
		if classifyNameFirst == "周报" {
			newTypeIds, tErr := GetWeekTypeIdsByPermissionIds(permissionIds,[]int{})
			if tErr != nil {
				return
			}
			weekReportIds, err = report_chapter.GetReportIdsByTypeIdsAndClass(newTypeIds, classifyNameFirst)
			//分类获取
			reports, err = report.GetListByIDsAndClassifyIdFirst(weekReportIds, classifyIdFirst, offset, pageSize)
			if err != nil {
				return
			}
			total, err = report.GetListCountByIDsAndClassifyIdFirst(weekReportIds, classifyIdFirst)
			if err != nil {
				errMsg = err.Error()
				err = errors.New("查询报告总数出错")
				return
			}
		}else{
			//获取有权限的二级分类
			var classifyNameSeconds []string
			chartPermissions, tErr := chart_permission_search_key_word_mapping.GetChartPermissionByFrom("rddp")
			if tErr != nil {
				errMsg = tErr.Error()
				err = errors.New("分类权限查询出错")
				return
			}
			if len(chartPermissions) > 0 {
				for _, v := range chartPermissions {
					for _, myPerId := range permissionIds {
						if v.ChartPermissionId == myPerId {
							if classifyNameFirst == "大事点评" || classifyNameFirst == "会议纪要" || classifyNameFirst == "年报合集" {
								if v.KeyWord == "大事点评" || v.KeyWord == "会议纪要" || v.KeyWord == "年报合集" {  //筛选出用户有权限的二级分类ID
									classifyNameSeconds = append(classifyNameSeconds, v.KeyWord)
								}
							}else{
								classifyNameSeconds = append(classifyNameSeconds, v.KeyWord)
							}
							break
						}
					}
				}
			}
			//获取所有二级分类的id
			if classifyNameFirst == "大事点评" || classifyNameFirst == "会议纪要" || classifyNameFirst == "年报合集" {
				classifyIdSeconds, tErr = classify.GetOtherIdsByClassifyNames(classifyNameSeconds)
			}else{
				classifyIdSeconds, tErr = classify.GetIdsByClassifyNameAndParentId(classifyNameSeconds, classifyIdFirst)
			}

			if tErr != nil {
				errMsg = tErr.Error()
				err = errors.New("二级分类查询出错")
				return
			}
			if len(classifyIdSeconds) > 0 {
				//分类获取
				reports, err = report.GetListByClassifyIdSeconds(classifyIdSeconds, offset, pageSize)
				if err != nil {
					return
				}
				total, err = report.GetListCountByClassifyIdSeconds(classifyIdSeconds)
				if err != nil {
					errMsg = err.Error()
					err = errors.New("查询报告总数出错")
					return
				}
			}
		}
	}
	var list []*purchase.Detail
	ret = new(purchase.DetailResp)
	if len(reports) > 0 {
		var viewReportIds []int
		for _, v := range reports {
			viewReportIds = append(viewReportIds, v.Id)
			temp := new(purchase.Detail)
			temp.ReportId = v.Id
			temp.ClassifyIdFirst = v.ClassifyIdFirst
			temp.ClassifyNameFirst = v.ClassifyNameFirst
			temp.Title = v.Title
			temp.ClassifyIdSecond = v.ClassifyIdSecond
			temp.ClassifyNameSecond = v.ClassifyNameSecond
			temp.Stage = v.Stage
			temp.ImgUrl = classifyInfo.YbBgUrl
			if temp.ClassifyNameFirst == "晨报" || temp.ClassifyNameFirst == "周报" {  //晨报或者周报，查询最新的章节信息
				temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.Title)
				temp.TopName = temp.Title
			}else{
				if temp.ClassifyNameFirst != temp.ClassifyNameSecond {     //包含二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC| %s】%s", temp.Stage, temp.ClassifyNameSecond, temp.ClassifyNameFirst)
					temp.TopName = temp.ClassifyNameSecond
				} else {
					temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.ClassifyNameFirst)
					temp.TopName = temp.ClassifyNameFirst
				}
			}
			temp.Time = v.PublishTime
			list = append(list, temp)
		}
	}
	ret.List = list
	ret.Paging = response.GetPaging(pageIndex, pageSize, int(total))
	// 执行一个协程任务，新增用户浏览记录
	//_, tErr := BatchInsertReportView(weekReportIds, userId, classifyNameFirst, classifyIdSeconds)
	task.Task(BatchInsertReportView, weekReportIds, userId, classifyNameFirst, classifyIdSeconds)
	/*if tErr != nil {
		err = tErr
		return
	}*/
	return
}


// 获取报告详情
func GetReportDetail(userinfo user.UserInfo, reportId int) (reportDetail response.ReportDetail, err error) {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetReportDetail: userId=%d, err:%s， errMsg:%s", userinfo.UserID, err.Error(), errMsg))
		}
	}()
	reportInfo, err := report.GetByReportId(reportId)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("报告查询出错")
		return
	}
	if reportInfo.Id == 0 {
		err = errors.New("报告不存在")
		return
	}

	//判断权限
	var authOk bool
	var permissionCheckInfo response.PermissionCheckInfo
	if reportInfo.ClassifyNameFirst == "晨报"{
		authOk, permissionCheckInfo, err = CheckDayReportPermission(userinfo)
	}else if reportInfo.ClassifyNameFirst == "周报"{
		authOk, permissionCheckInfo, err = CheckWeekReportPermission(userinfo, reportId)
	}else{
		authOk, permissionCheckInfo, err = CheckReportPermission(userinfo, reportId)
	}
	if err != nil {
		return
	}

	reportItem := new(response.ReportItem)
	reportItem.ReportId = reportInfo.Id
	reportItem.Title = reportInfo.Title
	reportItem.PublishTime = reportInfo.PublishTime
	reportItem.ClassifyNameFirst = reportInfo.ClassifyNameFirst
	reportItem.ClassifyNameSecond = reportInfo.ClassifyNameSecond
	reportItem.Stage = reportInfo.Stage
	reportItem.Abstract = reportInfo.Abstract
	reportItem.ContentSub = html.UnescapeString(reportInfo.ContentSub)
	reportItem.Frequency = reportInfo.Frequency
	reportItem.VideoName = reportInfo.VideoName
	reportItem.VideoPlaySeconds = reportInfo.VideoPlaySeconds
	reportItem.Author = reportInfo.Author
	var reportTypeList []*response.ReportChapterListItem

	if (reportInfo.ClassifyNameFirst == "晨报" || reportInfo.ClassifyNameFirst == "周报") {
		//（晨报和周报的banner图）
		if reportInfo.ClassifyNameFirst == "晨报"  {
			reportItem.BannerUrl = utils.ALIYUN_YBIMG_HOST + "report_banner_day.jpg"
		} else {
			reportItem.BannerUrl = utils.ALIYUN_YBIMG_HOST + "report_banner_week.jpg"
		}
		if authOk {
			reportTypeList, err = GetChapterListByReport(reportInfo.ClassifyNameFirst, reportInfo.Id, userinfo.CompanyID)
			if err != nil {
				return
			}
		}
	}
	//如果有权限则展示content
	if authOk  {
		_ = AddViewRecord(userinfo, reportInfo.Id, reportInfo.ClassifyNameFirst, 0)
		reportItem.Content = html.UnescapeString(reportInfo.Content)
		reportItem.VideoUrl = reportInfo.VideoUrl
	}
	reportDetail.ReportInfo = reportItem
	reportDetail.ReportChapterList = reportTypeList
	reportDetail.PermissionCheck = &permissionCheckInfo
	reportDetail.AuthOk = authOk
	return
}

// CheckReportPermission 验证用户查看报告的权限
func CheckReportPermission(userInfo user.UserInfo, reportId int) (authOk bool, permissionCheckInfo response.PermissionCheckInfo, err error) {
	permissionIds, err := chart_permission_chapter_mapping.GetPermissionIdsByReportId(reportId, "rddp")
	if err != nil && err != utils.ErrNoRow {
		return
	}
	authOk, permissionCheckInfo, err = company.GetCheckPermission(userInfo.CompanyID, int(userInfo.UserID), permissionIds)
	return
}

// GetReportList 获取报告列表
func GetReportList(user user.UserInfo, keyWord string, classifyIdFirst, classifyIdSecond, pageIndex, pageSize int) (ret *response.ReportList, err error) {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetReportList: userId=%d, err:%s， errMsg:%s", user.UserID, err.Error(), errMsg))
		}
	}()
	var condition string
	pars := make([]interface{}, 0)

	classifyParent, err := classify.GetByClassifyId(classifyIdFirst)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("分类查询出错")
		return
	}
	if classifyParent.Id == 0 {
		err = errors.New("该分类不存在")
		return
	}
	condition = `classify_id_first = ?`
	pars = append(pars, classifyIdFirst)
	permissionMap := make(map[string][]int)
	checkPermissionMap := make(map[string]bool)
	permissionImageMap := make(map[string]string)
	chartPermissionImageMap := make(map[int]string)
    var reportImgUrl string
    chartPermissionList, err := chart_permission.GetFiccListExceptTacticByProductId()
	if err != nil {
		errMsg = err.Error()
		err = errors.New("分类查询出错")
		return
	}

	if len(chartPermissionList) > 0 {
		for _, v := range chartPermissionList {
			chartPermissionImageMap[int(v.ChartPermissionID)] = v.YbImgUrl
		}
	}

	if classifyIdSecond > 0 {
		classifyInfo, tErr := classify.GetByClassifyId(classifyIdSecond)
		if tErr != nil {
			errMsg = tErr.Error()
			err = errors.New("分类查询出错")
			return
		}
		if classifyInfo.Id == 0 {
			err = errors.New("该二级分类不存在")
			return
		}

		condition += " AND classify_id_second = ?"
		pars = append(pars, classifyIdSecond)
		//查询二级分类对应的权限
		permissionIds, tErr := chart_permission_search_key_word_mapping.GetChartPermissionIdsByKeyWord(classifyInfo.ClassifyName)
		if tErr != nil {
			errMsg = tErr.Error()
			err = errors.New("分类权限查询出错")
			return
		}
		permissionMap[classifyInfo.ClassifyName] = permissionIds
		if len(permissionIds)  > 0{
			for _, v := range permissionIds {
				reportImgUrl = chartPermissionImageMap[v]
			}
		}

	}else{
		if classifyParent.ClassifyName == "晨报" || classifyParent.ClassifyName == "周报"{
			reportImgUrl =  chartPermissionImageMap[1]
		}

		chartPermissions, tErr := chart_permission_search_key_word_mapping.GetChartPermissionByFrom("rddp")
		if tErr != nil {
			errMsg = tErr.Error()
			err = errors.New("分类权限查询出错")
			return
		}

		if len(chartPermissions) > 0 {
			for _, v := range chartPermissions {
				permissionMap[v.KeyWord] = append(permissionMap[v.KeyWord], v.ChartPermissionId)
				permissionImageMap[v.KeyWord] = chartPermissionImageMap[v.ChartPermissionId]
			}
		}
	}

	// 获取有效的权限id列表
	validPermissionIdList, err := company.GetValidPermissionIdListByCompany2ProductId(user.CompanyID, 1)
	if err != nil && err != utils.ErrNoRow {
		errMsg = err.Error()
		err = errors.New("查询分类出错")
		return
	}

	if len(validPermissionIdList) > 0 {
		for classifyName, perIds := range permissionMap {
		checkLoop:
			for _, checkId := range perIds{
				for _, validPerid := range validPermissionIdList {
					if checkId == validPerid {
						checkPermissionMap[classifyName] = true
						break checkLoop
					}
				}
			}
		}
	}

	if keyWord != "" {
		condition += ` AND (title LIKE ? OR abstract LIKE ?) `
		pars = append(pars, "%" + keyWord + "%")
		pars = append(pars, "%" + keyWord + "%")
	}
	offset := (pageIndex - 1) * pageSize
	list, err := report.GetReportList(condition, pars, offset, pageSize)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("报告查询出错")
		return
	}
	total, err := report.GetReportListCount(condition, pars)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询报告总数出错")
		return
	}
	var reportList []*response.ReportListItem
	if len(list) > 0 {
		for _, reportInfo := range list {
			reportItem := new(response.ReportListItem)
			reportItem.ReportId = reportInfo.Id
			reportItem.Title = reportInfo.Title
			reportItem.PublishTime = reportInfo.PublishTime
			reportItem.ClassifyNameFirst = reportInfo.ClassifyNameFirst
			reportItem.ClassifyNameSecond = reportInfo.ClassifyNameSecond
			reportItem.ClassifyIdFirst = reportInfo.ClassifyIdFirst
			reportItem.ClassifyIdSecond = reportInfo.ClassifyIdSecond
			reportItem.Stage = reportInfo.Stage
			reportItem.Abstract = reportInfo.Abstract
			reportItem.Author = reportInfo.Author
			if reportInfo.ClassifyNameFirst == "晨报" || reportInfo.ClassifyNameFirst == "周报" || classifyIdSecond > 0{
				reportItem.ReportImgUrl = utils.ALIYUN_YBIMG_HOST + reportImgUrl
			} else if url,ok := permissionImageMap[reportInfo.ClassifyNameSecond]; ok {
				reportItem.ReportImgUrl = utils.ALIYUN_YBIMG_HOST + url
			}
			
			if authOk,ok := checkPermissionMap[reportInfo.ClassifyNameSecond]; ok && authOk {
				reportItem.VideoUrl = reportInfo.VideoUrl
				reportItem.AuthOk = authOk
			}
			reportList = append(reportList, reportItem)
		}

	}
	ret = new(response.ReportList)
	ret.List = reportList
	ret.Paging = response.GetPaging(pageIndex, pageSize, int(total))
	return
}

// GetCollectReportList 首页展示报告汇总列表
func GetCollectReportList(user user.UserInfo, chartPermissionId, pageIndex, pageSize int) (ret *response.ReportCollectResp, err error)  {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetCollectReportList: userId=%d, err:%s， errMsg:%s", user.UserID, err.Error(), errMsg))
		}
	}()

	// 查询权限的基本信息
	permissionInfo, err := chart_permission.GetByChartPermissionId(chartPermissionId)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询权限出错")
		return
	}

	if permissionInfo.ChartPermissionID == 0 {
		err = errors.New("权限不存在")
		return
	}
	// 除了晨报和周报以外的其他报告
	classifyNames, err := chart_permission_search_key_word_mapping.GetKeyWordsByChartPermissionId(chartPermissionId, "rddp")
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询权限对应的分类出错")
		return
	}

	var classifySecondIds []int
	if len(classifyNames) > 0 {
		classifySecondIds, err = classify.GetSecondIdsByClassifyNames(classifyNames)
		if err != nil {
			errMsg = err.Error()
			err = errors.New("查询分类出错")
			return
		}
	}

	// 查询晨报和周报相对应的章节ID
	reportChapterTypeIds, err := report_chapter_type_permission.GetTypeIdsByChartPermissionId(chartPermissionId)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询权限对应的章节出错")
		return
	}

	var reportList []*response.ReportCollectListItem
	list := response.ReportCollectListResp{}
	var total int64
	if len(reportChapterTypeIds) > 0 || len(classifySecondIds) > 0 {
		offset := (pageIndex - 1) * pageSize
		reportList, err = report.GetReportCollectListByPermission(classifySecondIds, reportChapterTypeIds, offset, pageSize)
		if err != nil {
			errMsg = err.Error()
			err = errors.New("查询报告信息出错")
			return
		}
		listMap := make(map[string]*response.ReportCollectList)
		for _, v := range reportList {
			v.ContentSub = html.UnescapeString(v.ContentSub)
			if _, ok := listMap[v.PublishTime.Format("2006-01-02")]; !ok {
				temp := new(response.ReportCollectList)
				temp.Date = v.PublishTime.Format("2006-01-02")
				listMap[v.PublishTime.Format("2006-01-02")] = temp
			}
			listMap[v.PublishTime.Format("2006-01-02")].SubList = append(listMap[v.PublishTime.Format("2006-01-02")].SubList, v)
		}
		for _, v := range listMap {
			list = append(list, v)
		}
		total, err = report.GetReportCollectCountByPermission(classifySecondIds, reportChapterTypeIds)
		if err != nil {
			errMsg = err.Error()
			err = errors.New("查询报告总数出错")
			return
		}
		if len(list) > 0 {
			sort.Sort(list)
		}
	}
	ret = new(response.ReportCollectResp)
	ret.List = list
	ret.Paging = response.GetPaging(pageIndex, pageSize, int(total))
	return
}

func SearchReport(user user.UserInfo, keyWord string, pageIndex, pageSize int)(ret *response.ReportSearchResp, err error) {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("SearchReport: userId=%d, err:%s， errMsg:%s", user.UserID, err.Error(), errMsg))
		}
	}()
	searchResp, total, err := elasticService.SearchReport(keyWord, pageIndex, pageSize)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询失败")
		return
	}
	var reportList []*response.ReportCollectListItem
	if searchResp.Hits != nil {
		for _, v := range searchResp.Hits.Hits {
			temp := new(response.ReportCollectListItem)
			itemJson, tmpErr := v.Source.MarshalJSON()
			if tmpErr != nil {
				errMsg = tmpErr.Error()
				err = errors.New("解析出错")
				return
			}
			reportItem := new(response.EsReportItem)
			tmpErr = json.Unmarshal(itemJson, &reportItem)
			if tmpErr != nil {
				errMsg = tmpErr.Error()
				err = errors.New("解析json出错")
				return
			}
			temp.ReportId = reportItem.ReportId
			temp.ClassifyIdFirst = reportItem.ClassifyIdFirst
			temp.ClassifyNameFirst = reportItem.ClassifyNameFirst
			temp.ClassifyIdSecond = reportItem.ClassifyIdSecond
			temp.ClassifyNameSecond = reportItem.ClassifyNameSecond
			temp.Title = reportItem.Title
			temp.ContentSub = html.UnescapeString(html.UnescapeString(reportItem.BodyContent))
			temp.PublishTime, err = time.Parse("2006-01-02 15:04:05", reportItem.PublishTime)
			fmt.Println(*reportItem)
			if len(v.Highlight["Title"]) > 0 {
				temp.Title = v.Highlight["Title"][0]
			}
			if len(v.Highlight["BodyContent"]) > 0 {
				temp.ContentSub = html.UnescapeString(html.UnescapeString(v.Highlight["BodyContent"][0]))
			}
			if len(v.Highlight["Categories"]) > 0 {
				if temp.ClassifyNameSecond != "" {
					temp.ClassifyNameSecond = "<span style=\"color:#efefef\">"+temp.ClassifyNameSecond+"</span>"
				}
				if temp.ClassifyNameFirst != "" {
					temp.ClassifyNameFirst = "<span style=\"color:#efefef\">"+temp.ClassifyNameFirst+"</span>"
				}
			}
			reportList = append(reportList, temp)
		}
	}
	ret = new(response.ReportSearchResp)
	ret.List = reportList
	ret.Paging = response.GetPaging(pageIndex, pageSize, int(total))
	return
}

// GetTickerData 获取指标数据
func GetTickerData(user user.UserInfo, reportChapterId int) (list []*response.TickerDataItem, err error) {
	var errMsg string
	defer func() {
		if err != nil {
			global.LOG.Critical(fmt.Sprintf("GetTickerData: userId=%d, err:%s， errMsg:%s", user.UserID, err.Error(), errMsg))
		}
	}()
	
	//查询章节类型
	chapter, err := report_chapter.GetTypeIdById(reportChapterId)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询章节失败")
		return
	}

	if chapter.ReportChapterId == 0 {
		err = errors.New("章节不存在或者未发布")
		return
	}
	
	tickers, err := report_chapter_ticker.GetTickerByChapterId(reportChapterId)
	if err != nil {
		errMsg = err.Error()
		err = errors.New("查询章节指标失败")
		return
	}

	if len(tickers) > 0 {
		var tickerNames []string
		for _, v := range tickers {
			tickerNames = append(tickerNames, v.Ticker)
		}
		var dataList []*response.TickerDataItem
		if chapter.TypeId == 17 {
			dataList, err = daily_base_column.GetDataByBaseColumnTickers17(tickerNames)
		}else{
			dataList, err = daily_base_column.GetDataByBaseColumnTickers(tickerNames)
		}
		if err != nil {
			errMsg = err.Error()
			err = errors.New("查询指标数据失败")
			return
		}

		if len(dataList) >= 0 {
			for _, v := range dataList {
				temp := new(response.TickerDataItem)
				temp.BaseColumnName = v.BaseColumnName
				temp.Ticker = v.Ticker
				temp.Date = v.Date
				temp.TickerValue, _ = strconv.ParseFloat(fmt.Sprintf("%.2f",v.TickerValue), 2)
				temp.LastValue, _ = strconv.ParseFloat(fmt.Sprintf("%.2f",v.LastValue), 2)
				temp.MmValue, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", v.MmValue), 2)
				temp.DdValue, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", v.DdValue), 2)
				temp.WwValue, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", v.WwValue), 2)

				list = append(list, temp)
			}
		}
	}
	return
}