hongze_yb/services/report/report.go

package report

import (
	"errors"
	"fmt"
	"hongze/hongze_yb/global"
	"hongze/hongze_yb/models/response"
	"hongze/hongze_yb/models/response/purchase"
	"hongze/hongze_yb/models/tables/chart_permission_chapter_mapping"
	"hongze/hongze_yb/models/tables/rddp/report"
	"hongze/hongze_yb/models/tables/rddp/report_chapter"
	"hongze/hongze_yb/models/tables/report_chapter_type"
	"hongze/hongze_yb/services/company"
	"hongze/hongze_yb/services/user"
	"hongze/hongze_yb/utils"
	"log"
)

func GetLatestClassReport(permissionIds []int, userId uint64) (purchaseList []*purchase.PurchaseListItem, err error)  {
	//获取所有和权限绑定的报告
	reportIds, err := GetReportIdsByPermissionIds(permissionIds)
	if err != nil {
		return
	}
	typeIds, tErr := report_chapter_type.GetEffectTypeID()
	if tErr != nil {
		err = tErr
		return
	}
	//获取最新的晨报
	dayReport, err := report.GetLatestDay()
	if err != nil {
		if err == utils.ErrNoRow {
			dayReport = nil
		}else{
			return
		}
	}
	//获取最新的有权限的周报
	weekReport, err := GetLatestWeek(permissionIds, typeIds)
	if err != nil {
		return
	}

	var reports []*report.Report
	if len(reportIds) > 0 {
		reports, err = report.GetLatestClassReportsByIDs(reportIds)
		if err != nil {
			return
		}
	}
	if dayReport != nil {
		reports = append(reports, dayReport)

	}
	if weekReport != nil {
		reports = append(reports, weekReport)
	}

	//获取未读数
	unReadItem, tErr := GetUnRead(reportIds, userId)
	if tErr != nil {
		err = tErr
		return
	}
	if len(reports) > 0 {
		for _, v := range reports {
			temp := new(purchase.PurchaseListItem)
			temp.ReportId = v.Id
			temp.ClassifyIdFirst = v.ClassifyIdFirst
			temp.ClassifyNameFirst = v.ClassifyNameFirst
			temp.Stage = v.Stage
			temp.Title = v.Title
			temp.ClassifyIdSecond = v.ClassifyIdSecond
			temp.ClassifyNameSecond = v.ClassifyNameSecond
			if temp.ClassifyNameFirst == "晨报" || temp.ClassifyNameFirst == "周报" {  //晨报或者周报，查询最新的章节信息
				temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.Title)
			}else{
				if temp.ClassifyIdSecond > 0 {     //包含二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC| %s】%s", temp.Stage, temp.ClassifyNameSecond, temp.ClassifyNameFirst)
				} else {                   //无二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.ClassifyNameFirst)
				}
			}

			temp.Time = v.PublishTime
			temp.Unread = unReadItem[temp.ClassifyNameFirst]
			purchaseList = append(purchaseList, temp)
		}
	}
	return
}

// GetReportIdsByPermissionIds 获取所有和权限绑定的报告
func GetReportIdsByPermissionIds(permissionIds []int) (reportIds []int, err error)   {
	reportIds, err = chart_permission_chapter_mapping.GetReportIdsByPermisssionIds(permissionIds, "rddp")
	return
}

// GetListByClassName 根据分类类型，分页获取报告
func GetListByClassName(reportIds []int, className string, offset, limit int ) (list []*report.Report, err error)  {
	list, err = report.GetListByIDsAndClassID(reportIds, className, offset, limit)
	return
}


// GetPurchaseDetail 已购详情页面
func GetPurchaseDetail(permissionIds []int, userId uint64, classifyNameFirst string, offset, pageLimit int) (list []*purchase.Detail, err error)  {
	var reports []*report.Report
	var reportIds []int
	if classifyNameFirst == "晨报" {
		//分类获取
		reports, err = report.GetListByClass(classifyNameFirst, offset, pageLimit)
		if err != nil {
			return
		}
		for _, v := range reports {
			reportIds = append(reportIds, v.Id)
		}
	}else {
		if classifyNameFirst == "周报" {
			newTypeIds, tErr := GetWeekTypeIdsByPermissionIds(permissionIds,[]int{})
			if tErr != nil {
				return
			}
			reportIds, err = report_chapter.GetReportIdsByTypeIdsAndClass(newTypeIds, classifyNameFirst)
		} else {
			reportIds, err = GetReportIdsByPermissionIds(permissionIds)
			if err != nil {
				return
			}
		}

		if len(reportIds) > 0 {
			//分类获取
			reports, err = GetListByClassName(reportIds, classifyNameFirst, offset, pageLimit)
			if err != nil {
				return
			}
		}
	}
	if len(reports) > 0 {
		var viewReportIds []int
		for _, v := range reports {
			viewReportIds = append(viewReportIds, v.Id)
			temp := new(purchase.Detail)
			temp.ReportId = v.Id
			temp.ClassifyIdFirst = v.ClassifyIdFirst
			temp.ClassifyNameFirst = v.ClassifyNameFirst
			temp.Title = v.Title
			temp.ClassifyIdSecond = v.ClassifyIdSecond
			temp.ClassifyNameSecond = v.ClassifyNameSecond
			if temp.ClassifyNameFirst == "晨报" || temp.ClassifyNameFirst == "周报" {  //晨报或者周报，查询最新的章节信息
				temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.Title)
				temp.TopName = temp.Title
			}else{
				if temp.ClassifyIdSecond > 0 {     //包含二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC| %s】%s", temp.Stage, temp.ClassifyNameSecond, temp.ClassifyNameFirst)
					temp.TopName = temp.ClassifyNameSecond
				} else {                   //无二级分类
					temp.Content = fmt.Sprintf("【第%d期|FICC】%s", temp.Stage, temp.ClassifyNameFirst)
					temp.TopName = temp.ClassifyNameFirst
				}
			}
			temp.Time = v.PublishTime
			list = append(list, temp)
		}
	}

	num, tErr := BatchInsertReportView(reportIds, userId, classifyNameFirst)
	log.Printf("新增报告浏览记录：%d", num)
	if tErr != nil {
		err = tErr
		return
	}
	return
}


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

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

	reportItem := new(response.ReportItem)
	reportItem.ReportId = reportInfo.Id
	reportItem.Title = reportInfo.Title
	reportItem.PublishTime = reportInfo.PublishTime
	reportItem.ClassifyNameFirst = reportInfo.ClassifyNameFirst
	reportItem.ClassifyNameSecond = reportInfo.ClassifyNameSecond
	reportItem.Stage = reportInfo.Stage
	reportItem.Abstract = reportInfo.Abstract
	reportItem.ContentSub = reportInfo.ContentSub
	reportItem.Frequency = reportInfo.Frequency
	reportItem.VideoName = reportInfo.VideoName
	reportItem.VideoPlaySeconds = reportInfo.VideoPlaySeconds
	reportItem.Author = reportInfo.Author

	var reportTypeList []*response.ReportChapterListItem
	if (reportInfo.ClassifyNameFirst == "晨报" || reportInfo.ClassifyNameFirst == "周报") && authOk {
		reportTypeList, err = GetChapterListByReport(reportInfo.ClassifyNameFirst, reportInfo.Id, userinfo.CompanyID)
		if err != nil {
			return
		}
	}
	//如果有权限则展示content
	if authOk  {
		_ = AddViewRecord(userinfo, reportInfo.Id, reportInfo.ClassifyNameFirst, 0)
		reportItem.Content = reportInfo.Content
		reportItem.VideoUrl = reportInfo.VideoUrl
	}
	reportDetail.ReportInfo = reportItem
	reportDetail.ReportChapterList = reportTypeList
	reportDetail.PermissionCheck = &permissionCheckInfo
	reportDetail.AuthOk = authOk
	return
}

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