hongze_clpt/controllers/report.go

package controllers

import (
	"encoding/json"
	"github.com/rdlucklib/rdluck_tools/paging"
	"hongze/hongze_clpt/models"
	"hongze/hongze_clpt/services"
	"hongze/hongze_clpt/utils"
	"strconv"
	"strings"
	"time"
)

// 报告
type ReportController struct {
	BaseAuthController
}

type ReportCommonController struct {
	BaseCommonController
}

type MobileReportController struct {
	BaseAuthMobileController
}

// @Title 行业报告分类列表接口
// @Description 获取行业报告分类列表接口
// @Param   ChartPermissionId   query   int  true       "分类ID"
// @Success 200 {object} models.TradeReportMappingResp
// @router /tradeList [get]
func (this *MobileReportController) TradeList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	ChartPermissionId, _ := this.GetInt("ChartPermissionId")
	if ChartPermissionId < 1 {
		br.Msg = "请输入分类ID"
		return
	}
	//var result []*models.SearchItem
	var list []*models.TradeReportMapping
	var err error
	mapCategory := make(map[int]int)
	if ChartPermissionId == utils.CE_LUE_ID || ChartPermissionId == utils.GU_SHOU_ID {
		listTrade, errTrade := models.GetReportMappingStrategyHomeAll(user.UserId, ChartPermissionId)
		list = listTrade
		err = errTrade

		if user.Mobile != "" {
			//策略的处理
			categoryList, err := models.GetCygxXzsChooseCategoryList(user.Mobile)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取客户信息失败,Err:" + err.Error()
				return
			}
			for _, v := range categoryList {
				mapCategory[v.CategoryId] = v.CategoryId
			}
		}
		for k, v := range list {
			count, err := models.GetUserIsReadThisNewCategoryArticleCount(v.CategoryId, uid)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取品种信息失败，Err:" + err.Error()
				return
			}
			Newdetail, err := models.GetNewArticleByCategoryId(v.CategoryId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + err.Error()
				return
			}
			if count == 0 && user.CreatedTime.Before(utils.StrTimeToTime(Newdetail.PublishDate)) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(Newdetail.PublishDate)) {
				list[k].IsRed = true
			}
		}
	} else {
		listTrade, errTrade := models.GetTradeAll(ChartPermissionId)
		err = errTrade
		list = listTrade
	}

	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}

	for k, v := range list {

		var condition string
		var pars []interface{}

		//categoryIdSet, errCategory := models.GetdetailByCategoryIdSet(v.CategoryId)
		//if errCategory != nil {
		//	br.Msg = "获取信息失败"
		//	br.ErrMsg = "获取信息失败,Err:" + errCategory.Error() + "categoryID 不存在：" + strconv.Itoa(v.CategoryId)
		//	return
		//}
		//if categoryIdSet != "" {
		//	condition = ` AND a.category_id IN(` + categoryIdSet + `)`
		//} else {
		//	condition = ` AND a.category_id IN(` + strconv.Itoa(v.CategoryId) + `)`
		//}

		if v.PolymerizationId != "" {
			condition = ` AND a.category_id IN(` + v.PolymerizationId + `)`
		} else {
			condition = ` AND a.category_id IN(` + strconv.Itoa(v.CategoryId) + `)`
		}

		if ChartPermissionId != utils.CE_LUE_ID && ChartPermissionId != utils.GU_SHOU_ID {
			var pageSize int
			//if ChartPermissionId == utils.KE_JI_ID {
			//	pageSize = 12
			//} else {
			//	pageSize = 3
			//}

			pageSize = 3
			listArticle, err := models.GetHomeList(condition, pars, 0, pageSize)
			if err != nil {
				br.Msg = "获取信息失败"
				br.Msg = "GetHomeList，Err:" + err.Error()
				return
			}

			if len(listArticle) > 0 {
				list[k].UpdateTime = utils.StrTimeToTime(listArticle[0].PublishDate).Format(utils.FormatDate) //时间字符串格式转时间格式
				count, err := models.CheckThisCategoryNewArticleIsRead(uid, v.CategoryId)
				if err != nil {
					br.Msg = "获取信息失败"
					br.ErrMsg = "获取帖子总数失败，Err:" + err.Error()
					return
				}
				if count == 0 && user.CreatedTime.Before(utils.StrTimeToTime(v.UpdateTime)) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(v.UpdateTime)) {
					list[k].IsRed = true
				}
			}
			list[k].ListArticle = listArticle
		} else {
			if mapCategory[v.CategoryId] > 0 {
				list[k].IsFollow = true
			}
			list[k].ListArticle = make([]*models.HomeArticle, 0)
		}
	}
	resp := new(models.TradeReportMappingResp)
	if len(list) == 0 {
		list = make([]*models.TradeReportMapping, 0)
	}
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 产业报告分类列表接口
// @Description 获取产业报告分类列表接口
// @Param   ChartPermissionId   query   int  true       "分类ID"
// @Param   DeepCover   query   int  false       "是否选择深度覆盖，1是，0否 不填默认为0"
// @Param   RecommendFocus   query   int  false       "是否选择推荐关注，1是，0否 不填默认为0"
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   IsBillboard   query   bool  false       "是否属于榜单 是true 否 false"
// @Success 200 {object} models.IndustrialManagementList
// @router /industryList [get]
func (this *MobileReportController) IndustryList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	ChartPermissionId, _ := this.GetInt("ChartPermissionId")
	orderColumn := this.GetString("OrderColumn")
	orderColumnNew := this.GetString("OrderColumn")
	isNewLabel := this.GetString("IsNewLabel")
	isDeepLabel := this.GetString("IsDeepLabel")
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	deepCover, _ := this.GetInt("DeepCover")
	recommendFocus, _ := this.GetInt("RecommendFocus")
	isBillboard, _ := this.GetBool("IsBillboard", false)
	var orderSrt string
	var condition string
	var startSize int
	resp := new(models.IndustrialManagementList)
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)
	if ChartPermissionId > 0 {
		condition += ` AND man.chart_permission_id IN (` + strconv.Itoa(ChartPermissionId) + `)`
	}

	// 获取近一个月产业报告阅读次数最多的产业
	var topCond string
	var topPars []interface{}
	topReadIndustryId := 0
	if ChartPermissionId > 0 {
		topCond += ` AND chart_permission_id = ?`
		topPars = append(topPars, ChartPermissionId)
	}
	topReadIndustry, e := models.GetTopOneMonthArtReadNumIndustry(topCond, topPars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取近一个月报告阅读次数最多的产业失败, Err: " + e.Error()
		return
	}
	if topReadIndustry != nil {
		topReadIndustryId = topReadIndustry.IndustrialManagementId
	}
	// 深度覆盖
	if deepCover == 1 {
		// 查询深标签产业报告数
		var deepCondition string
		var deepPars []interface{}
		deepCondition += ` AND man.is_deep_label = 1`
		if ChartPermissionId > 0 {
			deepCondition += ` AND man.chart_permission_id = ?`
			deepPars = append(deepPars, ChartPermissionId)
		}
		industryCountList, e := models.GetIndustryArtCountByCondition(deepCondition, deepPars)
		if e != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取深标签产业报告数失败, Err: " + e.Error()
			return
		}
		deepIdArr := make([]string, 0)
		for i := range industryCountList {
			if industryCountList[i].ArtNum > 10 {
				deepIdArr = append(deepIdArr, strconv.Itoa(industryCountList[i].IndustrialManagementId))
			}
		}
		deepIds := strings.Join(deepIdArr, ",")
		if deepIds != "" {
			condition = `AND man.industrial_management_id IN (` + deepIds + `)`
		}
	}
	// 推荐关注
	if recommendFocus == 1 {
		condition += ` AND man.recommended_index >= 80`
	}

	var list []*models.IndustrialManagement
	total, err := models.GetIndustrialManagementAllCount(condition)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取数量失败,Err:" + err.Error()
		return
	}

	if orderColumn == "" {
		orderColumn = "NewTime"
	}
	if orderColumn == "NewTime" {
		orderSrt = "update_time DESC"
	} else {
		orderSrt = "man.recommended_index DESC,update_time DESC"
	}

	if isBillboard {
		// 查询有已归类行业报告的行业IDs
		activeIndustryIds, e := models.GetActiveArticleIndustryIds()
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取已归类行业失败, Err:" + e.Error()
			return
		}
		activeIndustryLen := len(activeIndustryIds)
		//topNum := pageSize
		condition = ""
		var parsBd []interface{}
		if ChartPermissionId > 0 {
			condition += ` 	AND man.chart_permission_id = ?  `
			parsBd = append(parsBd, ChartPermissionId)
		}
		if activeIndustryLen > 0 {
			condition += ` AND man.industrial_management_id IN (` + utils.GetOrmInReplace(activeIndustryLen) + `)`
			parsBd = append(parsBd, activeIndustryIds)
		}
		nowTime := time.Now().Local()
		startTime := nowTime.AddDate(0, -1, 0)
		endTime := nowTime.AddDate(0, 0, -1)
		condition += ` AND idf.create_time BETWEEN ? AND ?`
		parsBd = append(parsBd, startTime, endTime)
		list, e = models.GetTopIndustryFollowData(0, pageSize, condition, parsBd)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取关注度最高的产业数据失败, Err:" + e.Error()
			return
		}
	} else {
		list, err = models.GetIndustrialManagementAll(uid, condition, orderSrt, startSize, pageSize, isBillboard)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
			return
		}
	}

	var resource string
	if ChartPermissionId == utils.CHART_PERMISSION_ID_YANXUAN {
		resource = utils.REOURCE_YX
	} else {
		resource = utils.REOURCE_HZ
	}
	list, err = services.HandleIndustryList(list, user, resource)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	industrialIdArr := make([]int, 0)
	for k, v := range list {
		industrialIdArr = append(industrialIdArr, v.IndustrialManagementId)
		if topReadIndustryId > 0 && list[k].IndustrialManagementId == topReadIndustryId {
			list[k].IsHot = true
		}
	}
	if orderColumnNew != "" {
		item := new(models.CygxReportIndustrialSeaarchHistory)
		item.UserId = user.UserId
		item.Mobile = user.Mobile
		item.CompanyId = user.CompanyId
		item.CompanyName = user.CompanyName
		item.CreateTime = time.Now()
		item.IsDeepLabel = isDeepLabel
		item.IsNewLabel = isNewLabel
		item.ChartPermissionId = ChartPermissionId
		if orderColumnNew == "NewTime" {
			item.OrderColumn = "0"
		} else {
			item.OrderColumn = "1"
		}
		go models.AddCygxReportIndustrialSeaarchHistory(item)
	}
	if len(list) == 0 {
		list = make([]*models.IndustrialManagement, 0)
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	if isBillboard {
		total = len(list)
	}
	resp.List = list
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 产业下所关联的文章分类列表
// @Description 产业下所关联的文章分类列表接口
// @Param   IndustrialManagementId   query   int  true       "产业ID"
// @Success 200 {object} models.IndustrialToArticleCategoryListRep
// @router /toArticleCategoryList [get]
func (this *MobileReportController) ArticleCategoryList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	industrialManagementId, _ := this.GetInt("IndustrialManagementId")
	if industrialManagementId < 1 {
		br.Msg = "请输入分类ID"
		return
	}

	detail, err := models.GetIndustrialManagementDetail(industrialManagementId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取信息失败,Err:" + err.Error()
		return
	}
	list, err := models.IndustrialToArticleCategory(industrialManagementId, detail.ChartPermissionId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}

	for k, v := range list {
		recordCount, err := models.IndustrialUserRecordArticleCount(uid, industrialManagementId, v.CategoryId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "判断是否已申请过试用失败，Err:" + err.Error()
			return
		}
		Newdetail, err := models.GetNewIndustrialUserRecordArticle(industrialManagementId, v.CategoryId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
		if Newdetail != nil {
			if recordCount == 0 && user.CreatedTime.Before(utils.StrTimeToTime(Newdetail.PublishDate)) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(Newdetail.PublishDate)) {
				list[k].IsRed = true
			}
		}
	}
	//标的列表
	industrialSubjectList, err := models.GetIndustrialSubjectAll(industrialManagementId)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}
	videoSimple, au, err := services.GetindustryVideo(user, industrialManagementId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取用户权限失败, Err: " + err.Error()
		return
	}
	timeLineItem := models.IndustrialToArticleCategoryRep{
		CategoryId:    utils.TIME_CATEGORYID,
		MatchTypeName: "时间线",
	}
	timeLineIsRed, err := services.GetShowTimeLineIsRed(user, industrialManagementId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取用户权限失败, Err: " + err.Error()
		return
	}
	timeLineItem.IsRed = timeLineIsRed
	list = append([]*models.IndustrialToArticleCategoryRep{&timeLineItem}, list...)
	resp := new(models.IndustrialToArticleCategoryListRep)
	resp.List = list
	resp.ListSubject = industrialSubjectList
	resp.LayoutTime = utils.TimeRemoveHms(detail.LayoutTime)
	resp.IndustryName = detail.IndustryName
	resp.IndustrialManagementId = industrialManagementId
	if videoSimple != nil && videoSimple.Id > 0 {
		resp.IndustryVideo = videoSimple
	}
	resp.AuthInfo = au
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 根据行业分类获取文章列表
// @Description根据行业分类获取文章列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   CategoryId   query   int  true       "分类ID"
// @Param   IndustrialManagementId   query   int  false       "产业ID"
// @Success 200 {object} models.TacticsListResp
// @router /articleList/byCategoryId [get]
func (this *MobileReportController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	//uid := user.UserId
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	categoryId, _ := this.GetInt("CategoryId")
	industrialManagementId, _ := this.GetInt("IndustrialManagementId")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)
	var condition string
	var pars []interface{}
	var total int
	resp := new(models.TacticsListResp)
	page := paging.GetPaging(currentIndex, pageSize, total)
	list := make([]*models.ArticleListResp, 0)

	if categoryId == utils.TIME_CATEGORYID {
		var err error
		list, total, err = models.GetTimeLineReportIndustrialList(industrialManagementId, startSize, pageSize)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取产业报告+晨会点评列表,Err:" + err.Error()
			return
		}
	} else {
		//获取该产业下所对应的行业图片
		var reportType int
		if industrialManagementId > 0 {
			reportType = 2
		} else {
			reportType = 1
		}
		detail, errCategory := models.GetdetailByCategoryIdOne(categoryId, reportType)
		if errCategory != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + errCategory.Error() + "categoryID 不存在：" + strconv.Itoa(categoryId)
			return
		}
		//对应行业的图片
		detailChartPermissionUrl, err := models.GetConfigByCode("category_chart_permissionimg_url")
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
			return
		}
		chartPermissionUrlList := strings.Split(detailChartPermissionUrl.ConfigValue, "{|}")
		mapChartPermission := make(map[string]string)
		var permissionName string
		var imgUrlChartPermission string
		for _, v := range chartPermissionUrlList {
			vslice := strings.Split(v, "_")
			permissionName = vslice[0]
			imgUrlChartPermission = vslice[len(vslice)-1]
			mapChartPermission[permissionName] = imgUrlChartPermission
		}

		//对应分类的所图片
		detailCategoryUrl, err := models.GetConfigByCode("category_map_img_url")
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "行业配置信息失败，Err:" + err.Error()
			return
		}
		categoryUrlList := strings.Split(detailCategoryUrl.ConfigValue, "{|}")
		mapCategoryUrl := make(map[string]string)
		var categoryIdStr string
		var imgUrlChart string
		for _, v := range categoryUrlList {
			vslice := strings.Split(v, "_")
			categoryIdStr = vslice[0]
			imgUrlChart = vslice[len(vslice)-1]
			mapCategoryUrl[categoryIdStr] = imgUrlChart
		}
		if detail.CeLueFieldId != "" {
			condition = ` AND ce_lue_field_id IN(` + detail.CeLueFieldId + `)`
		} else if detail.PolymerizationId != "" {
			condition = ` AND category_id IN(` + detail.PolymerizationId + `)`
		} else {
			categoryIdSet, errCategory := models.GetdetailByCategoryIdSet(categoryId)
			if errCategory != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + errCategory.Error() + "categoryID 不存在：" + strconv.Itoa(categoryId)
				return
			}
			if categoryIdSet != "" {
				condition = ` AND category_id IN(` + categoryIdSet + `)`
			} else {
				condition = ` AND category_id IN(` + strconv.Itoa(categoryId) + `)`
			}
		}

		if industrialManagementId > 0 {
			industrialManageentList, err := models.GetIndustrialArticleGroupManagementByIndustrialManagementId(industrialManagementId)
			if err != nil {
				br.Msg = "获取信息失败"
				br.Msg = "获取产业关联的文章ID失败，GetIndustrialArticleGroupManagementByIndustrialManagementIdErr:" + err.Error()
				return
			}
			articleIdList := make([]string, 0)
			for _, v := range industrialManageentList {
				articleIdList = append(articleIdList, strconv.Itoa(v.ArticleId))
			}
			condition += ` AND a.article_id IN (  ` + utils.GetOrmInReplace(len(articleIdList)) + ` )  `
			pars = append(pars, articleIdList)
		}

		total, err = models.GetHomeCount(condition, pars)
		if err != nil {
			br.Msg = "获取信息失败"
			br.Msg = "获取帖子总数失败，Err:" + err.Error()
			return
		}

		list, err = models.GetHomeListNew(condition, pars, startSize, pageSize)
		if err != nil {
			br.Msg = "获取信息失败"
			br.Msg = "获取帖子数据失败，Err:" + err.Error()
			return
		}
		articleIdMap, err := services.GetUserArticleHistoryRecord(user)
		if err != nil {
			br.Msg = "获取信息失败"
			br.Msg = "获取帖子数据失败，Err:" + err.Error()
			return
		}
		for k, v := range list {
			list[k].ImgUrlPc = mapCategoryUrl[v.CategoryId]
			if !articleIdMap[v.ArticleId] && user.CreatedTime.Before(utils.StrTimeToTime(v.PublishDate)) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(v.PublishDate)) {
				list[k].IsRed = true
			}
		}
		if categoryId > 0 {
			detail, errCategory := models.GetdetailByCategoryId(categoryId)
			if errCategory != nil {
				br.Msg = "获取信息失败"
				br.ErrMsg = "获取信息失败,Err:" + errCategory.Error() + "categoryID 不存在：" + strconv.Itoa(categoryId)
				return
			}
			resp.MatchTypeName = detail.MatchTypeName
		}
		resp.CategoryImgUrlPc = mapChartPermission[detail.ChartPermissionName]
	}

	listPublic, err := services.HandleArticleCategoryImg(list, user)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取报告封面图片失败, Err:" + err.Error()
		return
	}
	listResp := make([]*models.HomeArticle, 0)
	//listResp :=
	for _, v := range listPublic {
		listResp = append(listResp, &models.HomeArticle{
			ArticleId:   v.ArticleId,
			Title:       v.Title,
			Annotation:  "核心观点：" + v.Annotation,
			Abstract:    v.Abstract,
			ImgUrlPc:    v.ImgUrlPc,
			PublishDate: v.PublishDate,
		})
	}
	//lenList := len(list)
	//for i := 0; i < lenList; i++ {
	//	item := list[i]
	//	list[i].Body = ""
	//	list[i].Abstract, _ = services.GetReportContentTextSub(item.Abstract)
	//	list[i].Annotation, _ = services.GetReportContentTextSub(item.Annotation)
	//	list[i].PublishDate = utils.StrTimeToTime(item.PublishDate).Format(utils.FormatDate) //时间字符串格式转时间格式
	//	//行业比较研究、资金流向，显示报告的摘要
	//	if resp.MatchTypeName == "行业比较研究" || resp.MatchTypeName == "资金流向" {
	//		list[i].Annotation = list[i].Abstract
	//	}
	//}
	if len(listResp) == 0 {
		listResp = make([]*models.HomeArticle, 0)
	}
	page = paging.GetPaging(currentIndex, pageSize, total)
	resp.List = listResp
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 产业关注/取消关注
// @Description 产业关注/取消关注 接口
// @Param	request	body models.CygxIndustryFllowRep true "type json string"
// @Success 200
// @router /industrial/fllow [post]
func (this *ReportController) IndustrialFllow() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.CygxIndustryFllowRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	industrialManagementId := req.IndustrialManagementId
	var condition string
	countIndustrial, err := models.GetIndustrialManagementCount(industrialManagementId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	if countIndustrial == 0 {
		br.Msg = "产业不存在！"
		br.ErrMsg = "产业ID不存在:" + strconv.Itoa(industrialManagementId)
		return
	}
	count, err := models.GetCountCygxIndustryFllow(industrialManagementId, user.UserId, condition)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.CygxIndustryFllowResp)
	if count == 0 {
		item := new(models.CygxIndustryFllow)
		item.IndustrialManagementId = industrialManagementId
		item.UserId = uid
		item.Email = user.Email
		item.Mobile = user.Mobile
		item.RealName = user.RealName
		item.CompanyId = user.CompanyId
		item.CompanyName = user.CompanyName
		item.Type = 1
		item.CreateTime = time.Now()
		item.ModifyTime = time.Now()
		_, err = models.AddCygxIndustryFllow(item)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "操作失败,Err:" + err.Error()
			return
		}
		resp.Status = 1
		br.Msg = "关注成功"
	} else {
		err = models.RemoveCygxIndustryFllow(uid, industrialManagementId)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "取消关注失败,Err:" + err.Error()
			return
		}
		resp.Status = 2
		br.Msg = "已取消关注"
	}
	//处理是否关注全部赛道字段
	go services.IndustryFllowWithTrack(industrialManagementId, count, uid)
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 行业关注/取消关注
// @Description 行业关注/取消关注 接口
// @Param	request	body models.CygxCategoryFllowRep true "type json string"
// @Success 200
// @router /category/fllow [post]
func (this *ReportController) CategoryFllow() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	var req models.CygxCategoryFllowRep
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	categoryId := req.CategoryId
	var condition string
	countCategory, err := models.GetCategoryCount(categoryId)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	if countCategory == 0 {
		br.Msg = "产业不存在！"
		br.ErrMsg = "产业ID不存在:" + strconv.Itoa(categoryId)
		return
	}
	count, err := models.GetCountCategoryFllow(categoryId, user.Mobile, condition)
	if err != nil {
		br.Msg = "获取数据失败！"
		br.ErrMsg = "获取数据失败，Err:" + err.Error()
		return
	}
	resp := new(models.CygxIndustryFllowResp)
	if count == 0 {
		item := new(models.CygxXzsChooseCategory)
		item.CategoryId = categoryId
		item.UserId = uid
		item.Email = user.Email
		item.Mobile = user.Mobile
		item.RealName = user.RealName
		item.CompanyId = user.CompanyId
		item.CompanyName = user.CompanyName
		item.CreateTime = time.Now()
		item.ModifyTime = time.Now()
		_, err = models.AddCygxCategoryFllow(item)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "操作失败,Err:" + err.Error()
			return
		}
		resp.Status = 1
		br.Msg = "关注成功"
	} else {
		err = models.RemoveCygxCategoryFllow(user.Mobile, categoryId)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = "取消关注失败,Err:" + err.Error()
			return
		}
		resp.Status = 2
		br.Msg = "已取消关注"
	}
	br.Ret = 200
	br.Success = true
	br.Data = resp
}

// @Title 报告搜索
// @Description 报告搜索接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Param   ArticleType   query   int  true       "文章类型，1弘则报告、2研选 "
// @Param   IsAll   query   bool  true       "是否为综合 "
// @Success 200 {object} models.ReoprtSearchResp
// @router /searchReport [get]
func (this *MobileReportController) SearchReport() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	articleType, _ := this.GetInt("ArticleType", 1)
	keyWord := this.GetString("KeyWord")
	isAll, _ := this.GetBool("IsAll")
	var condition string
	var pars []interface{}
	//var conditionSql string
	var total int
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if isAll {
		pageSize = utils.PageSize5
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	resp := new(models.ReoprtSearchResp)
	//匹配报告标题、
	articleTypeIds, err := services.GetYanXuanArticleTypeIds()
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "GetYanXuanArticleTypeIds,Err:" + err.Error()
		return
	}
	if articleTypeIds == "" {
		br.Msg = "获取信息失败"
		br.ErrMsg = "研选分类ID不能为空"
		return
	}
	//处理对应的文章类型标签按钮
	nameMap, styleMap, err := services.GetArticleTypeMap()
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "GetArticleTypeMap Err:" + err.Error()
		return
	}
	if isAll {
		total = utils.PageSize5
		conditionHz := `  AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%' OR  a.annotation LIKE '%` + keyWord + `%' OR  a.abstract LIKE '%` + keyWord + `%') AND a.publish_status = 1  AND a.article_type_id NOT IN (` + articleTypeIds + `)  `
		conditionYx := `  AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%' OR  a.annotation LIKE '%` + keyWord + `%' OR  a.abstract LIKE '%` + keyWord + `%') AND a.publish_status = 1  AND a.article_type_id  IN (` + articleTypeIds + `)  `

		listHz, err := models.GetArticleResearchListHz(conditionHz, pars, startSize, pageSize, user.UserId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
			return
		}
		listYx, err := models.GetArticleResearchList(conditionYx, pars, startSize, pageSize, user.UserId)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
			return
		}

		listHz, err = services.HandleArticleCategoryImg(listHz, user)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "HandleArticleCategoryImg,Err:" + err.Error()
			return
		}

		listYx, err = services.HandleArticleCategoryImg(listYx, user)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "HandleArticleCategoryImg,Err:" + err.Error()
			return
		}

		for _, v := range listHz {
			item := models.ArticleResearchResp{
				ArticleId:       v.ArticleId,
				ArticleTypeId:   v.ArticleTypeId,
				Title:           v.Title,
				PublishDate:     v.PublishDate,
				DepartmentId:    v.DepartmentId,
				NickName:        v.NickName,
				IsCollect:       v.IsCollect,
				Pv:              v.Pv,
				CollectNum:      v.CollectNum,
				Abstract:        v.Abstract,
				Annotation:      v.Annotation,
				ImgUrlPc:        v.ImgUrlPc,
				ArticleTypeName: nameMap[v.ArticleTypeId],
				ButtonStyle:     styleMap[v.ArticleTypeId],
				List:            v.List,
			}
			resp.ListHz = append(resp.ListHz, &item)
		}

		for _, v := range listYx {
			item := models.ArticleResearchResp{
				ArticleId:       v.ArticleId,
				ArticleTypeId:   v.ArticleTypeId,
				Title:           v.Title,
				PublishDate:     v.PublishDate,
				DepartmentId:    v.DepartmentId,
				NickName:        v.NickName,
				IsCollect:       v.IsCollect,
				Pv:              v.Pv,
				CollectNum:      v.CollectNum,
				Abstract:        v.Abstract,
				Annotation:      v.Annotation,
				ImgUrlPc:        v.ImgUrlPc,
				ArticleTypeName: nameMap[v.ArticleTypeId],
				ButtonStyle:     styleMap[v.ArticleTypeId],
				List:            v.List,
			}
			resp.ListYx = append(resp.ListYx, &item)
		}
	} else {

		//condition = `AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%' OR  a.annotation LIKE '%` + keyWord + `%' OR  a.abstract LIKE '%` + keyWord + `%') AND a.publish_status = 1 `
		if articleType == 1 {
			condition = `  AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%' OR  a.annotation LIKE '%` + keyWord + `%' OR  a.abstract LIKE '%` + keyWord + `%') AND a.publish_status = 1  AND a.article_type_id NOT IN (` + articleTypeIds + `)  `
			total, err = models.GetReoprtSearchCountHz(condition)
		} else {
			condition = `  AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%' OR  a.annotation LIKE '%` + keyWord + `%' OR  a.abstract LIKE '%` + keyWord + `%') AND a.publish_status = 1  AND a.article_type_id  IN (` + articleTypeIds + `)  `
			total, err = models.GetReoprtSearchCountYx(condition)
		}
		if err != nil {
			br.Msg = "获取信息失败"
			br.Msg = "获取总数失败，Err:" + err.Error()
			return
		}
		var list []*models.ArticleListResp
		//list := new([]models.ArticleResearchResp)
		if articleType == 1 {
			list, err = models.GetArticleResearchListHz(condition, pars, startSize, pageSize, user.UserId)
		} else {
			list, err = models.GetArticleResearchList(condition, pars, startSize, pageSize, user.UserId)
		}
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
			return
		}
		//return
		list, err = services.HandleArticleCategoryImg(list, user)
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "HandleArticleCategoryImg,Err:" + err.Error()
			return
		}

		for _, v := range list {
			item := models.ArticleResearchResp{
				ArticleId:       v.ArticleId,
				ArticleTypeId:   v.ArticleTypeId,
				Title:           v.Title,
				PublishDate:     v.PublishDate,
				DepartmentId:    v.DepartmentId,
				NickName:        v.NickName,
				IsCollect:       v.IsCollect,
				Pv:              v.Pv,
				CollectNum:      v.CollectNum,
				Abstract:        v.Abstract,
				Annotation:      v.Annotation,
				ImgUrlPc:        v.ImgUrlPc,
				ArticleTypeName: nameMap[v.ArticleTypeId],
				ButtonStyle:     styleMap[v.ArticleTypeId],
				List:            v.List,
			}
			if articleType == 1 {
				resp.ListHz = append(resp.ListHz, &item)
			} else {
				resp.ListYx = append(resp.ListYx, &item)
			}
		}
	}

	if keyWord != "" {
		go services.AddUserSearchLog(user, keyWord, 5)
	}
	if len(resp.ListHz) == 0 {
		resp.ListHz = make([]*models.ArticleResearchResp, 0)
	}
	if len(resp.ListYx) == 0 {
		resp.ListYx = make([]*models.ArticleResearchResp, 0)
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 资源包搜索
// @Description 资源包搜索接口
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Success 200 {object} models.SearchResourceResp
// @router /searchResource [get]
func (this *MobileReportController) SearchResource() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	uid := user.UserId
	fllowList, err := models.GetUserFllowIndustrialList(uid)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，GetUserFllowIndustrialList Err:" + err.Error()
		return
	}
	fllowMap := make(map[int]int)
	if len(fllowList) > 0 {
		for _, v := range fllowList {
			fllowMap[v.IndustrialManagementId] = v.IndustrialManagementId
		}
	}
	keyWord := this.GetString("KeyWord")
	var condition string

	articleTypeIds, err := services.GetYanXuanArticleTypeIds()
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "GetYanXuanArticleTypeIds,Err:" + err.Error()
		return
	}
	if articleTypeIds == "" {
		br.Msg = "获取信息失败"
		br.ErrMsg = "研选分类ID不能为空"
		return
	}

	condition = `  AND a.publish_status = 1 AND a.article_type_id NOT IN (` + articleTypeIds + `)  AND (m.industry_name LIKE '%` + keyWord + `%' OR m.subject_names LIKE '%` + keyWord + `%'  )  `
	listHz, err := models.GetSearchResourceList(condition)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}

	condition = `  AND a.publish_status = 1 AND a.article_type_id IN (` + articleTypeIds + `)  AND (m.industry_name LIKE '%` + keyWord + `%' OR m.subject_names LIKE '%` + keyWord + `%'  )  `
	listYx, err := models.GetSearchResourceList(condition)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}

	if len(listYx) > 0 {
		listYx, err = services.HandleIndustryList(listYx, user, "Yx")
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
	}
	if len(listHz) > 0 {
		listHz, err = services.HandleIndustryList(listHz, user, "Hz")
		if err != nil {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取信息失败,Err:" + err.Error()
			return
		}
	}
	if keyWord != "" {
		go services.AddUserSearchLog(user, keyWord, 4)
	}
	resp := new(models.SearchResourceResp)
	if len(listHz) == 0 {
		listHz = make([]*models.IndustrialManagement, 0)
	}
	if len(listYx) == 0 {
		listYx = make([]*models.IndustrialManagement, 0)
	}
	resp.ListHz = listHz
	resp.ListYx = listYx
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 报告搜索、资源包搜索接口
// @Description 报告搜索、资源包搜索接口接口
// @Param   KeyWord   query   string  true       "搜索关键词"
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   SearchType   query   int  true       "1：综合，2：全部"
// @Success 200 {object} models.SearchReportAndResourceResp
// @router /searchReportAndResource [get]
func (this *MobileReportController) SearchReportAndResource() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	//uid := user.UserId
	keyWord := this.GetString("KeyWord")
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	searchType, _ := this.GetInt("SearchType")
	var total int
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)
	page := paging.GetPaging(currentIndex, pageSize, total)
	var condition string
	var conditionSql string
	//匹配报告标题、
	condition = ` AND ( a.title LIKE '%` + keyWord + `%' OR  a.body LIKE '%` + keyWord + `%') AND a.publish_status = 1 `
	conditionSql = ` AND a.article_id <  ` + strconv.Itoa(utils.SummaryArticleId) + condition + ` OR ( article_type = 'lyjh' ` + condition + ` ) `
	total, err := models.GetReoprtSearchCount(conditionSql)
	if err != nil {
		br.Msg = "获取信息失败"
		br.Msg = "获取总数失败，Err:" + err.Error()
		return
	}
	if searchType == 1 {
		pageSize = utils.PageSize5
	}
	ListHzReport, err := services.GetReoprtSearchListHz(conditionSql, user.UserId, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，GetReoprtSearchListHz Err:" + err.Error()
		return
	}
	if len(ListHzReport) == 0 {
		ListHzReport = make([]*models.ArticleCollectionResp, 0)
	}
	var conditionOr string
	conditionOr += ` OR ( m.subject_names LIKE '%` + keyWord + `%' AND a.article_id < ` + strconv.Itoa(utils.SummaryArticleId) + `  AND publish_status = 1 ) `
	condition = ` AND m.industry_name LIKE '%` + keyWord + `%' AND a.article_id < ` + strconv.Itoa(utils.SummaryArticleId) + conditionOr
	listHzResource, err := services.GetSearchResourceListHz(condition, user)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取品种信息失败,Err:" + err.Error()
		return
	}
	resp := new(models.SearchReportAndResourceResp)
	if len(listHzResource) == 0 {
		listHzResource = make([]*models.IndustrialManagement, 0)
	}
	if keyWord != "" {
		go services.AddUserSearchLog(user, keyWord, 5)
	}
	page = paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page
	resp.ListHzResource = listHzResource
	resp.ListHzReport = ListHzReport
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 公司速览
// @Description 公司速览接口
// @Param   ChartPermissionId   query   int  false       "分类ID"
// @Success 200 {object} models.ArticleDataLogoListResp
// @router /companyList [get]
func (this *ReportCommonController) CompanyList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var condition string
	var pars []interface{}
	chartPermissionId, _ := this.GetInt("ChartPermissionId")
	if chartPermissionId > 1 {
		categoryId, err := models.GetCategoryId(chartPermissionId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败"
			br.ErrMsg = "获取分类权限信息失败，Err:" + err.Error()
			return
		}
		if categoryId != "" {
			condition += ` AND a.category_id IN  (` + categoryId + `)`
		}
	}
	condition += ` 	AND a.type_name = '综述报告'   ORDER BY  a.modify_time_by_cl DESC  `
	list, err := models.CygxArticleDataList(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取报告封面图片失败, Err:" + err.Error()
		return
	}
	listLogo := make([]*models.ArticleDataLogoResp, 0)
	for i := range list {
		v := list[i]
		comapnyList := services.HandleArticleStock(v.Stock)
		if len(comapnyList) > 1 {
			for kC, vC := range comapnyList {
				sliceCovers := strings.Split(v.Cover, "{|}")
				cover := v.Cover
				if len(sliceCovers) == len(comapnyList) {
					cover = sliceCovers[kC]
				}
				listLogo = append(listLogo, &models.ArticleDataLogoResp{
					ArticleId:   v.ArticleId,
					Cover:       cover,
					ComapnyList: services.HandleArticleStock(vC.ComapnyName),
				})
			}
		} else {
			listLogo = append(listLogo, &models.ArticleDataLogoResp{
				ArticleId:   v.ArticleId,
				Cover:       v.Cover,
				ComapnyList: services.HandleArticleStock(v.Stock),
			})
		}

	}
	resp := new(models.ArticleDataLogoListResp)
	resp.List = listLogo
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 时间线
// @Description 时间线接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   IndustrialManagementId   query   int  false       "产业ID"
// @Success 200 {object} models.TacticsListResp
// @router /timeline [get]
func (this *MobileReportController) Timeline() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	industrialManagementId, _ := this.GetInt("IndustrialManagementId")
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)
	var total int
	resp := new(models.TacticsListTimeResp)
	page := paging.GetPaging(currentIndex, pageSize, total)
	list := make([]*models.TimeLineReportItem, 0)
	var err error
	list, total, err = models.GetTimeLineReportIndustrialListTime(user.UserId, industrialManagementId, startSize, pageSize)
	if err != nil {
		br.Msg = "获取信息失败"
		br.ErrMsg = "获取产业报告+晨会点评列表,Err:" + err.Error()
		return
	}
	//查询用户今天是否看过时间线
	count, err := models.GetTimeLineRecordCount(user.UserId, industrialManagementId)
	if err != nil {
		br.Msg = "查询浏览记录数量失败"
		br.ErrMsg = "查询浏览记录数量失败，Err:" + err.Error()
		return
	}
	var recordItem *models.CygxPageHistoryRecord
	if count > 1 {
		recordItem, err = models.GetTimeLineRecordItem(user.UserId, industrialManagementId)
		if err != nil {
			br.Msg = "查询浏览记录失败"
			br.ErrMsg = "查询浏览记录失败，Err:" + err.Error()
			return
		}
	}

	for k, v := range list {
		if v.SubCategoryName != "时间线" && v.Readnum == 0 && user.CreatedTime.Before(utils.StrTimeToTime(v.PublishDate)) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(v.PublishDate)) {
			list[k].IsRed = true
		}
		timeLineRed := false
		if count < 2 && v.SubCategoryName == "时间线" {
			timeLineRed = true
		} else if count > 1 && recordItem.CreateTime.Before(utils.StrTimeToTime(v.PublishDate)) {
			timeLineRed = true
		}
		if v.SubCategoryName == "时间线" && timeLineRed {
			list[k].IsRed = true
		}
		if v.VideoUrl != "" {
			list[k].IsHaveVideo = true
		}

	}

	//添加我的日程访问记录
	item := new(models.CygxPageHistoryRecord)
	item.UserId = user.UserId
	item.CreateTime = time.Now()
	item.CompanyId = user.CompanyId
	item.CompanyName = user.CompanyName
	item.Router = utils.TIME_LINE_ROUTE + strconv.Itoa(industrialManagementId)
	go models.AddCygxPageHistoryRecord(item)
	if len(list) == 0 {
		list = make([]*models.TimeLineReportItem, 0)
	}
	page = paging.GetPaging(currentIndex, pageSize, total)
	resp.List = list
	resp.Paging = page
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 文章留言接口
// @Description 文章留言接口
// @Param	request	body models.AddCygxActivityHelpAsk true "type json string"
// @Success 200 {object} models.TacticsListResp
// @router /commentAdd [post]
func (this *ReportController) CommentAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	user := this.User
	if user == nil {
		br.Msg = "请重新登录"
		br.Ret = 408
		return
	}
	var req models.AddCygxArticleCommentReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ArticleId <= 0 {
		br.Msg = "文章不存在"
		br.ErrMsg = "文章不存在，文章ID错误"
		return
	}
	if req.Content == "" {
		br.Msg = "建议内容不可为空"
		return
	}
	content := req.Content
	if content == "" {
		br.Msg = "留言内容不能为空！"
		return
	}

	//itemToken, err := services.WxGetToken()
	//if err != nil {
	//	br.Msg = "GetWxAccessToken Err:" + err.Error()
	//	return
	//}
	//if itemToken.AccessToken == "" {
	//	br.Msg = "accessToken is empty"
	//	return
	//}
	//commerr, err := weapp.MSGSecCheck(itemToken.AccessToken, content)
	//if err != nil {
	//	br.Msg = "内容校验失败！"
	//	br.ErrMsg = "内容校验失败，Err:" + err.Error()
	//	return
	//}
	//if commerr.ErrCode != 0 {
	//	br.Msg = "内容违规,请重新提交！"
	//	br.ErrMsg = "内容违规，Err:" + commerr.ErrMSG
	//	return
	//}

	articleId := req.ArticleId
	articleInfo, errInfo := models.GetArticleDetailById(articleId)
	if articleInfo == nil {
		br.Msg = "操作失败"
		br.ErrMsg = "文章ID错误,不存在articleId：" + strconv.Itoa(articleId)
		return
	}
	if errInfo != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "操作失败,Err:" + errInfo.Error()
		return
	}

	companyDetail, err := models.GetCompanyDetailById(user.CompanyId)
	if err != nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "获取客户详情失败，Err:" + err.Error()
		return
	}
	if companyDetail == nil {
		br.Msg = "提交失败！"
		br.ErrMsg = "客户不存在，uid:" + strconv.Itoa(user.UserId)
		return
	}
	item := models.CygxArticleComment{
		UserId:      user.UserId,
		ArticleId:   req.ArticleId,
		CreateTime:  time.Now(),
		Mobile:      user.Mobile,
		Email:       user.Email,
		CompanyId:   user.CompanyId,
		CompanyName: companyDetail.CompanyName,
		Content:     content,
		Title:       articleInfo.Title,
	}
	_, err = models.AddArticleComment(&item)
	if err != nil {
		br.Msg = "提交失败"
		br.ErrMsg = "提交留言失败,Err:" + err.Error()
		return
	}
	services.SendCommentWxTemplateMsg(req, user, articleInfo)
	br.Ret = 200
	br.Success = true
	br.Msg = "提交成功"
}