eta_mini_ht_api/service/media/media_service.go

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"
	configService "eta/eta_mini_ht_api/domian/config"
	permissionService "eta/eta_mini_ht_api/domian/config"
	mediaService "eta/eta_mini_ht_api/domian/media"
	productService "eta/eta_mini_ht_api/domian/merchant"
	userService "eta/eta_mini_ht_api/domian/user"
	mediaDao "eta/eta_mini_ht_api/models/media"
	productDao "eta/eta_mini_ht_api/models/merchant"
	"eta/eta_mini_ht_api/service/config"
	"eta/eta_mini_ht_api/service/report"
	"eta/eta_mini_ht_api/service/user"
	"fmt"
	"gorm.io/gorm"
	"strconv"
	"strings"
	"sync"
)

const (
	RiskLevelUnMatch    = "unMatch"
	RiskLevelUnTest     = "unTest"
	RiskLevelExpired    = "expired"
	RiskLevelMatch      = "match"
	defaultProductPrice = "0"
)

type RecordCount struct {
	UserId     int
	Mobile     string
	MediaId    int
	MediaName  string
	TraceId    string
	MediaType  string
	IpAddress  string
	Location   string
	Referer    string
	Additional string
}

func convertToMediaCountDTO(record RecordCount) (dto userService.RecordCountDTO) {
	return userService.RecordCountDTO{
		UserId:   record.UserId,
		TraceId:  record.TraceId,
		Mobile:   record.Mobile,
		SourceId: record.MediaId,
	}
}

func CountMedia(count RecordCount) (traceId string, err error) {
	media, err := mediaService.GetMediaById(count.MediaType, count.MediaId)
	if err != nil {
		err = exception.New(exception.MediaFoundFailed)
		return
	}
	dto := convertToMediaCountDTO(count)
	dto.SourceTitle = media.MediaName
	return userService.CountMedia(dto, media.MediaType)
}

func RangeSearchByAnalyst(mediaType string, analystId int, userId int) (total int64, latestId int64, ids []int, mappingRiskLevel string) {
	//var err error
	////登录了需要校验风险等级，如果风险等级没做或者过期直接返回空，做了就筛选风险等级
	//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：%v", userProfile.Mobile)
	//}
	//if userProfile.RiskLevelStatus == user.RiskExpired {
	//	logger.Error("客户风险等级已过期,mobile：%v", userProfile.Mobile)
	//}
	//mapping, mappingErr := permissionService.GetRiskMappingByCustomerRiskLevel(userProfile.RiskLevel)
	//if mappingErr != nil {
	//	logger.Error("查询产品风险等级映射失败:%v", mappingErr)
	//	return
	//}
	//mappingRiskLevel = mapping.ProductRiskLevel
	//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)
	//}
	filterPermissionIds, riskLevel, err := report.CheckUserRisk(nil, true, userId)
	if err != nil {
		logger.Error("校验用户风险等级失败:%v", err)
		return
	}
	return mediaService.GetAnalystMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds, analystId, riskLevel)
}

func getCount(mediaType string, permissionIds []int, isLogin bool, userId int) (total int64, latestId int64, orgIds []int, mappingPdRisk string) {
	filterPermissionIds, riskLevel, err := report.CheckUserRisk(permissionIds, isLogin, userId)
	if err != nil {
		logger.Error("校验用户风险等级失败:%v", err)
		return
	}
	return mediaService.GetMediaPermissionMappingByPermissionIds(mediaType, filterPermissionIds, riskLevel)
}
func RangeSearch(mediaType string, isLogin bool, userId int) (total int64, latestId int64, ids []int, mappingPdRisk string) {
	return getCount(mediaType, nil, isLogin, userId)
}
func GetTotalPageCountByPermissionIds(mediaType string, permissionIds []int, isLogin bool, userId int) (total int64, latestId int64, ids []int, mappingPdRisk string) {
	if mediaType == "" {
		return
	}
	return getCount(mediaType, permissionIds, isLogin, userId)
}

func filterPermissionsByRisk(permissionList []permissionService.PermissionDTO, riskLevel string) (resultList []permissionService.PermissionDTO) {
	riskLevelNum, err := config.ParseRiskLevel(riskLevel)
	if err != nil {
		logger.Error("风险等级解析失败:%v", err)
		return
	}
	for _, permission := range permissionList {
		pRiskNum, riskErr := config.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, isLogin bool, userId int) (media *mediaService.MediaDTO, err error) {
	_, mappingRiskLevel, err := user.CheckUserRisk(nil, isLogin, userId)
	if err != nil {
		logger.Error("校验用户风险等级失败:%v", err)
	}
	*media, err = mediaService.GetMediaById(mediaType, mediaId)
	if err != nil {
		logger.Error("获取媒体失败:%v", err)
		err = exception.New(exception.MediaFoundFailed)
		return
	}
	//var status string
	//
	//status, media.RiskLevel, 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)
	//if err != nil {
	//	logger.Error("品种名称列表转换失败:%v", err)
	//	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 DealMediaInfo(media, isLogin, userId, mappingRiskLevel)
}
func matchRiskLevel(userId int, media mediaService.MediaDTO) (riskLevelMatch string, productRiskLevel 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：%v", userProfile.Mobile)
		riskLevelMatch = RiskLevelUnTest
		return
	}
	if userProfile.RiskLevelStatus == user.RiskExpired {
		logger.Info("客户风险等级已过期,mobile：%v", 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 := config.ParseRiskLevel(level.ProductRiskLevel)
	if err != nil {
		logger.Error("解析风险等级失败:%v", err)
		return
	}
	if len(permissionDTOs) == 0 {
		logger.Error("当前报告对应品种未设置风险等级")
		err = exception.New(exception.ReportRiskLevelUnSet)
		return
	}
	//能够查看需要的最小等级
	num := config.GetHighestRiskLevel(permissionDTOs)
	productRiskLevel = fmt.Sprintf("R%d", num)
	if num > matchNum {
		riskLevelMatch = RiskLevelUnMatch
		return
	} else {
		riskLevelMatch = RiskLevelMatch
		return
	}
}

func getLowestRiskLevel(permissions []permissionService.PermissionDTO) (riskLevelNum int) {
	for _, permission := range permissions {
		pRiskNum, err := config.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, mediaIds []int, userId int, mappingRiskLevel string) (list []mediaService.MediaDTO, err error) {
	list, err = mediaService.GetMediaPageByAnalystId(mediaType, pageInfo, analystId, mediaIds)
	if err != nil {
		err = exception.New(exception.GetAnalystMediaListFailed)
		return
	}
	if len(list) == 0 {
		logger.Info("研究员媒体列表为空")
		return
	}
	//并发获取媒体的标签
	list, err = dealMediaInfo(list, true, userId, mappingRiskLevel)
	if err != nil {
		err = exception.New(exception.GetAnalystMediaListFailed)
	}
	return
}
func getMediaSecondPermissions(ids []int) (permissionDTOs []configService.PermissionDTO, err error) {
	return mediaService.GetSecondPermissionsByIds(ids)
}
func GetMediaPageByIds(mediaType string, pageInfo page.PageInfo, mediaIds []int, isLogin bool, userId int, mappingRiskLevel string) (list []mediaService.MediaDTO, err error) {
	list, err = mediaService.GetMediaPageByIds(mediaType, pageInfo, mediaIds)
	if err != nil {
		err = exception.New(exception.GetMediaListFailed)
		return
	}
	list, err = dealMediaInfo(list, isLogin, userId, mappingRiskLevel)
	if err != nil {
		err = exception.New(exception.QueryReportPageFailed)
	}
	return
}
func GetMediaPermissionNames(id []int) (labels []string) {
	permissions, err := mediaService.GetPermissionsByIds(id)
	if err != nil {
		logger.Error("查询品种名称列表失败:%v", err)
		labels = []string{}
		return
	}
	for _, permission := range permissions {
		labels = append(labels, permission.PermissionName)
	}
	return
}
func DealMediaInfo(media *mediaService.MediaDTO, isLogin bool, templateUserId int, mappingRiskLevel string) (resultMedia *mediaService.MediaDTO, err error) {
	idStr := strings.Split(media.PermissionIDs, ",")
	var ids []int
	ids, err = stringUtils.StringToIntSlice(idStr)
	if err != nil {
		logger.Error("品种名称列表转换失败:%v", err)
	}
	media.PermissionNames = GetMediaPermissionNames(ids)
	permissions, permissionErr := getMediaSecondPermissions(ids)
	if permissionErr != nil {
		logger.Error("获取媒体品种信息失败:%v，无法设置媒体风险等级", err)
	}
	riskNum := config.GetHighestRiskLevel(permissions)
	media.RiskLevel = strings.Join([]string{"R", strconv.Itoa(riskNum)}, "")
	if !isLogin {
		media.Src = ""
	}
	media.Login = isLogin
	var productType productDao.MerchantProductType
	switch media.MediaType {
	case string(mediaDao.Audio):
		productType = productDao.Audio
	case string(mediaDao.Video):
		productType = productDao.Video
	default:
		logger.Error("未知媒体类型:%s", media.MediaType)
		productType = ""
	}
	var packageList []productService.MerchantProductDTO
	var permissionIds []int
	if len(permissions) > 0 {
		for _, permission := range permissions {
			permissionIds = append(permissionIds, permission.PermissionId)
		}
		//单品不存在的话查套餐
		packageList, err = productService.GetProductListBySourceIds(permissionIds, "package")
		if err != nil {
			logger.Error("获取套餐列表失败:%v", err)
		}
	}
	product, pdErr := productService.GetProductBySourceId(media.MediaId, productType)
	if pdErr != nil {
		if len(packageList) == 0 {
			logger.Error("获取套餐列表失败:%v", err)
			media.Price = defaultProductPrice
			media.IsFree = true
			media.IsSubscribe = false
			media.IsPackage = false
		} else {
			media.Price = defaultProductPrice
			media.IsFree = false
			media.IsSubscribe = false
			media.IsPackage = true
			media.ProductId = packageList[0].Id
		}
	} else {
		media.Price = product.Price
		media.IsFree = false
		media.IsPackage = false
		media.IsSubscribe = false
		media.ProductId = product.Id
	}
	if isLogin {
		var productIds []int
		if len(packageList) > 0 {
			for _, packageItem := range packageList {
				productIds = append(productIds, packageItem.Id)
			}
		}
		if product.Id > 0 {
			productIds = append(productIds, product.Id)
		}
		subscribeList, subscribeErr := userService.GetUserSubscribe(productIds, templateUserId)
		if subscribeErr != nil {
			media.IsSubscribe = false
		} else {
			for _, subscribe := range subscribeList {
				if subscribe.Status == productDao.SubscribeValid {
					media.IsSubscribe = true
					break
				}
			}
		}
	}
	media.RiskLevelStatus = RiskLevelUnMatch
	mappingRiskNum, parseErr := config.ParseRiskLevel(mappingRiskLevel)
	if parseErr != nil {
		return
	}
	var rpRiskNum int
	rpRiskNum, parseErr = config.ParseRiskLevel(media.RiskLevel)
	if parseErr != nil {
		return
	}
	if rpRiskNum <= mappingRiskNum {
		media.RiskLevelStatus = RiskLevelMatch
	}
	resultMedia = media
	return
}

// stringToIntSlice 将一个包含数字字符串的切片转换为整数切片
func dealMediaInfo(list []mediaService.MediaDTO, isLogin bool, templateUserId int, mappingRiskLevel string) (dealList []mediaService.MediaDTO, err error) {
	//并发获取媒体的标签
	var wg sync.WaitGroup
	wg.Add(len(list))
	for i := 0; i < len(list); i++ {
		go func(media *mediaService.MediaDTO) {
			defer wg.Done()
			media, err = DealMediaInfo(media, isLogin, templateUserId, mappingRiskLevel)
			if err != nil {
				logger.Error("处理媒体信息失败:%v", err)
			}
		}(&list[i])
	}
	wg.Wait()
	dealList = list
	return
}
func SearchMediaList(mediaType string, key string, mediaIds []int, pageInfo page.PageInfo, isLogin bool, userId int, mappingRiskLevel string) (medias []mediaService.MediaDTO, err error) {
	offset := page.StartIndex(pageInfo.Current, pageInfo.PageSize)
	medias, err = mediaService.SearchMediaList(mediaType, key, mediaIds, offset, pageInfo.PageSize, pageInfo.LatestId)
	medias, err = dealMediaInfo(medias, isLogin, userId, mappingRiskLevel)
	if err != nil {
		err = exception.New(exception.SearchReportPageFailed)
	}
	return
}

func SearchMediaProduct(key string, docIds []int) (list []mediaService.MediaDTO, err error) {
	list, err = mediaService.SearchMediaProduct(key, 100, 0, docIds)
	if err != nil {
		err = exception.New(exception.SearchReportPageFailed)
	}
	return
}

func CountPermissionWeight(ids []int) (permissionMap map[int]int) {
	list, err := mediaService.CountPermissionWeight(ids)
	if err != nil {
		return
	}
	for _, permission := range list {
		permissionMap[permission.PermissionId] = permission.Weight
	}
	return
}