fix:创建章节报告时，自动关联配置中的品种

controllers/report.go

@@ -73,17 +73,8 @@ func (this *ReportController) PublishReport() {
 			br.ErrMsg = "参数错误,Err:" + err.Error()
 			return
 		}
-		report, err := models.GetReportById(vint)
-		if err != nil {
-			br.Msg = "获取报告信息失败"
-			br.ErrMsg = "获取报告信息失败,Err:" + err.Error()
-			return
-		}
-		if report == nil {
-			br.Msg = "报告不存在"
-			return
-		}
 
+		// 报告的图表刷新状态校验
 		refreshResult := data.CheckBatchChartRefreshResult("report", vint, 0)
 		if !refreshResult {
 			br.Msg = "图表刷新未完成，请稍后操作"
@@ -92,81 +83,14 @@ func (this *ReportController) PublishReport() {
 			return
 		}
 
-		var publishTime time.Time
-		if report.MsgIsSend == 1 && report.PublishTime != "" { //如果报告曾经发布过，并且已经发送过模版消息，则章节的发布时间为报告的发布时间
-			publishTime, _ = time.ParseInLocation(utils.FormatDateTime, report.PublishTime, time.Local)
-		} else {
-			publishTime = time.Now()
-		}
-		var tmpErr error
-		if report.HasChapter == 1 && (report.ChapterType == utils.REPORT_TYPE_DAY || report.ChapterType == utils.REPORT_TYPE_WEEK) {
-			// 发布晨周报
-			if tips, tmpErr = services.PublishDayWeekReport(vint); tmpErr != nil {
-				br.Msg = "报告发布失败"
-				br.ErrMsg = "晨周报发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
-				return
-			}
-		} else {
-			if report.Content == "" {
-				br.Msg = "报告内容为空，不可发布"
-				br.ErrMsg = "报告内容为空，不需要生成,report_id:" + strconv.Itoa(report.Id)
-				return
-			}
-
-			// 根据审批开关及审批流判断当前报告状态
-			state, e := services.CheckReportCurrState(report_approve.FlowReportTypeChinese, report.ClassifyIdFirst, report.ClassifyIdSecond, report.ClassifyIdThird, models.ReportOperatePublish)
-			if e != nil {
-				br.Msg = "操作失败"
-				br.ErrMsg = "校验报告当前状态失败, Err: " + e.Error()
-				return
-			}
-
-			if state == models.ReportStatePublished {
-				// 发布报告
-				if tmpErr = models.PublishReportById(report.Id, publishTime); tmpErr != nil {
-					br.Msg = "报告发布失败"
-					br.ErrMsg = "报告发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(report.Id)
-					return
-				}
-				go func() {
-					// 生成音频
-					if report.VideoUrl == "" {
-						_ = services.CreateVideo(report)
-					}
-					//// 推送找钢网
-					//if utils.RunMode == "release" && (report.ClassifyNameSecond == "知白守黑日评" || report.ClassifyNameSecond == "股债日评") {
-					//	_ = services.ZhaoGangSend(report)
-					//}
-					// 更新报告Es
-					_ = services.UpdateReportEs(report.Id, 2)
-				}()
-			} else {
-				// 从无审批切换为有审批, 状态重置
-				if e = models.ResetReportById(report.Id, state); tmpErr != nil {
-					br.Msg = "操作失败"
-					br.ErrMsg = fmt.Sprintf("重置报告状态失败, Err: %s, ReportId: %d", e.Error(), report.Id)
-					return
-				}
-			}
-
-			recordItem := &models.ReportStateRecord{
-				ReportId:   vint,
-				ReportType: 1,
-				State:      state,
-				AdminId:    this.SysUser.AdminId,
-				AdminName:  this.SysUser.AdminName,
-				CreateTime: time.Now(),
-			}
-			go func() {
-				_, _ = models.AddReportStateRecord(recordItem)
-			}()
-
-			// 生成报告pdf和长图
-			if req.ReportUrl != "" {
-				go services.Report2pdfAndJpeg(req.ReportUrl, report.Id, 1)
-			}
+		// 报告发布
+		tmpTips, err, errMsg := services.PublishReport(vint, req.ReportUrl, this.SysUser)
+		if err != nil {
+			br.Msg = errMsg
+			br.ErrMsg = "报告发布失败,Err:" + err.Error()
+			return
 		}
-
+		tips = tmpTips
 	}
 	// 发布晨周报部分章节未发布的提示
 	if tips != "" {

controllers/report_approve/report_approve.go

@@ -940,42 +940,3 @@ func (this *ReportApproveController) CheckApproveOpen() {
 	br.Success = true
 	br.Msg = "操作成功"
 }
-
-func init() {
-	//fixApproveRecord()
-}
-func fixApproveRecord() {
-	recordOb := new(report_approve.ReportApproveRecord)
-
-	recordCond := fmt.Sprintf(` AND %s = ? AND %s in (?,?)`, report_approve.ReportApproveRecordCols.NodeType, report_approve.ReportApproveRecordCols.State)
-	recordPars := make([]interface{}, 0)
-	recordPars = append(recordPars, 0, report_approve.ReportApproveStatePass, report_approve.ReportApproveStateRefuse)
-	list, e := recordOb.GetItemsByCondition(recordCond, recordPars, []string{}, "")
-	if e != nil {
-		fmt.Println("查找审批记录失败，Err:", e.Error())
-		return
-	}
-	for _, recordItem := range list {
-		//fmt.Println(recordItem)
-		recordItem.NodeState = report_approve.ReportApproveStatePass
-		recordItem.NodeApproveUserId = recordItem.ApproveUserId
-		recordItem.NodeApproveUserName = recordItem.ApproveUserName
-		recordItem.NodeApproveTime = recordItem.ApproveTime
-
-		// 如果不是或签，那么只需要修复自己就好了
-		if recordItem.ApproveType != report_approve.NodeApproveTypeAny {
-			recordCols := []string{"State", "ApproveTime", "ModifyTime", "NodeState", "NodeApproveUserId", "NodeApproveUserName", "NodeApproveTime"}
-			if e = recordItem.Update(recordCols); e != nil {
-				fmt.Println("更新审批记录状态失败，Err：", e.Error())
-			}
-			continue
-		}
-		// 或签
-		// 需要将该审批的同一个节点的记录标记为已审批
-		if e := recordItem.UpdateNodeState(recordItem.ReportApproveId, recordItem.NodeId, recordItem.NodeState, recordItem.NodeApproveUserId, recordItem.NodeApproveUserName, recordItem.NodeApproveTime); e != nil {
-			fmt.Println("更新同一节点的其他审批记录状态失败，Err：", e.Error())
-		}
-	}
-
-	fmt.Println("审批数据修复完成")
-}

controllers/report_v2.go

@@ -9,6 +9,7 @@ import (
 	"eta/eta_api/services"
 	"eta/eta_api/services/alarm_msg"
 	"eta/eta_api/utils"
+	"fmt"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"html"
 	"strconv"
@@ -1092,4 +1093,46 @@ func (this *ReportController) EditLayoutImg() {
 	br.Data = resp
 }
 
-// TODO 报告发布后，图片和pdf的生成
+// TODO 修复历史章节报告的品种权限
+// TODO 修复历史报告的ES数据
+
+func init() {
+	//fixApproveRecord()
+}
+
+// 修复研报审批数据
+func fixApproveRecord() {
+	recordOb := new(report_approve.ReportApproveRecord)
+
+	recordCond := fmt.Sprintf(` AND %s = ? AND %s in (?,?)`, report_approve.ReportApproveRecordCols.NodeType, report_approve.ReportApproveRecordCols.State)
+	recordPars := make([]interface{}, 0)
+	recordPars = append(recordPars, 0, report_approve.ReportApproveStatePass, report_approve.ReportApproveStateRefuse)
+	list, e := recordOb.GetItemsByCondition(recordCond, recordPars, []string{}, "")
+	if e != nil {
+		fmt.Println("查找审批记录失败，Err:", e.Error())
+		return
+	}
+	for _, recordItem := range list {
+		//fmt.Println(recordItem)
+		recordItem.NodeState = report_approve.ReportApproveStatePass
+		recordItem.NodeApproveUserId = recordItem.ApproveUserId
+		recordItem.NodeApproveUserName = recordItem.ApproveUserName
+		recordItem.NodeApproveTime = recordItem.ApproveTime
+
+		// 如果不是或签，那么只需要修复自己就好了
+		if recordItem.ApproveType != report_approve.NodeApproveTypeAny {
+			recordCols := []string{"State", "ApproveTime", "ModifyTime", "NodeState", "NodeApproveUserId", "NodeApproveUserName", "NodeApproveTime"}
+			if e = recordItem.Update(recordCols); e != nil {
+				fmt.Println("更新审批记录状态失败，Err：", e.Error())
+			}
+			continue
+		}
+		// 或签
+		// 需要将该审批的同一个节点的记录标记为已审批
+		if e := recordItem.UpdateNodeState(recordItem.ReportApproveId, recordItem.NodeId, recordItem.NodeState, recordItem.NodeApproveUserId, recordItem.NodeApproveUserName, recordItem.NodeApproveTime); e != nil {
+			fmt.Println("更新同一节点的其他审批记录状态失败，Err：", e.Error())
+		}
+	}
+
+	fmt.Println("审批数据修复完成")
+}

models/report/report_chapter_permission_mapping.go

@@ -71,6 +71,33 @@ func (m ReportChapterPermissionMapping) GetPermissionListById(reportChapterId in
 	return
 }
 
+// ReportChapterPermissionItem
+// @Description: 报告章节的权限关系表（带有品种名称）
+type ReportChapterPermissionItem struct {
+	ReportChapterPermissionMappingId int    `orm:"column(report_chapter_permission_mapping_id)"`
+	ReportChapterId                  int    `description:"报告章节的id"`
+	ChartPermissionId                int    `description:"权限id"`
+	ChartPermissionName              string `description:"品种名称"`
+	CreateTime                       time.Time
+}
+
+// GetPermissionItemListById
+// @Description: 根据id获取品种权限列表(带有品种名称）
+// @author: Roc
+// @receiver m
+// @datetime 2024-06-04 15:33:58
+// @param reportChapterId int
+// @return list []*ReportChapterPermissionMapping
+// @return err error
+func (m ReportChapterPermissionMapping) GetPermissionItemListById(reportChapterId int) (list []*ReportChapterPermissionItem, err error) {
+	o := orm.NewOrmUsingDB("rddp")
+	sql := `SELECT a.*,b.chart_permission_name FROM report_chapter_permission_mapping AS a 
+         JOIN chart_permission AS b on a.chart_permission_id=b.chart_permission_id WHERE report_chapter_id=? `
+	_, err = o.Raw(sql, reportChapterId).QueryRows(&list)
+
+	return
+}
+
 // GetPermissionListByIdList
 // @Description: 根据id列表获取品种权限列表
 // @author: Roc

models/report_chapter.go

@@ -389,8 +389,9 @@ func CountReportChapterByTypeId(typeId int) (count int, err error) {
 // AddReportChapter
 // @Description: 待添加的报告章节
 type AddReportChapter struct {
-	ReportChapter *ReportChapter
-	GrantList     []*report.ReportChapterGrant
+	ReportChapter       *ReportChapter
+	GrantList           []*report.ReportChapterGrant
+	GrantPermissionList []*report.ReportChapterPermissionMapping
 }
 
 // EditReportChapterBaseInfoAndPermissionReq

services/report.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"eta/eta_api/models"
 	"eta/eta_api/models/company"
+	"eta/eta_api/models/report"
 	"eta/eta_api/models/system"
 	"eta/eta_api/services/alarm_msg"
 	"eta/eta_api/services/public_api"
@@ -124,6 +125,7 @@ func PublishDayWeekReport(reportId int) (tips string, err error) {
 
 	// 发布时备份内容
 	go SaveReportLogs(report, chapters, report.AdminId, report.AdminRealName)
+
 	return
 }
 
@@ -232,39 +234,10 @@ func UpdateReportEs(reportId int, publishState int) (err error) {
 			return
 		}
 		if len(chapterList) > 0 {
-			for i := 0; i < len(chapterList); i++ {
-				// 章节对应的品种
-				permissionList, tmpErr := models.GetChapterTypePermissionByReportChapterTypeId(chapterList[i].TypeId)
-				if tmpErr != nil {
-					return
-				}
-				categoryArr := make([]string, 0)
-				if len(permissionList) > 0 {
-					for ii := 0; ii < len(permissionList); ii++ {
-						categoryArr = append(categoryArr, permissionList[ii].PermissionName)
-					}
-				}
-				aliasArr, _ := addCategoryAliasToArr(categoryArr)
-				chapterCategories := strings.Join(aliasArr, ",")
-
-				esChapter := &models.ElasticReportDetail{
-					ReportId:           chapterList[i].ReportId,
-					ReportChapterId:    chapterList[i].ReportChapterId,
-					Title:              chapterList[i].Title,
-					Abstract:           chapterList[i].Abstract,
-					BodyContent:        utils.TrimHtml(html.UnescapeString(chapterList[i].Content)),
-					PublishTime:        chapterList[i].PublishTime.Format(utils.FormatDateTime),
-					PublishState:       chapterList[i].PublishState,
-					Author:             chapterList[i].Author,
-					ClassifyIdFirst:    chapterList[i].ClassifyIdFirst,
-					ClassifyNameFirst:  chapterList[i].ClassifyNameFirst,
-					ClassifyIdSecond:   0,
-					ClassifyNameSecond: "",
-					Categories:         chapterCategories,
-					StageStr:           strconv.Itoa(chapterList[i].Stage),
-				}
-				chapterDocId := fmt.Sprintf("%d-%d", reportInfo.Id, chapterList[i].ReportChapterId)
-				if err = EsAddOrEditReport(utils.EsReportIndexName, chapterDocId, esChapter); err != nil {
+			// 更新章节的es数据
+			for _, chapterInfo := range chapterList {
+				err = updateReportChapterEsByChapter(chapterInfo)
+				if err != nil {
 					return
 				}
 			}
@@ -343,16 +316,13 @@ func addCategoryAliasToArr(categoryArr []string) (aliasArr []string, err error)
 	return
 }
 
-// UpdateReportChapterEs 更新报告章节ES
+// UpdateReportChapterEs
+// @Description: 通过章节id更新报告章节ES
+// @author: Roc
+// @datetime 2024-06-20 13:16:22
+// @param reportChapterId int
+// @return err error
 func UpdateReportChapterEs(reportChapterId int) (err error) {
-	// TODO 报告章节ES的权限控制
-	// TODO 弘则得单独处理晨报的权限
-	//if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
-	//	br.Ret = 200
-	//	br.Success = true
-	//	br.Msg = "操作成功"
-	//	return
-	//}
 	if reportChapterId <= 0 {
 		return
 	}
@@ -360,15 +330,39 @@ func UpdateReportChapterEs(reportChapterId int) (err error) {
 	if err != nil {
 		return
 	}
+
+	err = updateReportChapterEsByChapter(chapterInfo)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// updateReportChapterEsByChapter
+// @Description: 通过章节详情更新报告章节ES
+// @author: Roc
+// @datetime 2024-06-20 13:16:11
+// @param chapterInfo *models.ReportChapter
+// @return err error
+func updateReportChapterEsByChapter(chapterInfo *models.ReportChapter) (err error) {
+	// TODO 弘则得单独处理晨报的权限
+	//if utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeSandbox && utils.BusinessCode != utils.BusinessCodeDebug {
+	//	br.Ret = 200
+	//	br.Success = true
+	//	br.Msg = "操作成功"
+	//	return
+	//}
 	// 章节对应的品种
-	permissionList, tmpErr := models.GetChapterTypePermissionByReportChapterTypeId(chapterInfo.TypeId)
+	obj := report.ReportChapterPermissionMapping{}
+	permissionList, tmpErr := obj.GetPermissionItemListById(chapterInfo.ReportChapterId)
 	if tmpErr != nil {
 		return
 	}
 	categoryArr := make([]string, 0)
 	if len(permissionList) > 0 {
 		for ii := 0; ii < len(permissionList); ii++ {
-			categoryArr = append(categoryArr, permissionList[ii].PermissionName)
+			categoryArr = append(categoryArr, permissionList[ii].ChartPermissionName)
 		}
 	}
 	aliasArr, _ := addCategoryAliasToArr(categoryArr)

services/report_approve.go

@@ -829,7 +829,7 @@ func BuildNextNodeRecordAndMsg(approveNodeItem *report_approve.ReportApproveNode
 func AfterReportApprovePass(reportType, reportId int) (err error) {
 	// 中文研报
 	if reportType == report_approve.FlowReportTypeChinese {
-		report, e := models.GetReportById(reportId)
+		reportInfo, e := models.GetReportByReportId(reportId)
 		if e != nil {
 			if e.Error() == utils.ErrNoRow() {
 				return
@@ -837,8 +837,8 @@ func AfterReportApprovePass(reportType, reportId int) (err error) {
 			err = fmt.Errorf("获取研报信息失败, Err: %s", e.Error())
 			return
 		}
-		_ = CreateVideo(report)
-		_ = UpdateReportEs(report.Id, models.ReportStatePublished)
+		_ = CreateVideo(reportInfo)
+		_ = UpdateReportEs(reportInfo.Id, models.ReportStatePublished)
 
 		return
 	}

services/report_v2.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"eta/eta_api/models"
 	"eta/eta_api/models/report"
+	"eta/eta_api/models/report_approve"
 	"eta/eta_api/models/system"
 	"eta/eta_api/utils"
 	"fmt"
@@ -89,24 +90,8 @@ func AddReportAndChapter(reportInfo *models.Report, inheritReportId int, grantAd
 		go models.ModifyReportCode(reportId, reportCode)
 	}
 
-	// TODO 报告权限处理
-	//处理权限
-	//go func() {
-	//	permissionItems, e := models.GetPermission(req.ClassifyIdSecond)
-	//	if e != nil {
-	//		alarm_msg.SendAlarmMsg("获取权限失败，Err："+e.Error(), 3)
-	//		return
-	//	}
-	//	for _, v := range permissionItems {
-	//		e = models.AddChartPermissionChapterMapping(v.ChartPermissionId, int64(item.Id))
-	//		if e != nil {
-	//			alarm_msg.SendAlarmMsg("新增权限失败，Err："+e.Error(), 3)
-	//			return
-	//		}
-	//	}
-	//	// 同步crm权限
-	//	_ = EditReportPermissionSync(int64(item.Id), req.ClassifyIdSecond)
-	//}()
+	// 报告权限处理
+	go handleReportPermission(reportId, minClassifyId)
 
 	return
 }
@@ -237,29 +222,15 @@ func EditReport(reportInfo *models.Report, req models.EditReq, sysUser *system.A
 	if err != nil {
 		return
 	}
-	// TODO 权限处理
-	//处理权限
-	//go func() {
-	//	e := models.RemoveChartPermissionChapterMapping(req.ReportId)
-	//	if e != nil {
-	//		alarm_msg.SendAlarmMsg("修改删除报告权限失败，Err："+e.Error(), 3)
-	//		return
-	//	}
-	//	permissionItems, e := models.GetPermission(req.ClassifyIdSecond)
-	//	if e != nil {
-	//		alarm_msg.SendAlarmMsg("获取权限失败，Err："+e.Error(), 3)
-	//		return
-	//	}
-	//	for _, v := range permissionItems {
-	//		e = models.AddChartPermissionChapterMapping(v.ChartPermissionId, req.ReportId)
-	//		if e != nil {
-	//			alarm_msg.SendAlarmMsg("新增权限失败，Err："+e.Error(), 3)
-	//			return
-	//		}
-	//	}
-	//	// 同步crm权限
-	//	_ = services.EditReportPermissionSync(req.ReportId, req.ClassifyIdSecond)
-	//}()
+
+	// 报告权限处理
+	{
+		minClassifyId, tmpErr := getMinClassifyId(reportInfo)
+		if tmpErr != nil {
+			return
+		}
+		go handleReportPermission(int64(reportInfo.Id), minClassifyId)
+	}
 
 	return
 }
@@ -315,7 +286,9 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 	}
 
 	// 待添加的章节
-	typeList := make([]*models.ReportChapterType, 0)
+	chapterTypeList := make([]*models.ReportChapterType, 0)
+	// 待添加的章节类型id列表
+	chapterTypeIdList := make([]int, 0)
 
 	nowTime := time.Now().Local()
 	for _, chapterType := range allTypeList {
@@ -342,15 +315,42 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 		}
 
 		// 正常的章节类型状态，那么应该自动创建该章节
-		typeList = append(typeList, chapterType)
+		chapterTypeList = append(chapterTypeList, chapterType)
+		chapterTypeIdList = append(chapterTypeIdList, chapterType.ReportChapterTypeId)
 	}
 
-	// 分类章节的授权用户
-	typeGrantListMap := make(map[int][]*report.ReportChapterGrant)
+	// 待继承的章节类id的授权用户
+	oldChapterIdGrantListMap := make(map[int][]*report.ReportChapterGrant)
+	// 待继承的章节类id关联的品种列表
+	oldChapterPermissionListMap := make(map[int][]*report.ReportChapterPermissionMapping)
 	// 自定义章节列表
 	customAddChapterList := make([]models.AddReportChapter, 0)
 	// 报告继承
 	inheritChapterMap := make(map[int]*models.ReportChapter)
+
+	// 当前分类下配置的章节类型id所关联的品种列表（默认配置，不是从继承报告里面获取的，如果有继承章节，那么需要从继承报告里面获取）
+	currChapterTypePermissionListMap := make(map[int][]*report.ReportChapterPermissionMapping)
+
+	if len(chapterTypeIdList) > 0 {
+		mappingList, e := models.GetChapterTypePermissionByChapterTypeIdList(chapterTypeIdList)
+		if e != nil {
+			err = fmt.Errorf("获取章节类型权限列表失败, Err: " + e.Error())
+			return
+		}
+		for _, v := range mappingList {
+			tmpChapterTypePermissionList, ok := currChapterTypePermissionListMap[v.ReportChapterTypeId]
+			if !ok {
+				tmpChapterTypePermissionList = make([]*report.ReportChapterPermissionMapping, 0)
+			}
+			currChapterTypePermissionListMap[v.ReportChapterTypeId] = append(tmpChapterTypePermissionList, &report.ReportChapterPermissionMapping{
+				ReportChapterPermissionMappingId: 0,
+				ReportChapterId:                  0,
+				ChartPermissionId:                v.ChartPermissionId,
+				CreateTime:                       time.Now(),
+			})
+		}
+	}
+
 	if inheritReportId > 0 {
 		// 继承待继承的报告章节内容
 		inheritReportChapters, tmpErr := models.GetChapterListByReportId(inheritReportId)
@@ -366,8 +366,13 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 
 		// 继承的报告章节用户map
 		grantListMap := make(map[int][]*report.ReportChapterGrant)
+
+		// 继承的报告章节的关联品种map
+		chapterPermissionListMap := make(map[int][]*report.ReportChapterPermissionMapping)
+
 		// 授权数据列表
 		if len(reportChaptersIdList) > 0 {
+			// 授权用户数据
 			obj := report.ReportChapterGrant{}
 			grantList, tmpErr := obj.GetGrantListByIdList(reportChaptersIdList)
 			if tmpErr != nil {
@@ -392,6 +397,27 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 				tmpGrantList = append(tmpGrantList, v)
 				grantListMap[currReportChapterId] = tmpGrantList
 			}
+
+			// 授权关联品种数据
+			permissionObj := report.ReportChapterPermissionMapping{}
+			permissionList, tmpErr := permissionObj.GetPermissionListByIdList(reportChaptersIdList)
+			if tmpErr != nil {
+				errMsg = "获取待继承的报告章节的授权用户列表失败"
+				err = tmpErr
+				return
+			}
+
+			for _, v := range permissionList {
+				currReportChapterId := v.ReportChapterId
+				tmpPermissionList, ok := chapterPermissionListMap[currReportChapterId]
+				if !ok {
+					tmpPermissionList = make([]*report.ReportChapterPermissionMapping, 0)
+				}
+				v.ReportChapterId = 0
+				v.ReportChapterPermissionMappingId = 0
+				tmpPermissionList = append(tmpPermissionList, v)
+				chapterPermissionListMap[currReportChapterId] = tmpPermissionList
+			}
 		}
 
 		// 继承的报告章节内容
@@ -403,7 +429,14 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 			if !ok {
 				tmpGrantList = make([]*report.ReportChapterGrant, 0)
 			}
-			typeGrantListMap[customChapter.TypeId] = tmpGrantList
+			oldChapterIdGrantListMap[customChapter.ReportChapterId] = tmpGrantList
+
+			// 关联品种列表
+			chapterPermissionList, ok := chapterPermissionListMap[customChapter.ReportChapterId]
+			if !ok {
+				chapterPermissionList = make([]*report.ReportChapterPermissionMapping, 0)
+			}
+			oldChapterPermissionListMap[customChapter.ReportChapterId] = chapterPermissionList
 
 			// 判断该章节是否是系统章节，如果是的话，那就是需要额外创建的
 			if customChapter.TypeId > 0 {
@@ -425,8 +458,9 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 			customChapter.ContentModifyTime = time.Now()
 
 			customAddChapter := models.AddReportChapter{
-				ReportChapter: customChapter,
-				GrantList:     tmpGrantList,
+				ReportChapter:       customChapter,
+				GrantList:           tmpGrantList,
+				GrantPermissionList: chapterPermissionList,
 			}
 			customAddChapterList = append(customAddChapterList, customAddChapter)
 		}
@@ -434,10 +468,18 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 
 	// 最大排序
 	var maxSort int
-	for _, typeItem := range typeList {
-		v := inheritChapterMap[typeItem.ReportChapterTypeId]
+	for _, typeItem := range chapterTypeList {
+		v, ok := inheritChapterMap[typeItem.ReportChapterTypeId]
+
+		// 章节授权用户
+		var tmpGrantList []*report.ReportChapterGrant
+		// 章节关联品种
+		var tmpChapterPermissionList []*report.ReportChapterPermissionMapping
+
 		chapterItem := new(models.ReportChapter)
-		if v != nil {
+
+		if ok && v != nil {
+			// 如果存在继承的章节，那么就从继承的章节内容中获取
 			chapterItem.AddType = 2
 			chapterItem.Title = v.Title
 			chapterItem.ReportType = v.ReportType
@@ -459,6 +501,17 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 			chapterItem.ContentStruct = v.ContentStruct
 			chapterItem.ReportLayout = v.ReportLayout
 			chapterItem.ReportCreateTime = time.Now()
+
+			// 继承历史章节中的授权用户列表
+			tmpGrantList, ok = oldChapterIdGrantListMap[v.ReportChapterId]
+			if !ok {
+				tmpGrantList = make([]*report.ReportChapterGrant, 0)
+			}
+			// 继承历史章节中的关联品种列表
+			tmpChapterPermissionList, ok = oldChapterPermissionListMap[v.ReportChapterId]
+			if !ok {
+				tmpChapterPermissionList = make([]*report.ReportChapterPermissionMapping, 0)
+			}
 		} else {
 			chapterItem.AddType = 1
 			chapterItem.Title = typeItem.ReportChapterTypeName
@@ -479,20 +532,23 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 			//chapterItem.ContentStruct = v.ContentStruct
 			chapterItem.ReportLayout = reportInfo.ReportLayout
 			chapterItem.ReportCreateTime = time.Now()
+
+			// 默认配置：从当前分类下配置的章节类型id所关联的品种列表
+			tmpChapterPermissionList, ok = currChapterTypePermissionListMap[v.TypeId]
+			if !ok {
+				tmpChapterPermissionList = make([]*report.ReportChapterPermissionMapping, 0)
+			}
+
 		}
 
 		if typeItem.Sort > maxSort {
 			maxSort = typeItem.Sort
 		}
 
-		// 授权用户列表
-		tmpGrantList, ok := typeGrantListMap[chapterItem.TypeId]
-		if !ok {
-			tmpGrantList = make([]*report.ReportChapterGrant, 0)
-		}
 		addChapter := models.AddReportChapter{
-			ReportChapter: chapterItem,
-			GrantList:     tmpGrantList,
+			ReportChapter:       chapterItem,
+			GrantList:           tmpGrantList,
+			GrantPermissionList: tmpChapterPermissionList,
 		}
 
 		chapterList = append(chapterList, addChapter)
@@ -505,19 +561,19 @@ func getAddChapter(reportInfo *models.Report, minClassifyId, inheritReportId int
 		chapterList = append(chapterList, addChapterItem)
 	}
 
-	hasGrantUserMap := make(map[int]bool)
-	for _, grantList := range typeGrantListMap {
-		for _, grant := range grantList {
-			if _, ok := hasGrantUserMap[grant.AdminId]; !ok {
-				allGrantUserList = append(allGrantUserList, &report.ReportGrant{
-					//GrantId:      0,
-					//ReportId:     0,
-					AdminId:    grant.AdminId,
-					CreateTime: time.Now(),
-				})
-			}
-		}
-	}
+	//hasGrantUserMap := make(map[int]bool)
+	//for _, grantList := range typeGrantListMap {
+	//	for _, grant := range grantList {
+	//		if _, ok := hasGrantUserMap[grant.AdminId]; !ok {
+	//			allGrantUserList = append(allGrantUserList, &report.ReportGrant{
+	//				//GrantId:      0,
+	//				//ReportId:     0,
+	//				AdminId:    grant.AdminId,
+	//				CreateTime: time.Now(),
+	//			})
+	//		}
+	//	}
+	//}
 
 	return
 }
@@ -927,28 +983,196 @@ func CheckReportAuthByReportChapterInfo(adminId, createAdminId int, reportInfoId
 func EditReportLayoutImg(reportInfo *models.Report, req models.EditLayoutImgReq, sysUser *system.Admin) (err error, errMsg string) {
 	errMsg = `保存失败`
 
+	reportInfo.HeadResourceId = req.HeadResourceId
+	reportInfo.HeadImg = req.HeadImg
+	reportInfo.EndResourceId = req.EndResourceId
+	reportInfo.EndImg = req.EndImg
 	reportInfo.CanvasColor = req.CanvasColor
 	reportInfo.LastModifyAdminId = sysUser.AdminId
 	reportInfo.LastModifyAdminName = sysUser.RealName
 	reportInfo.ModifyTime = time.Now()
 
-	updateCols := []string{"CanvasColor", "LastModifyAdminId", "LastModifyAdminName", "ModifyTime"}
+	updateCols := []string{"HeadResourceId", "HeadImg", "EndResourceId", "EndImg", "CanvasColor", "LastModifyAdminId", "LastModifyAdminName", "ModifyTime"}
 
-	if req.HeadResourceId > 0 {
-		reportInfo.HeadResourceId = req.HeadResourceId
-		reportInfo.HeadImg = req.HeadImg
-		updateCols = append(updateCols, "HeadResourceId", "HeadImg")
+	err = reportInfo.UpdateReport(updateCols)
+	if err != nil {
+		return
 	}
-	if req.EndResourceId > 0 {
-		reportInfo.EndResourceId = req.EndResourceId
-		reportInfo.EndImg = req.EndImg
-		updateCols = append(updateCols, "EndResourceId", "EndImg")
+
+	return
+}
+
+// PublishReport
+// @Description: 报告发布
+// @author: Roc
+// @datetime 2024-06-20 09:44:13
+// @param reportId int
+// @param reportUrl string
+// @param sysUser *system.Admin
+// @return tips string
+// @return err error
+// @return errMsg string
+func PublishReport(reportId int, reportUrl string, sysUser *system.Admin) (tips string, err error, errMsg string) {
+	errMsg = `报告发布失败`
+	reportInfo, err := models.GetReportByReportId(reportId)
+	if err != nil {
+		errMsg = "获取报告信息失败"
+		return
+	}
+	if reportInfo == nil {
+		errMsg = "获取报告信息失败"
+		err = errors.New(errMsg)
+		return
 	}
 
-	err = reportInfo.UpdateReport(updateCols)
+	var publishTime time.Time
+	if reportInfo.MsgIsSend == 1 && reportInfo.PublishTime.IsZero() { //如果报告曾经发布过，并且已经发送过模版消息，则章节的发布时间为报告的发布时间
+		publishTime = reportInfo.PublishTime
+	} else {
+		publishTime = time.Now()
+	}
+	var tmpErr error
+
+	// 章节类型的报告（原来的晨周报）
+	if reportInfo.HasChapter == 1 {
+		tips, tmpErr = PublishDayWeekReport(reportId)
+		if tmpErr != nil {
+			err = errors.New("晨周报发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(reportId))
+		}
+		return
+	}
+
+	// 普通报告
+	if reportInfo.Content == "" {
+		errMsg = `报告内容为空，不可发布`
+		err = errors.New("报告内容为空，不需要生成,report_id:" + strconv.Itoa(reportId))
+		return
+	}
+
+	// 根据审批开关及审批流判断当前报告状态
+	state, e := CheckReportCurrState(report_approve.FlowReportTypeChinese, reportInfo.ClassifyIdFirst, reportInfo.ClassifyIdSecond, reportInfo.ClassifyIdThird, models.ReportOperatePublish)
+	if e != nil {
+		errMsg = "操作失败"
+		err = errors.New("校验报告当前状态失败, Err: " + e.Error())
+		return
+	}
+
+	if state == models.ReportStatePublished {
+		// 发布报告
+		if tmpErr = models.PublishReportById(reportId, publishTime); tmpErr != nil {
+			err = errors.New("报告发布失败, Err:" + tmpErr.Error() + ", report_id:" + strconv.Itoa(reportId))
+			return
+		}
+		go func() {
+			// 生成音频
+			if reportInfo.VideoUrl == "" {
+				_ = CreateVideo(reportInfo)
+			}
+			// 更新报告Es
+			_ = UpdateReportEs(reportId, 2)
+		}()
+	} else {
+		// 从无审批切换为有审批, 状态重置
+		if e = models.ResetReportById(reportId, state); tmpErr != nil {
+			errMsg = "操作失败"
+			err = fmt.Errorf("重置报告状态失败, Err: %s, ReportId: %d", e.Error(), reportId)
+			return
+		}
+	}
+
+	recordItem := &models.ReportStateRecord{
+		ReportId:   reportId,
+		ReportType: 1,
+		State:      state,
+		AdminId:    sysUser.AdminId,
+		AdminName:  sysUser.AdminName,
+		CreateTime: time.Now(),
+	}
+	go func() {
+		_, _ = models.AddReportStateRecord(recordItem)
+	}()
+
+	// TODO 生成报告pdf和长图
+	// 生成报告pdf和长图
+	if reportUrl != "" {
+		go Report2pdfAndJpeg(reportUrl, reportId, 1)
+	}
+
+	// 报告权限处理
+	{
+		minClassifyId, tmpErr := getMinClassifyId(reportInfo)
+		if tmpErr != nil {
+			return
+		}
+		go handleReportPermission(int64(reportInfo.Id), minClassifyId)
+	}
+
+	return
+}
+
+// getMinClassifyId
+// @Description: 获取最小分类ID
+// @author: Roc
+// @datetime 2024-06-20 09:23:19
+// @param reportInfo *models.Report
+// @return minClassifyId int
+// @return err error
+func getMinClassifyId(reportInfo *models.Report) (minClassifyId int, err error) {
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("获取最小分类ID失败，报告ID：%d，Err：%s", reportInfo.Id, err.Error())
+		}
+	}()
+	minClassifyId = reportInfo.ClassifyIdThird
+	if minClassifyId <= 0 {
+		minClassifyId = reportInfo.ClassifyIdSecond
+	}
+	if minClassifyId <= 0 {
+		minClassifyId = reportInfo.ClassifyIdFirst
+	}
+	if minClassifyId <= 0 {
+		err = errors.New("分类异常")
+	}
+
+	return
+}
+
+// handleReportPermission
+// @Description: 报告权限处理
+// @author: Roc
+// @datetime 2024-06-19 18:00:51
+// @param reportId int64
+// @param minClassifyId int
+func handleReportPermission(reportId int64, minClassifyId int) {
+	// TODO 报告权限处理
+	var err error
+	defer func() {
+		if err != nil {
+			utils.FileLog.Error("报告权限处理失败，报告ID：%d，分类ID：%d，Err：%s", reportId, minClassifyId, err.Error())
+			//alarm_msg.SendAlarmMsg("修改删除报告权限失败，Err："+err.Error(), 3)
+		}
+	}()
+
+	err = models.RemoveChartPermissionChapterMapping(reportId)
 	if err != nil {
+		err = errors.New("修改删除报告权限失败，Err：" + err.Error())
 		return
 	}
+	permissionItems, err := models.GetPermission(minClassifyId)
+	if err != nil {
+		err = errors.New("获取权限失败，Err：" + err.Error())
+		return
+	}
+	for _, v := range permissionItems {
+		err = models.AddChartPermissionChapterMapping(v.ChartPermissionId, reportId)
+		if err != nil {
+			err = errors.New("新增权限失败，Err：" + err.Error())
+			return
+		}
+	}
+
+	// 同步crm权限
+	_ = EditReportPermissionSync(reportId, minClassifyId)
 
 	return
 }

services/video.go

@@ -21,7 +21,7 @@ import (
 	"unicode"
 )
 
-func CreateVideo(report *models.ReportDetail) (err error) {
+func CreateVideo(report *models.Report) (err error) {
 	defer func() {
 		if err != nil {
 			utils.FileLog.Error("CreateVideo Err:%s", err.Error())