媒体风险等级筛选

common/component/es/es.go

@@ -38,6 +38,8 @@ const (
 	MatchAllByCondition        = "match_all_by_condition"
 	RangeByCondition           = "range_by_condition"
 	RangeByConditionWithDocIds = "range_by_condition_with_doc_ids"
+
+	RangeWithDocIds = "range_with_doc_ids"
 )
 
 func GetInstance() *ESClient {
@@ -265,6 +267,41 @@ func (req *ESQueryRequest) parseJsonQuery() (queryMap map[string]interface{}) {
 			},
 		}
 		return
+	case RangeWithDocIds:
+		queryMap = map[string]interface{}{
+			"query": map[string]interface{}{
+				"match": map[string]interface{}{
+					req.Column: req.Key,
+				},
+			},
+			"highlight": map[string]interface{}{
+				"fields": map[string]interface{}{
+					req.Column: map[string]interface{}{},
+				},
+				"pre_tags":  []string{"<span style='color:#0078E8'>"},
+				"post_tags": []string{"</span>"},
+			},
+			"post_filter": map[string]interface{}{
+				"bool": map[string]interface{}{
+					"must": []map[string]interface{}{
+						{
+							"range": map[string]interface{}{
+								req.RangeColumn: map[string]interface{}{
+									"gte": req.Min,
+									"lte": req.Max,
+								},
+							},
+						},
+						{
+							"terms": map[string]interface{}{
+								"_id": req.DocIds,
+							},
+						},
+					},
+				},
+			},
+		}
+		return
 	case RangeByCondition:
 		queryMap = map[string]interface{}{
 			"query": map[string]interface{}{

controllers/media/media_controller.go

@@ -5,6 +5,7 @@ import (
 	"eta/eta_mini_ht_api/common/exception"
 	"eta/eta_mini_ht_api/common/utils/page"
 	"eta/eta_mini_ht_api/controllers"
+	reportService "eta/eta_mini_ht_api/domian/report"
 	"eta/eta_mini_ht_api/service/media"
 	"eta/eta_mini_ht_api/service/user"
 )
@@ -37,24 +38,32 @@ func (m *MediaController) Search(mediaType string, key string) {
 			return
 		}
 		detailType := m.Data["detailType"].(string)
-		//if mediaType == "" || !m.CheckMediaType(mediaType) {
-		//	err = exception.New(exception.MediaTypeError)
-		//	m.FailedResult("分页查询媒体列表失败", result)
-		//	return
-		//}
+		userInfo := m.Data["user"].(user.User)
 		pageRes := page.Page{
 			Current:  m.PageInfo.Current,
 			PageSize: m.PageInfo.PageSize,
 		}
+		//获取当前可以被搜索的报告原始ID
+		var mediaIds []int
+		//先要限制查询的id范围
+		pageRes.Total, pageRes.LatestId, mediaIds = media.RangeSearch(mediaType, isLogin(detailType), userInfo.Id)
+		if len(mediaIds) == 0 {
+			reports := new(page.PageResult)
+			reports.Data = []reportService.ReportDTO{}
+			reports.Page = pageRes
+			logger.Info("没有可以查询的报告列表")
+			m.SuccessResult("分页搜索报告列表成功", reports, result)
+			return
+		}
 		if m.PageInfo.LatestId == 0 {
-			pageRes.Total, pageRes.LatestId = media.SearchMaxMediaId(mediaType, key)
+			//pageRes.Total, pageRes.LatestId = media.SearchMaxMediaId(mediaType, key)
 			m.PageInfo.LatestId = pageRes.LatestId
 		} else {
 			pageRes.LatestId = m.PageInfo.LatestId
 			pageRes.Total = m.PageInfo.Total
 		}
 		pageRes.TotalPage = page.TotalPages(pageRes.Total, pageRes.PageSize)
-		list, err := media.SearchMediaList(mediaType, key, m.PageInfo, isLogin(detailType))
+		list, err := media.SearchMediaList(mediaType, key, mediaIds, m.PageInfo, isLogin(detailType))
 		if err != nil {
 			m.FailedResult("分页搜索报告列表失败", result)
 			return
@@ -91,9 +100,15 @@ func (m *MediaController) List(mediaType string, permissionIds string) {
 			PageSize: m.PageInfo.PageSize,
 		}
 		detailType := m.Data["detailType"].(string)
+		userInfo := m.Data["user"].(user.User)
 		var mediaIds []int
+		pageRes.Total, pageRes.LatestId, mediaIds = media.GetTotalPageCountByPermissionIds(mediaType, permissionIdList, isLogin(detailType), userInfo.Id)
+		if err != nil {
+			logger.Error("分页查询媒体列表失败:%v", err)
+			m.FailedResult("分页查询媒体列表失败", result)
+			return
+		}
 		if m.PageInfo.LatestId == 0 {
-			pageRes.Total, pageRes.LatestId, mediaIds = media.GetTotalPageCountByPermissionIds(mediaType, permissionIdList)
 			m.PageInfo.LatestId = pageRes.LatestId
 			m.PageInfo.Total = pageRes.Total
 		} else {
@@ -161,16 +176,10 @@ func (m *MediaController) GetMedia(mediaType string, mediaId int) {
 			m.FailedResult("获取媒体详情失败", result)
 			return
 		}
-		detailType := m.Data["detailType"]
-		mediaDetail, err := media.GetMediaById(mediaType, mediaId)
-		switch detailType {
-		case "logout":
-			logger.Info("当前用户未登录,展示部分详情")
-			mediaDetail.Src = ""
-			mediaDetail.Login = false
-		case "login":
-			mediaDetail.Login = true
-		}
+		userInfo := m.Data["user"].(user.User)
+		detailType := m.Data["detailType"].(string)
+		mediaDetail, err := media.GetMediaById(mediaType, mediaId, isLogin(detailType), userInfo.Id)
+
 		if err != nil {
 			m.FailedResult("获取媒体详情失败", result)
 			return

domian/media/media_service.go

@@ -11,6 +11,7 @@ import (
 	"eta/eta_mini_ht_api/models"
 	mediaDao "eta/eta_mini_ht_api/models/media"
 	"sort"
+	"strconv"
 	"time"
 )
 
@@ -50,12 +51,17 @@ type MediaDTO struct {
 	PermissionNames       []string `json:"permissionNames,omitempty"`
 	Highlight             []string `json:"highlight,omitempty"`
 	Login                 bool     `json:"login"`
+	RiskLevelStatus       string   `json:"riskLevelStatus"`
 }
 
-func SearchMediaList(mediaType string, key string, from int, size int, max int64) (reports []MediaDTO, err error) {
+func SearchMediaList(_ string, key string, mediaIds []int, from int, size int, max int64) (reports []MediaDTO, err error) {
 	//同步es
+	var docIds []string
+	for _, id := range mediaIds {
+		docIds = append(docIds, strconv.Itoa(id))
+	}
 	sorts := append(sortField, "publishedTime:desc")
-	request := matchRangeByCondition(key, from, size, max, sorts, ConditionColumn, mediaType)
+	request := matchRangeWithDocIds(key, from, size, max, sorts, docIds)
 	re, err := elastic().Search(request)
 	if err != nil {
 		logger.Error("es搜索失败:%v", err)
@@ -208,7 +214,11 @@ func matchRangeByCondition(key string, from int, to int, max int64, sorts []stri
 	//return req.CreateESQueryRequest(htConfig.GetMediaIndex(), ESColumn, key, from, to, sorts, es.RangeByCondition).Range(0, max, ESRangeColumn).ByCondition(column, value)
 	return req.CreateESQueryRequest(htConfig.GetMediaIndex(), ESColumn, key, from, to, sorts, es.Range).Range(0, max, ESRangeColumn)
 }
-
+func matchRangeWithDocIds(key string, from int, to int, max int64, sorts []string, docIds []string) (request *es.ESQueryRequest) {
+	req := new(es.ESQueryRequest)
+	//return req.CreateESQueryRequest(htConfig.GetMediaIndex(), ESColumn, key, from, to, sorts, es.RangeByCondition).Range(0, max, ESRangeColumn).ByCondition(column, value)
+	return req.CreateESQueryRequest(htConfig.GetMediaIndex(), ESColumn, key, from, to, sorts, es.Range).Range(0, max, ESRangeColumn).WithDocs(docIds)
+}
 func GetImageSrc(id int) (src string, err error) {
 	return mediaDao.GetImageSrc(id)
 }

domian/user/user_source_click_flow_service.go

@@ -1,6 +1,7 @@
 package user
 
 import (
+	"errors"
 	logger "eta/eta_mini_ht_api/common/component/log"
 	userDao "eta/eta_mini_ht_api/models/user"
 )
@@ -16,6 +17,22 @@ type RecordCountDTO struct {
 	Additional string
 }
 
+const (
+	video = "video"
+	audio = "audio"
+)
+
+func getSourceType(mediaType string) userDao.SourceType {
+	switch mediaType {
+	case video:
+		return userDao.VideoSourceType
+	case audio:
+		return userDao.AudioSourceType
+	default:
+		return ""
+	}
+}
+
 func CountReport(record RecordCountDTO) (err error) {
 	dao := convertUserToReportFlow(record)
 	err = userDao.CountSourceClicks(dao)
@@ -27,11 +44,18 @@ func CountReport(record RecordCountDTO) (err error) {
 	return
 }
 
-func CountMedia(record RecordCountDTO) (err error) {
+func CountMedia(record RecordCountDTO, mediaType string) (err error) {
+	sourceType := getSourceType(mediaType)
+	if sourceType == "" {
+		logger.Error("媒体类型错误,%s", mediaType)
+		err = errors.New("illegal sourceType")
+		return
+	}
+	record.SourceType = sourceType
 	dao := convertUserToMediaFlow(record)
 	err = userDao.CountSourceClicks(dao)
 	if err != nil {
-		logger.Error("插入用户研报点击记录失败:%v", err)
+		logger.Error("插入用户媒体点击记录失败:%v", err)
 		return
 	}
 	_ = GetUserAndCountReadTimes(record.UserId)

service/media/media_service.go

@@ -1,20 +1,27 @@
 package media
 
 import (
+	"errors"
 	logger "eta/eta_mini_ht_api/common/component/log"
 	"eta/eta_mini_ht_api/common/exception"
 	"eta/eta_mini_ht_api/common/utils/page"
 	stringUtils "eta/eta_mini_ht_api/common/utils/string"
+	permissionService "eta/eta_mini_ht_api/domian/config"
 	mediaService "eta/eta_mini_ht_api/domian/media"
 	userService "eta/eta_mini_ht_api/domian/user"
-	"eta/eta_mini_ht_api/models/user"
+	"eta/eta_mini_ht_api/service/user"
+	"fmt"
+	"gorm.io/gorm"
+	"strconv"
 	"strings"
 	"sync"
 )
 
 const (
-	video = "video"
-	audio = "audio"
+	RiskLevelUnMatch = "unMatch"
+	RiskLevelUnTest  = "unTest"
+	RiskLevelExpired = "expired"
+	RiskLevelMatch   = "match"
 )
 
 type RecordCount struct {
@@ -28,33 +35,22 @@ type RecordCount struct {
 	Additional string
 }
 
-func convertToMediaCountDTO(record RecordCount, sourceType user.SourceType) (dto userService.RecordCountDTO) {
+func convertToMediaCountDTO(record RecordCount) (dto userService.RecordCountDTO) {
 	return userService.RecordCountDTO{
-		UserId:     record.UserId,
-		Mobile:     record.Mobile,
-		SourceId:   record.MediaId,
-		SourceType: sourceType,
-	}
-}
-func getSourceType(mediaType string) user.SourceType {
-	switch mediaType {
-	case video:
-		return user.VideoSourceType
-	case audio:
-		return user.AudioSourceType
-	default:
-		return ""
+		UserId:   record.UserId,
+		Mobile:   record.Mobile,
+		SourceId: record.MediaId,
 	}
 }
+
 func CountMedia(count RecordCount) (err error) {
-	media, err := mediaService.GetMediaById(count.MediaType, count.MediaId)
-	sourceType := getSourceType(media.MediaType)
-	if sourceType == "" {
-		err = exception.New(exception.MediaTypeError)
+	meida, err := mediaService.GetMediaById(count.MediaType, count.MediaId)
+	if err != nil {
+		err = exception.New(exception.MediaFoundFailed)
 		return
 	}
-	dto := convertToMediaCountDTO(count, sourceType)
-	return userService.CountMedia(dto)
+	dto := convertToMediaCountDTO(count)
+	return userService.CountMedia(dto, meida.MediaType)
 }
 func GetTotalPageCount(mediaType string) (count int64, latestId int64) {
 	if mediaType == "" {
@@ -68,26 +64,183 @@ func GetTotalPageCountByAnalystId(mediaType string, analystId int) (total int64,
 	}
 	return mediaService.GetTotalPageCountByAnalystId(mediaType, analystId)
 }
-func GetTotalPageCountByPermissionIds(mediaType string, permissionIds []int) (total int64, latestId int64, ids []int) {
+
+func RangeSearch(mediaType string, isLogin bool, userId int) (total int64, latestId int64, ids []int) {
+	var err error
+	//登录了需要校验风险等级，如果风险等级没做或者过期直接返回空，做了就筛选风险等级
+	if isLogin {
+		userProfile, userErr := user.GetUserProfile(userId)
+		if userErr != nil {
+			if errors.Is(userErr, gorm.ErrRecordNotFound) {
+				err = exception.New(exception.TemplateUserNotFound)
+			} else {
+				err = exception.New(exception.TemplateUserFoundFailed)
+			}
+			logger.Error("分页查询报告列表失败:%v", err)
+			return
+		}
+		//获取产品风险等级
+		if userProfile.RiskLevel == user.RiskUnTest {
+			logger.Error("客户未做风险等级测评,mobile：%d", userProfile.Mobile)
+			return
+		}
+		if userProfile.RiskLevelStatus == user.RiskExpired {
+			logger.Error("客户风险等级已过期,mobile：%d", userProfile.Mobile)
+			return
+		}
+		mapping, mappingErr := permissionService.GetRiskMappingByCustomerRiskLevel(userProfile.RiskLevel)
+		if mappingErr != nil {
+			logger.Error("查询产品风险等级映射失败:%v", mappingErr)
+			return
+		}
+		var permissionList []permissionService.PermissionDTO
+		//获取所有设置风险等级的品种
+		permissionList, err = permissionService.GetPermissionListWithRisk()
+		permissionList = filterPermissionsByRisk(permissionList, mapping.ProductRiskLevel)
+		if len(permissionList) == 0 {
+			return
+		}
+		var filterPermissionIds []int
+		for _, permission := range permissionList {
+			filterPermissionIds = append(filterPermissionIds, permission.PermissionId)
+		}
+		return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds)
+	} else { //没有登录的时候展示所有设置了风险等级的品种报告，筛选的时候过滤传入ID中没有设置风险等级的品种
+		var permissionList []permissionService.PermissionDTO
+		//获取所有设置风险等级的品种
+		permissionList, err = permissionService.GetPermissionListWithRisk()
+		if err != nil {
+			logger.Error("根据ID查询品种列表失败:%v", err)
+		}
+		var filterPermissionIds []int
+		for _, permission := range permissionList {
+			filterPermissionIds = append(filterPermissionIds, permission.PermissionId)
+		}
+		//查询品种
+		return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds)
+	}
+}
+func GetTotalPageCountByPermissionIds(mediaType string, permissionIds []int, isLogin bool, userId int) (total int64, latestId int64, ids []int) {
 	if mediaType == "" {
 		return
 	}
-	if len(permissionIds) == 0 {
-		total, latestId = mediaService.GetTotalPageCount(mediaType)
-		ids = []int{}
+	var err error
+	//登录了需要校验风险等级，如果风险等级没做或者过期直接返回空，做了就筛选风险等级
+	if isLogin {
+		userProfile, userErr := user.GetUserProfile(userId)
+		if userErr != nil {
+			if errors.Is(userErr, gorm.ErrRecordNotFound) {
+				err = exception.New(exception.TemplateUserNotFound)
+			} else {
+				err = exception.New(exception.TemplateUserFoundFailed)
+			}
+			logger.Error("分页查询媒体列表失败:%v", err)
+			return
+		}
+		//获取产品风险等级
+		if userProfile.RiskLevel == user.RiskUnTest {
+			logger.Error("客户未做风险等级测评,mobile：%d", userProfile.Mobile)
+			return
+		}
+		if userProfile.RiskLevelStatus == user.RiskExpired {
+			logger.Error("客户风险等级已过期,mobile：%d", userProfile.Mobile)
+			return
+		}
+		mapping, mappingErr := permissionService.GetRiskMappingByCustomerRiskLevel(userProfile.RiskLevel)
+		if mappingErr != nil {
+			logger.Error("查询产品风险等级映射失败:%v", mappingErr)
+			return
+		}
+		var permissionList []permissionService.PermissionDTO
+		if len(permissionIds) == 0 {
+			//获取所有设置风险等级的品种
+			permissionList, err = permissionService.GetPermissionListWithRisk()
+		} else {
+			//更具id过滤设置了风险等级的品种
+			permissionList, err = permissionService.GetPermissionListByIds(permissionIds)
+		}
+		permissionList = filterPermissionsByRisk(permissionList, mapping.ProductRiskLevel)
+		if len(permissionList) == 0 {
+			return
+		}
+		var filterPermissionIds []int
+		for _, permission := range permissionList {
+			filterPermissionIds = append(filterPermissionIds, permission.PermissionId)
+		}
+		return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds)
+	} else { //没有登录的时候展示所有设置了风险等级的品种报告，筛选的时候过滤传入ID中没有设置风险等级的品种
+		var permissionList []permissionService.PermissionDTO
+		if len(permissionIds) == 0 {
+			//获取所有设置风险等级的品种
+			permissionList, err = permissionService.GetPermissionListWithRisk()
+		} else {
+			//更具id过滤设置了风险等级的品种
+			permissionList, err = permissionService.GetPermissionListByIds(permissionIds)
+		}
+		if err != nil {
+			logger.Error("根据ID查询品种列表失败:%v", err)
+		}
+		var filterPermissionIds []int
+		for _, permission := range permissionList {
+			filterPermissionIds = append(filterPermissionIds, permission.PermissionId)
+		}
+		//查询品种
+		return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds)
+	}
+	//if len(permissionIds) == 0 {
+	//	total, latestId = mediaService.GetTotalPageCount(mediaType)
+	//	ids = []int{}
+	//	return
+	//}
+	//return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, permissionIds)
+}
+func parseRiskLevel(level string) (int, error) {
+	parts := strings.Split(level, "R")
+	if len(parts) < 2 {
+		return 0, fmt.Errorf("无效的风险等级: %s", level)
+	}
+	numberStr := parts[1]
+	number, err := strconv.Atoi(numberStr)
+	if err != nil {
+		return 0, fmt.Errorf("无法将风险等级转换为数字: %s", err)
+	}
+	return number, nil
+}
+func filterPermissionsByRisk(permissionList []permissionService.PermissionDTO, riskLevel string) (resultList []permissionService.PermissionDTO) {
+	riskLevelNum, err := parseRiskLevel(riskLevel)
+	if err != nil {
+		logger.Error("风险等级解析失败:%v", err)
 		return
 	}
-	return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, permissionIds)
+	for _, permission := range permissionList {
+		pRiskNum, riskErr := parseRiskLevel(permission.RiskLevel)
+		if riskErr != nil {
+			logger.Error("解析品种风险等级失败 permission:%d,risk:%v", permission.PermissionId, permission.RiskLevel)
+			continue
+		}
+		if pRiskNum <= riskLevelNum {
+			resultList = append(resultList, permission)
+		}
+	}
+	return
 }
 func SearchMaxMediaId(mediaType string, key string) (total int64, latestId int64) {
 	return mediaService.SearchMaxMediaId(mediaType, key)
 }
-func GetMediaById(mediaType string, mediaId int) (media mediaService.MediaDTO, err error) {
+func GetMediaById(mediaType string, mediaId int, isLogin bool, userId int) (media mediaService.MediaDTO, err error) {
 	media, err = mediaService.GetMediaById(mediaType, mediaId)
 	if err != nil {
+		logger.Error("获取媒体失败:%v", err)
 		err = exception.New(exception.MediaFoundFailed)
 		return
 	}
+	var status string
+	status, err = matchRiskLevel(userId, media)
+	if err != nil {
+		logger.Error("匹配风险等级失败:%v", err)
+		err = exception.New(exception.ReportRiskLevelUnSet)
+		return
+	}
 	idStr := strings.Split(media.PermissionIDs, ",")
 	var ids []int
 	ids, err = stringUtils.StringToIntSlice(idStr)
@@ -96,9 +249,98 @@ func GetMediaById(mediaType string, mediaId int) (media mediaService.MediaDTO, e
 		return
 	}
 	media.PermissionNames = getMediaPermissionNames(ids)
+	if isLogin {
+		media.Login = true
+		if status != RiskLevelMatch {
+			media.Src = ""
+		}
+		media.RiskLevelStatus = status
+	} else {
+		logger.Info("当前用户未登录,展示部分详情")
+		media.Src = ""
+		media.RiskLevelStatus = RiskLevelUnMatch
+		media.Login = false
+	}
+	return
+}
+func matchRiskLevel(userId int, media mediaService.MediaDTO) (riskLevelMatch string, err error) {
+	userProfile, userErr := user.GetUserProfile(userId)
+	if userErr != nil {
+		if errors.Is(userErr, gorm.ErrRecordNotFound) {
+			logger.Error("用户信息不存在,mobile：%d", userProfile.Mobile)
+			err = exception.New(exception.TemplateUserNotFound)
+			return
+		} else {
+			logger.Error("获取用户信息失败:%v", userErr)
+			err = exception.New(exception.TemplateUserFoundFailed)
+			return
+		}
+	}
+	//比较风险等级
+	if userProfile.RiskLevelStatus == user.RiskUnTest {
+		logger.Info("客户风险等级未测试,mobile：%d", userProfile.Mobile)
+		riskLevelMatch = RiskLevelUnTest
+		return
+	}
+	if userProfile.RiskLevelStatus == user.RiskExpired {
+		logger.Info("客户风险等级已过期,mobile：%d", userProfile.Mobile)
+		riskLevelMatch = RiskLevelExpired
+		return
+	}
+	level, err := permissionService.GetRiskMappingByCustomerRiskLevel(userProfile.RiskLevel)
+	if err != nil {
+		logger.Error("获取媒体风险等级设置失败:%v", err)
+		return
+	}
+	var permissionIds []int
+	permissionStrList := strings.Split(media.PermissionIDs, ",")
+	permissionIds, err = stringUtils.StringToIntSlice(permissionStrList)
+	if err != nil {
+		logger.Error("解析媒体品种ID列表失败:%v", err)
+	}
+	permissionDTOs, err := permissionService.GetPermissionListByIds(permissionIds)
+	if err != nil {
+		logger.Error("获取品种风险等级失败:%v", err)
+		return
+	}
+	//能够查看最高等级
+	matchNum, err := parseRiskLevel(level.ProductRiskLevel)
+	if err != nil {
+		logger.Error("解析风险等级失败:%v", err)
+		return
+	}
+	if len(permissionDTOs) == 0 {
+		logger.Error("当前报告对应品种未设置风险等级")
+		err = exception.New(exception.ReportRiskLevelUnSet)
+		return
+	}
+	//能够查看需要的最小等级
+	num := getLowestRiskLevel(permissionDTOs)
+	if num > matchNum {
+		riskLevelMatch = RiskLevelUnMatch
+		return
+	} else {
+		riskLevelMatch = RiskLevelMatch
+		return
+	}
+}
+func getLowestRiskLevel(permissions []permissionService.PermissionDTO) (riskLevelNum int) {
+	for _, permission := range permissions {
+		pRiskNum, err := parseRiskLevel(permission.RiskLevel)
+		if err != nil {
+			logger.Error("解析风险等级失败:%v", err)
+			continue
+		}
+		if riskLevelNum == 0 {
+			riskLevelNum = pRiskNum
+		} else {
+			if riskLevelNum > pRiskNum {
+				riskLevelNum = pRiskNum
+			}
+		}
+	}
 	return
 }
-
 func GetMediaPageByAnalystId(mediaType string, pageInfo page.PageInfo, analystId int) (list []mediaService.MediaDTO, err error) {
 	list, err = mediaService.GetMediaPageByAnalystId(mediaType, pageInfo, analystId)
 	if err != nil {
@@ -173,9 +415,9 @@ func getMediaPermissionNames(id []int) (labels []string) {
 
 // stringToIntSlice 将一个包含数字字符串的切片转换为整数切片
 
-func SearchMediaList(mediaType string, key string, pageInfo page.PageInfo, isLogin bool) (medias []mediaService.MediaDTO, err error) {
+func SearchMediaList(mediaType string, key string, mediaIds []int, pageInfo page.PageInfo, isLogin bool) (medias []mediaService.MediaDTO, err error) {
 	offset := page.StartIndex(pageInfo.Current, pageInfo.PageSize)
-	medias, err = mediaService.SearchMediaList(mediaType, key, offset, pageInfo.PageSize, pageInfo.LatestId)
+	medias, err = mediaService.SearchMediaList(mediaType, key, mediaIds, offset, pageInfo.PageSize, pageInfo.LatestId)
 	var wg sync.WaitGroup
 	wg.Add(len(medias))
 	for i := 0; i < len(medias); i++ {

service/report/report_service.go

@@ -183,7 +183,7 @@ func GetReportById(reportId int, login bool, userId int) (report reportService.R
 			report.RiskLevelStatus = RiskLevelUnMatch
 			report.Login = false
 		} else {
-			if status == RiskLevelUnMatch {
+			if status != RiskLevelMatch {
 				detail.Content = ""
 			}
 			report.RiskLevelStatus = status