hongze_cygx/services/micro_roadshow.go

package services

import (
	"encoding/json"
	"errors"
	"hongze/hongze_cygx/models"
	"hongze/hongze_cygx/utils"
	"math"
	"strconv"
	"strings"
	"sync"
)

// GetMicroRoadShowPageList 获取微路演列表
func GetMicroRoadShowPageList(pageSize, currentIndex, audioId, videoId int, keywords string) (respList []*models.MicroRoadShowPageList, total int, err error) {
	var e error
	// 根据每页数据量获取音视频配比
	audioRatio, videoRatio, audioPageNum, videoPageNum, sliceNum, e := getMicroRoadShowDataRatio(pageSize)
	if e != nil {
		err = errors.New("获取微路演列表数据音视频配比失败, Err: " + e.Error())
		return
	}

	audioTotal := 0
	videoTotal := 0
	audioList := make([]*models.MicroRoadShowPageList, 0)
	videoList := make([]*models.MicroRoadShowPageList, 0)
	if keywords != "" {
		keywords = "%" + keywords + "%"
	}
	// 查询指定音频/视频时, 调整比例为1方便后面组合数据
	if audioId > 0 || videoId > 0 {
		audioRatio = 1
		videoRatio = 1
	}

	wg := sync.WaitGroup{}

	wg.Add(2)

	// 分页查询音频
	go func() {
		defer wg.Done()
		// 如果筛选条件为指定视频ID则不做音频查询
		if videoId > 0 {
			return
		}
		var audioCond string
		var audioPars []interface{}
		if keywords != "" {
			audioCond += ` AND a.voice_name LIKE ? OR b.label LIKE ?`
			audioPars = append(audioPars, keywords, keywords)
		}
		if audioId > 0 {
			audioCond += ` AND a.activity_voice_id = ?`
			audioPars = append(audioPars, audioId)
		}
		audioStartSize := 0
		if currentIndex > 1 {
			audioStartSize = (currentIndex - 1) * audioPageNum
		}
		audioTotal, audioList, e = models.GetMicroRoadShowAudioPageList(audioStartSize, audioPageNum, audioCond, audioPars)
	}()

	// 分页查询视频
	go func() {
		defer wg.Done()
		// 如果筛选条件为指定音频ID则不做视频查询
		if audioId > 0 {
			return
		}
		var videoCond string
		var videoPars []interface{}
		if keywords != "" {
			videoCond += ` AND video_name LIKE ?`
			videoPars = append(videoPars, keywords)
		}
		if videoId > 0 {
			videoCond += ` AND video_id = ?`
			videoPars = append(videoPars, videoId)
		}
		videoStartSize := 0
		if currentIndex > 1 {
			videoStartSize = (currentIndex - 1) * videoPageNum
		}
		videoTotal, videoList, e = models.GetMicroRoadShowVideoPageList(videoStartSize, audioPageNum, videoCond, videoPars)
	}()

	wg.Wait()

	if e != nil {
		err = errors.New("获取微路演音视频列表失败, Err: " + e.Error())
		return
	}

	// 按比例组合列表
	audioLen := len(audioList)
	videoLen := len(videoList)
	for i := 0; i < sliceNum; i++ {
		// 音频
		a := i * audioRatio  // 0 4 8 12
		oa := a + audioRatio // 4 8 12 16
		if oa <= audioLen {
			for k1 := a; k1 < oa; k1++ {
				respList = append(respList, audioList[k1])
			}
		}
		// 视频
		b := i * videoRatio  // 0 1 2 3
		ob := b + videoRatio // 1 2 3 4
		if ob <= videoLen {
			for k2 := b; k2 < ob; k2++ {
				respList = append(respList, videoList[k2])
			}
		}
	}
	total = audioTotal + videoTotal
	return
}

// getMicroRoadShowDataRatio 获取微路演列表数据音视频配比
func getMicroRoadShowDataRatio(pageSize int) (audioRatio, videoRatio, audioPageNum, videoPageNum, sliceNum int, err error) {
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	key := models.MicroRoadShowListDataRatioConfigKey
	config, e := models.GetConfigByCode(key)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("获取微路演列表数据量配置失败, Err: " + e.Error())
		return
	}

	// 默认音频视频展示比例为4:1
	ratio := "4:1"
	if config != nil {
		ratio = config.ConfigValue
	}
	ratioArr := strings.Split(ratio, ":")
	if len(ratioArr) != 2 {
		err = errors.New("微路演列表数据量配比有误")
		return
	}
	audioRatio, e = strconv.Atoi(ratioArr[0])
	if e != nil {
		err = errors.New("微路演列表数据量配比有误")
		return
	}
	videoRatio, e = strconv.Atoi(ratioArr[1])
	if e != nil {
		err = errors.New("微路演列表数据量配比有误")
		return
	}
	totalRatio := audioRatio + videoRatio
	if totalRatio == 0 {
		err = errors.New("微路演列表数据量配比有误")
		return
	}

	// 每比率对应数量(向上取整)
	sliceNum = int(math.Ceil(float64(pageSize) / float64(totalRatio)))
	audioPageNum = audioRatio * sliceNum
	videoPageNum = videoRatio * sliceNum

	return
}

// GetMicroRoadShowDefaultImgConfig 获取微路演默认图配置
func GetMicroRoadShowDefaultImgConfig() (audioMap, videoMap map[int]string, err error) {
	audioMap = make(map[int]string, 0)
	videoMap = make(map[int]string, 0)
	key := models.MicroRoadshowDefaultImgKey
	conf, e := models.GetConfigByCode(key)
	if e != nil {
		err = errors.New("获取微路演默认图配置失败, Err: " + e.Error())
		return
	}
	if conf.ConfigValue == "" {
		err = errors.New("获取微路演默认图配置有误")
		return
	}
	list := new(models.MicroRoadShowDefaultImgList)
	if e = json.Unmarshal([]byte(conf.ConfigValue), &list); e != nil {
		err = errors.New("微路演默认图配置配置值解析失败, Err: " + e.Error())
		return
	}
	audioList := list.Audio
	for i := range audioList {
		audioMap[audioList[i].ChartPermissionId] = audioList[i].ImgUrl
	}
	videoList := list.Video
	for i := range videoList {
		videoMap[videoList[i].ChartPermissionId] = videoList[i].ImgUrl
	}
	return
}

// GetHomeNewestList 获取首页最新列表
func GetHomeNewestList(userId, companyId int, condition string, pars []interface{}) (resp []*models.HomeArticle, total int, err error) {
	resp = make([]*models.HomeArticle, 0)
	unionList, e := models.GetHomeNewestListUnionList(condition, pars, 0, 20)
	if e != nil {
		err = errors.New("获取首页最新列表失败")
		return
	}
	unionTotal, e := models.GetHomeNewestListUnionCount(condition, pars)
	if e != nil {
		err = errors.New("获取首页最新列表总数失败")
		return
	}
	total = unionTotal

	// 用户权限
	authInfo, permissionArr, e := GetUserRaiPermissionInfo(userId, companyId)
	if e != nil {
		err = errors.New("获取用户权限失败, Err: " + e.Error())
		return
	}

	// 获取默认图配置
	audioMap, videoMap, e := GetMicroRoadShowDefaultImgConfig()
	if e != nil {
		err = errors.New("获取微路演默认图配置失败, Err: " + e.Error())
		return
	}

	// 此处没有直接使用HomeArticle结构体而是多加了一层, 纯粹是为了方便前端区分纪要和微路演音频=_=!
	for _, v := range unionList {
		item := new(models.HomeArticle)
		item.HomeType = v.HomeType
		// 纪要
		if item.HomeType == 0 {
			item.ArticleId = v.ArticleId
			item.Title = v.Title
			item.TitleEn = v.TitleEn
			item.UpdateFrequency = v.UpdateFrequency
			item.CreateDate = v.CreateDate
			item.PublishDate = v.PublishDate
			item.Body = v.Body
			item.BodyHtml = v.BodyHtml
			item.Abstract = v.Abstract
			item.CategoryName = v.CategoryName
			item.SubCategoryName = v.SubCategoryName
			item.ExpertBackground = v.ExpertBackground
			item.IsResearch = v.IsResearch
			item.Pv = v.Pv
			item.ImgUrlPc = v.ImgUrlPc
			item.CategoryId = v.CategoryId
			item.HttpUrl = v.HttpUrl
			item.IsNeedJump = v.IsNeedJump
			item.Source = v.Source
			item.Annotation = v.Annotation
		}
		// 音频
		if v.HomeType == 1 {
			ad := new(models.MicroAudioUnionList)
			ad.Id = v.Id
			ad.AudioTitle = v.AudioTitle
			ad.AudioResourceUrl = v.AudioResourceUrl
			ad.AudioType = v.AudioType
			ad.AudioPublishTime = v.AudioPublishTime
			ad.AudioImgUrl = v.AudioImgUrl
			ad.AudioChartPermissionId = v.AudioChartPermissionId
			ad.AudioChartPermissionName = v.AudioChartPermissionName
			ad.AudioPlaySeconds = v.AudioPlaySeconds
			ad.AudioPlaySeconds = v.AudioPlaySeconds
			ad.AudioActivityId = v.AudioActivityId
			item.MicroAudio = ad
			// 默认图
			if ad.AudioImgUrl == "" {
				if ad.AudioType == 1 {
					ad.AudioImgUrl = audioMap[ad.AudioChartPermissionId]
				} else {
					ad.AudioImgUrl = videoMap[ad.AudioChartPermissionId]
				}
			}
			// 权限
			au := new(models.UserPermissionAuthInfo)
			au.SellerName = authInfo.SellerName
			au.SellerMobile = authInfo.SellerMobile
			au.HasPermission = authInfo.HasPermission
			if authInfo.HasPermission == 1 {
				if !utils.InArrayByStr(permissionArr, ad.AudioChartPermissionName) {
					au.HasPermission = 2
				}
			}
			if authInfo.HasPermission == 2 {
				if ad.AudioType == 1 {
					au.PopupMsg = UserPermissionPopupMsgCallActivity
				} else {
					au.PopupMsg = UserPermissionPopupMsgCallMicroVideo
				}
			}
			if authInfo.HasPermission == 3 {
				if ad.AudioType == 1 {
					au.PopupMsg = UserPermissionPopupMsgApplyActivity
				} else {
					au.PopupMsg = UserPermissionPopupMsgApplyMicroVideo
				}
			}
			ad.AuthInfo = au
		}
		resp = append(resp, item)
	}
	return
}