hongze_cygx/services/industrial_management.go

package services

import (
	"context"
	"errors"
	"fmt"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/utils"
	"strconv"
	"strings"
	"time"
)

// 修改标签状态
func UpdateIndustrialManagementLabel(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println("修改失败，Err:", err.Error())
		}
	}()
	fmt.Println("修改状态0000")
	go models.UpdateIndustrialIsNewLabel()

	list, err := models.GetIndustrialMorethan10()
	if err != nil {
		return err
	}
	if len(list) == 0 {
		return
	}
	var idStr string
	for _, v := range list {
		idStr += v.IndustrialManagementId + ","
	}
	idStr = strings.TrimRight(idStr, ",")

	go models.UpdateIndustrialIsDeepLabel(idStr)
	//fmt.Println(idStr)
	//go models.UpdateActivitySattusToComplete()
	fmt.Println("修改状态完成")
	return
}

// 修改活动状态
func UpdateIndustrialManagementSubjectNnames() (err error) {
	defer func() {
		if err != nil {
			fmt.Println("修改失败，Err:", err.Error())
		}
	}()
	fmt.Println("修改产业关联标的")
	list, err := models.GetIndustrialManagementIds()
	if err != nil {
		return err
	}
	for _, v := range list {
		//fmt.Println(v.IndustrialManagementId)
		var nameSub string
		listSub, errdSub := models.GetcygxIndustrialSubject(v.IndustrialManagementId)
		if errdSub != nil {
			return errdSub
		}
		for _, v2 := range listSub {
			fmt.Println(v2.SubjectName)
			nameSub += v2.SubjectName + ","
		}
		nameSub += v.IndustryName
		go models.UpdateIndustrialManagementSubjectNames(nameSub, v.IndustrialManagementId)

	}
	if len(list) == 0 {
		return
	}

	fmt.Println("修改状态完成")
	return
}

func ChageIndustrialArticleNum(cont context.Context) (err error) {
	IndustrialHzArticleNumUpdate()
	IndustrialYxArticleNumUpdate()
	IndustrialActivityNumUpdate()
	return
}

//func init() {
//	IndustrialHzArticleNumUpdate()
//	IndustrialYxArticleNumUpdate()
//	IndustrialActivityNumUpdate()
//}

// 更改弘则对应的报告关联产业近一个月的阅读量
func IndustrialHzArticleNumUpdate() (err error) {
	defer func() {
		if err != nil {
			//fmt.Println(err)
			go utils.SendAlarmMsg("更改弘则对应的报告关联产业近一个月的阅读量失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"更改弘则对应的报告关联产业近一个月的阅读量失败失败提醒", err.Error(), utils.EmailSendToUsers)
		}
	}()

	err = models.UpdateIndustrialManagementArtticleReadNum()
	if err != nil {
		return
	}
	articleTypeIds, err := GetYanXuanArticleTypeIds()
	if err != nil {
		return
	}
	var condition string
	if articleTypeIds == "" {
		return
	}
	condition = ` AND a.article_type_id NOT  IN (` + articleTypeIds + `)  `
	list, err := models.GetIndustrialManagementArtHistoryCount(condition)
	if err != nil {
		return
	}
	for _, v := range list {
		err = models.UpdateIndustrialManagementArtReadNum(v.Count, v.IndustrialManagementId)
		if err != nil {
			return
		}
	}
	return err
}

// 更改研选对应的报告关联产业近一个月的阅读量
func IndustrialYxArticleNumUpdate() (err error) {
	defer func() {
		if err != nil {
			//fmt.Println(err)
			go utils.SendAlarmMsg("更改研选对应的报告关联产业近一个月的阅读量失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"更改研选对应的报告关联产业近一个月的阅读量失败提醒", err.Error(), utils.EmailSendToUsers)
		}
	}()

	articleTypeIds, err := GetYanXuanArticleTypeIds()
	if err != nil {
		return
	}
	var condition string
	if articleTypeIds == "" {
		return
	}
	condition = ` AND a.article_type_id   IN (` + articleTypeIds + `)  `
	list, err := models.GetIndustrialManagementArtHistoryCount(condition)
	if err != nil {
		return
	}
	for _, v := range list {
		err = models.UpdateIndustrialManagementArtYanXuanReadNum(v.Count, v.IndustrialManagementId)
		if err != nil {
			return
		}
	}
	return err
}

// 更改活动关联产业近一个月的到会量
func IndustrialActivityNumUpdate() (err error) {
	defer func() {
		if err != nil {
			//fmt.Println(err)
			go utils.SendAlarmMsg("更改活动关联产业近一个月的到会量失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"更改活动关联产业近一个月的到会量失败", err.Error(), utils.EmailSendToUsers)
		}
	}()

	list, err := models.GetIndustrialManagementActivityHistoryCount()
	if err != nil {
		return
	}
	for _, v := range list {
		err = models.UpdateIndustrialManagementActivityNum(v.Count, v.IndustrialManagementId)
		if err != nil {
			return
		}
	}
	return err
}

func ReportBillboardUpdate(cont context.Context) (err error) {
	//修改产业关注数量
	go IndustryFllowCountUpdate()

	//修改文章收藏数量
	go ArticleCollectCountUpdate()
	return
}

// 修改产业关注数量
func IndustryFllowCountUpdate() (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("修改产业关注数量信息失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "GetCeLueArticlePv ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	fllowList, err := models.GetUserFllowIndustrialCountList()
	if err != nil {
		return
	}
	for _, v := range fllowList {
		err = models.UpdateIndustrialManagementFllowNum(v.Num, v.IndustrialManagementId)
		if err != nil {
			return
		}
	}
	return err
}

// 修改文章收藏数量
func ArticleCollectCountUpdate() (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("修改文章收藏数量信息失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "修改文章收藏数量信息失败 ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	collectList, err := models.GetUserArticleCollectList()
	if err != nil {
		return
	}
	for _, v := range collectList {
		err = models.UpdateArticleCollectCountNum(v.Num, v.ArticleId)
		if err != nil {
			return
		}
	}
	return err
}

// 根据行业处理所选的全部赛道字段
func DoXzsChooseSend(chartPermissionName string) string {
	var allIn string
	if chartPermissionName == utils.YI_YAO_NAME {
		allIn = "all_in_yi_yao"
	} else if chartPermissionName == utils.XIAO_FEI_NAME {
		allIn = "all_in_xiao_fei"
	} else if chartPermissionName == utils.KE_JI_NAME {
		allIn = "all_in_ke_ji"
	} else if chartPermissionName == utils.ZHI_ZAO_NAME {
		allIn = "all_in_zhi_zao"
	} else if chartPermissionName == utils.CHART_PERMISSION_NAME_MF_YANXUAN {
		allIn = "all_in_yan_xuan"
	}
	return allIn
}

// 行业关注或者取消关注的时候，对于用户全部赛道的影响
func IndustryFllowWithTrack(industrialManagementId, count, uid int) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go utils.SendAlarmMsg("修改行业关注或者取消关注的时候，对于用户全部赛道的影响信息失败"+err.Error(), 2)
			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "修改行业关注或者取消关注的时候，对于用户全部赛道的影响信息失败 ErrMsg:"+err.Error(), utils.EmailSendToUsers)
		}
	}()
	detail, err := models.GetIndustrialManagementDetail(industrialManagementId)
	if err != nil {
		return err
	}
	categoryinfo, err := models.GetChartPermissionById(detail.ChartPermissionId)
	if err != nil {
		return err
	}
	var allIn string
	allIn = DoXzsChooseSend(categoryinfo.PermissionName)
	if allIn != "" {
		//如果取消关注就把该赛道设置为非全部赛道
		if count == 1 {
			err = models.UpdateCygxXzsChooseSendIsAllIn(allIn, 0, uid)
			if err != nil {
				return err
			}
		} else {
			//医药、消费、科技、智造、研选下的产业赛道
			mapIndustrial := make(map[int][]*models.IndustrialManagementRep)
			industrialList, err := models.GetindustrialManagement()
			if err != nil {
				return err
			}
			for _, v := range industrialList {
				mapIndustrial[v.ChartPermissionId] = append(mapIndustrial[v.ChartPermissionId], v)
			}
			fllowNum, err := models.GetCountCygxIndustryFllowByUidAndChartPermissionId(uid, detail.ChartPermissionId)
			if err != nil {
				return err
			}
			if fllowNum == len(mapIndustrial[detail.ChartPermissionId]) {
				err = models.UpdateCygxXzsChooseSendIsAllIn(allIn, 1, uid)
				if err != nil {
					return err
				}
			}
		}
	}
	return err
}

func init() {
	//IndustryFllowUserLabel(136, 16, 5660)
	//UserLabelLogReduce()
}

// 1：文章阅读、 2产业关注、3：活动到会、4系列关注、5专项调研活动到会。
func IndustryFllowUserLabelLogAdd(industrialManagementId, count, uid int) (err error) {
	var isFllow int
	if count == 0 {
		isFllow = 1
	} else {
		isFllow = 0
	}
	defer func() {
		if err != nil {
			fmt.Println(err)
			msg := fmt.Sprint("industrialManagementId:", industrialManagementId, "isFllow:", isFllow, "userId:", uid)
			go utils.SendAlarmMsg("用户关注产业更新相关标签，写入Redis队列消息失败："+err.Error()+msg, 2)
		}
	}()
	log := &models.CygxUserLabelLogRedis{UserId: uid, SourceId: industrialManagementId, SourceType: 2, IsFllow: isFllow, CreateTime: time.Now()}
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CYGX_USER_KEY_LABEL, log)
		if err != nil {
			fmt.Println("RecordNewLogs LPush Err:" + err.Error())
		}
	}
	return
}

// GetIndustryNewLabelMap 获取产业【新】标签Map
func GetIndustryNewLabelMap(industryIds []int) (labelMap map[int]bool, err error) {
	labelMap = make(map[int]bool, 0)
	industryIdLen := len(industryIds)
	if industryIdLen == 0 {
		return
	}

	// 获取产业关联的报告最早发布时间及最近的发布时间
	var timeCond string
	var timePars []interface{}
	timeCond += ` AND b.publish_status = 1`
	if industryIdLen > 0 {
		timeCond += ` AND a.industrial_management_id IN (` + utils.GetOrmInReplace(industryIdLen) + `)`
		timePars = append(timePars, industryIds)
	}
	//只要弘则报告，不要研选报告
	timeCond += ` AND b.article_id < ? `
	timePars = append(timePars, utils.SummaryArticleId)

	industryTimeList, e := models.GetIndustryArticleMinMaxPublishTime(timeCond, timePars)
	if e != nil {
		err = errors.New("获取产业文章最大最小发布时间失败, Err: " + e.Error())
		return
	}

	// 判断产业是否为新
	nowTime := time.Now().Local()
	threeMonthBefore := nowTime.AddDate(0, -3, 0)
	nullTime, _ := time.ParseInLocation(utils.FormatDateTime, "0001-01-01 00:00:00", time.Local)
	industryMap := make(map[int]*models.IndustryArticleMinMaxPublishTime, 0)
	for i := range industryTimeList {
		industryMap[industryTimeList[i].IndustrialManagementId] = industryTimeList[i]
	}
	for i := range industryIds {
		iid := industryIds[i]
		item := industryMap[iid]
		if item != nil {
			// 最早发布时间为空 / 最早发布时间在三个月前之后
			if item.MinPublishTime.Equal(nullTime) || (item.MinPublishTime.After(threeMonthBefore)) {
				labelMap[iid] = true
			}
		} else {
			// 产业无报告, 则为新产业
			labelMap[iid] = true
		}
	}
	return
}

//func init() {
//	GetIndustrialManagementArticleNewPublishData()
//}

// 批量修改获取产业关联文章的最新发布时间
func GetIndustrialManagementArticleNewPublishData() (err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("批量修改获取产业关联文章的最新发布时间"+"GetIndustrialManagementArticleNewPublishData ErrMsg:"+err.Error(), 2)

		}
	}()
	articleNewPublishDataList, e := models.GetIndustrialManagementArticleNewPublishData()
	if e != nil {
		err = errors.New("获取客户剩余报名次数失败 GetIndustrialManagementArticleNewPublishData, Err: " + e.Error())
		return
	}
	mapUPdateTime := make(map[int]string)
	var industrialManagementIds []int
	for _, v := range articleNewPublishDataList {
		if v.IndustrialManagementId > 0 {
			industrialManagementIds = append(industrialManagementIds, v.IndustrialManagementId)
		}
		mapUPdateTime[v.IndustrialManagementId] = v.UpdateTime
	}
	//时间线的更新时间
	listtimelinePublishdate, err := models.GetTimeLineReportIndustrialPublishdateList(industrialManagementIds)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	for _, v := range listtimelinePublishdate {
		if mapUPdateTime[v.IndustrialManagementId] != "" {
			if utils.StrTimeToTime(v.PublishDate).After(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
				mapUPdateTime[v.IndustrialManagementId] = v.PublishDate
			}
		}
	}
	err = models.UpdateIndustrialManagementArticleNewPublishData(mapUPdateTime)
	return
}

// HandleIndustryList预处理产业列表字段
func HandleIndustryList(list []*models.IndustrialManagement, user *models.WxUserItem) (items []*models.IndustrialManagement, err error) {
	userId := user.UserId
	fllowList, err := models.GetUserFllowIndustrialList(userId)
	if err != nil {
		return
	}
	fllowMap := make(map[int]int)
	if len(fllowList) > 0 {
		for _, v := range fllowList {
			fllowMap[v.IndustrialManagementId] = v.IndustrialManagementId
		}
	}
	mapindustrialId, e := GetMicroRoadshowVideoMap()
	if e != nil {
		err = e
		return
	}
	//合并产业关联的标的
	listSubjcet, err := models.GetThemeHeatSubjectList("")
	if err != nil {
		return
	}
	industrialIdArr := make([]int, 0)
	for k, v := range list {
		list[k].Source = 1
		if fllowMap[v.IndustrialManagementId] > 0 {
			list[k].IsFollow = 1
		}
		industrialIdArr = append(industrialIdArr, v.IndustrialManagementId)
		if _, ok := mapindustrialId[v.IndustrialManagementId]; !ok {
			continue
		}
		videoSimple, au, e := GetindustryVideo(user, v.IndustrialManagementId)
		if e != nil {
			err = errors.New("获取产业关联的视频失败，GetindustryVideo " + e.Error())
			return
		}
		if videoSimple != nil && videoSimple.Id > 0 {
			v.IndustryVideo = videoSimple
		}
		v.AuthInfo = au
	}

	if len(industrialIdArr) > 0 {
		//合并产业关联的标的
		listSubjcet, err = models.GetIndustrialSubjectAllByIndustrialId(industrialIdArr)
		if err != nil {
			return
		}
		mapIndustrial := make(map[string]int)
		for _, v := range listSubjcet {
			for k2, v2 := range list {
				if v2.IndustrialManagementId == v.IndustrialManagementId && mapIndustrial[fmt.Sprint(v2.IndustrialManagementId, "Hz", v.SubjectName)] == 0 {
					list[k2].IndustrialSubjectList = append(list[k2].IndustrialSubjectList, v)
					mapIndustrial[fmt.Sprint(v2.IndustrialManagementId, "Hz", v.SubjectName)] = v2.IndustrialManagementId
				}
			}
		}
	}
	mapUPdateTime := make(map[int]string)
	articleIdArr := make([]int, 0)
	//获取这些产业下最新更新的文章

	listUpdateTime, err := models.GetNewArticleDetailByIndustrialIds(industrialIdArr)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	for _, v := range listUpdateTime {
		mapUPdateTime[v.IndustrialManagementId] = v.PublishDate
		articleIdArr = append(articleIdArr, v.ArticleId)
	}

	//时间线的更新时间
	//	maptimelineUPdateTime := make(map[int]string)
	listtimelinePublishdate, err := models.GetTimeLineReportIndustrialPublishdateList(industrialIdArr)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	for _, v := range listtimelinePublishdate {
		if mapUPdateTime[v.IndustrialManagementId] != "" {
			if utils.StrTimeToTime(v.PublishDate).After(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
				mapUPdateTime[v.IndustrialManagementId] = v.PublishDate
			}
		}
	}

	//产品内测的更新时间线
	listtProductInterior, err := models.GetNewProductInteriorByIndustrialIds(industrialIdArr)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	for _, v := range listtProductInterior {
		if mapUPdateTime[v.IndustrialManagementId] != "" {
			if utils.StrTimeToTime(v.PublishDate).After(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
				mapUPdateTime[v.IndustrialManagementId] = v.PublishDate
			}
		}
	}

	//mapHistroyArticleId := make(map[int]int)

	//if userId > 0 {
	//	listArticleHistory, e := models.GetUserToArticleHistory(userId, articleIdArr)
	//	if e != nil && e.Error() != utils.ErrNoRow() {
	//		err = errors.New("获取产业关联的视频失败，GetindustryVideo " + e.Error())
	//		return
	//	}
	//	for _, v := range listArticleHistory {
	//		mapHistroyArticleId[v.ArticleId] = v.ArticleId
	//	}
	//}
	var industrialIds string
	for _, id := range industrialIdArr {
		industrialIds += strconv.Itoa(id) + ","
	}
	industrialIds = strings.TrimRight(industrialIds, ",")
	articleList, err := models.GetReportIndustrialReadNumList(userId, industrialIds, user.CreatedTime)
	mapHistroyindustrialId := make(map[int]int)
	for _, v := range articleList {
		mapHistroyindustrialId[v.IndustrialManagementId] = v.Readnum
	}
	nowTime := time.Now().Local()
	threeMonBefore := nowTime.AddDate(0, -3, 0)

	//查询用户今天是否看过时间线
	//haveMorningMeeting := false
	//var morningMeetingTime string
	recrodList, err := models.GetTimeLineRecordAllCount(user.UserId, time.Now().Format(utils.FormatDate))
	if err != nil {
		return
	}
	var industrialManagementIdstr string
	industrialIdMap := make(map[string]time.Time)
	for _, v := range recrodList {
		industrialManagementIdstr = strings.TrimLeft(v.Parameter, "PageSize=10&CurrentIndex=1&CategoryId=99999&IndustrialManagementId=")
		if createTime, ok := industrialIdMap[industrialManagementIdstr]; ok {
			if createTime.Before(v.CreateTime) {
				industrialIdMap[industrialManagementIdstr] = v.CreateTime
			}
		} else {
			industrialIdMap[industrialManagementIdstr] = v.CreateTime
		}
	}

	mmList, err := models.GetCygxMorningMeetingReviewsListByIndustrialIds(industrialIds)
	if err != nil {
		return
	}
	morningMeetingTimeMap := make(map[int]time.Time)
	for _, v := range mmList {
		morningMeetingTimeMap[v.IndustryId] = v.CreateTime
	}
	timeLineRedMap := make(map[int]bool, 0)

	for _, industrialId := range industrialIdArr {
		if createTime, ok := industrialIdMap[strconv.Itoa(industrialId)]; ok {
			if createTime.Before(morningMeetingTimeMap[industrialId]) {
				timeLineRedMap[industrialId] = true
			}
		}
	}

	for k, v := range list {
		list[k].UpdateTime = utils.TimeRemoveHms(mapUPdateTime[v.IndustrialManagementId])
		if userId > 0 {
			//如果文章没有阅读，而且，文章的发布时间晚于项目的上线时间，而且文章的发布时间晚于用户的注册时间，就进行标红处理
			if mapHistroyindustrialId[v.IndustrialManagementId] == 0 || timeLineRedMap[v.IndustrialManagementId] {
				if user.CreatedTime.Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
					list[k].IsRed = true
				}
			}
		} else {
			if utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
				list[k].IsRed = true
			}
			list[k].IsFollow = 0
		}

		list[k].UpdateTime = utils.TimeRemoveHms(mapUPdateTime[v.IndustrialManagementId])
		if userId > 0 {
			//如果文章没有阅读，而且，文章的发布时间晚于项目的上线时间，而且文章的发布时间晚于用户的注册时间，就进行标红处理
			if mapHistroyindustrialId[v.IndustrialManagementId] == 0 || timeLineRedMap[v.IndustrialManagementId] {
				if user.CreatedTime.Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) && utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
					list[k].IsRed = true
				}
			}
		} else {
			if utils.StrTimeToTime(utils.OnlineTime).Before(utils.StrTimeToTime(mapUPdateTime[v.IndustrialManagementId])) {
				list[k].IsRed = true
			}
			list[k].IsFollow = 0
		}

		// 关联报告发布时间均在3个月内则标记New
		if v.MinReportTime != "" {
			t, e := time.Parse(utils.FormatDateTime, v.MinReportTime)
			if e != nil {
				err = errors.New("报告最早发布时间有误，GetindustryVideo " + e.Error())
				return
			}
			if t.After(threeMonBefore) {
				list[k].IsNew = true
			}
		}
	}
	items = list
	return
}

// 通过文章ID获取文章所关联的产业
func GetArticleIndustrialByArticleId(articleIds []int) (itemMap map[int][]*models.IndustrialManagementResp, err error) {
	lenarticleIds := len(articleIds)
	if lenarticleIds == 0 {
		return
	}
	var condition string
	var pars []interface{}
	condition = ` AND mg.article_id IN (` + utils.GetOrmInReplace(lenarticleIds) + `)`
	pars = append(pars, articleIds)
	industrialList, err := models.GetIndustrialListByarticleId(pars, condition)
	if err != nil {
		return
	}
	industrialMap := make(map[int][]*models.IndustrialManagementResp)
	if len(industrialList) > 0 {
		for _, v := range industrialList {
			item := new(models.IndustrialManagementResp)
			item.IndustrialManagementId = v.IndustrialManagementId
			item.IndustryName = v.IndustryName
			item.ChartPermissionId = v.ChartPermissionId
			industrialMap[v.ArticleId] = append(industrialMap[v.ArticleId], item)
		}
	}
	itemMap = industrialMap
	return
}

func GetArticleTypeMap() (nameMapResp map[int]string, buttonStyleMapResp map[int]string, err error) {
	condition := " AND is_show_yanx  = 1 "
	list, e := models.GetCygxArticleTypeListCondition(condition)
	if e != nil {
		err = errors.New("报告最早发布时间有误，GetindustryVideo " + e.Error())
		return
	}
	nameMap := make(map[int]string)
	buttonStyleMap := make(map[int]string)
	if len(list) > 0 {
		for _, v := range list {
			nameMap[v.ArticleTypeId] = v.ArticleTypeName
			buttonStyleMap[v.ArticleTypeId] = v.ButtonStyle
		}
	}
	nameMapResp = nameMap
	buttonStyleMapResp = buttonStyleMap
	return
}

// IndustrialManagementHotMapGropuPermission获取近一个月报告阅读数量最多的产业信息 根据行业分组
func IndustrialManagementHotMapGropuPermission() (mapResp map[int]bool, err error) {
	var topCond string
	var topPars []interface{}
	toplist, err := models.GetTopOneMonthArtReadNumIndustryAll(topCond, topPars)
	if err != nil {
		return
	}
	mapPermission := make(map[int][]*models.IndustrialManagement)
	mapPermissionMax := make(map[int]int)

	for _, v := range toplist {
		item := new(models.IndustrialManagement)
		item.ChartPermissionId = v.ChartPermissionId
		item.IndustrialManagementId = v.IndustrialManagementId
		item.ArticleReadNum = v.ArticleReadNum
		mapPermission[v.ChartPermissionId] = append(mapPermission[v.ChartPermissionId], item)
	}
	for k, v := range mapPermission {
		for _, item := range v {
			//mapPermissionMax[k] = item.ArticleReadNum
			if item.ArticleReadNum > mapPermissionMax[k] {
				mapPermissionMax[k] = item.ArticleReadNum
			}
		}
	}

	mapResp = make(map[int]bool, 0)
	for _, v := range toplist {
		if v.ArticleReadNum == mapPermissionMax[v.ChartPermissionId] {
			mapResp[v.IndustrialManagementId] = true
		}
	}
	return
}

// GetLyjhTypeMap 获取路演精华对应分类ID
func GetLyjhTypeMap() (mapResp map[int]int, err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("获取路演精华对应分类ID失败 ErrMsg:"+err.Error(), 2)

		}
	}()
	condition := " AND match_type_name = '路演精华'  "
	var pars []interface{}
	list, e := models.GetReportMappingList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("报告最早发布时间有误，GetindustryVideo " + e.Error())
		return
	}
	mapResp = make(map[int]int, 0)
	if len(list) > 0 {
		for _, v := range list {
			mapResp[v.CategoryId] = v.CategoryId
		}
	}
	return
}

// GetLyjhArticleMap 获取路演精华对应文章ID
func GetLyjhArticleMap() (mapResp map[int]bool, err error) {
	defer func() {
		if err != nil {
			go utils.SendAlarmMsg("获取路演精华对应文章ID失败 ErrMsg:"+err.Error(), 2)
		}
	}()
	condition := " AND match_type_name = '路演精华'  "
	var pars []interface{}
	list, e := models.GetReportMappingList(condition, pars)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("报告最早发布时间有误，GetindustryVideo " + e.Error())
		return
	}
	var categoryId []int
	mapResp = make(map[int]bool, 0)
	if len(list) > 0 {
		for _, v := range list {
			categoryId = append(categoryId, v.CategoryId)
		}
	}
	lencategoryId := len(categoryId)
	if lencategoryId > 0 {
		pars = make([]interface{}, 0)
		condition = ` AND a.category_id IN (` + utils.GetOrmInReplace(lencategoryId) + `)`
		pars = append(pars, categoryId)
		listArticle, e := models.GetHomeList(condition, pars, 0, 1000)
		if e != nil && e.Error() != utils.ErrNoRow() {
			err = errors.New("GetResourceDataList, Err: " + e.Error())
			return
		}
		for _, v := range listArticle {
			mapResp[v.ArticleId] = true
		}
	}
	return
}