926 lines
24 KiB
Go
926 lines
24 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"github.com/pkg/errors"
|
||
"go-common/app/admin/main/videoup/model/archive"
|
||
"go-common/app/admin/main/videoup/model/manager"
|
||
"go-common/app/admin/main/videoup/model/search"
|
||
accApi "go-common/app/service/main/account/api"
|
||
"go-common/library/database/elastic"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
bm "go-common/library/net/http/blademaster"
|
||
"go-common/library/xstr"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
)
|
||
|
||
// SearchVideo search video
|
||
func (s *Service) SearchVideo(c context.Context, p *search.VideoParams) (result *search.VideoResultData, err error) {
|
||
var (
|
||
aids, cids,
|
||
vids, mids,
|
||
tids, tagIds,
|
||
xcodes []int64
|
||
fNames []string
|
||
ps = 30
|
||
sort string
|
||
order string
|
||
isMonitor bool //是否查看监控列表
|
||
moniTotal int //监控列表的总数量
|
||
moniMap map[int64]int //监控列表的视频id map。键：vid；值：time（进入监控的时间）
|
||
tags map[int64]string
|
||
aStates, vStates map[int64]int
|
||
members map[int64]*accApi.Info
|
||
eReq *elastic.Request
|
||
wg sync.WaitGroup
|
||
)
|
||
es := elastic.NewElastic(nil)
|
||
//Page
|
||
if p.Ps != 0 {
|
||
ps = p.Ps
|
||
}
|
||
if p.Pn == 0 {
|
||
p.Pn = 1
|
||
}
|
||
if p.OrderType == "1" {
|
||
eReq = es.NewRequest("archive_video_score")
|
||
} else {
|
||
eReq = es.NewRequest("archive_video")
|
||
}
|
||
eReq.Index("archive_video")
|
||
|
||
if p.Keywords != "" {
|
||
eReq.WhereLike([]string{"arc_title", "arc_author"}, []string{p.Keywords}, true, elastic.LikeLevelLow)
|
||
}
|
||
if p.ArcTitle != "" {
|
||
eReq.WhereLike([]string{"arc_title"}, []string{p.ArcTitle}, false, elastic.LikeLevelLow)
|
||
}
|
||
if p.Aids != "" {
|
||
p.Aids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Aids, ",")))), ",")
|
||
if aids, err = s.SplitInts(p.Aids); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
if len(aids) > ps {
|
||
ps = len(aids)
|
||
}
|
||
eReq.WhereIn("aid", aids)
|
||
}
|
||
|
||
//监控结果列表逻辑
|
||
if p.MonitorList != "" {
|
||
isMonitor = true
|
||
var (
|
||
rid int
|
||
)
|
||
moniP := strings.Split(p.MonitorList, "_")
|
||
if len(moniP) != 3 {
|
||
err = errors.New("监控列表标识字段格式错误")
|
||
return
|
||
}
|
||
if rid, err = strconv.Atoi(moniP[2]); err != nil {
|
||
return
|
||
}
|
||
if moniMap, err = s.MonitorStayOids(c, int64(rid)); err != nil {
|
||
return
|
||
}
|
||
moniTotal = len(moniMap)
|
||
for vid := range moniMap {
|
||
vids = append(vids, vid)
|
||
}
|
||
if len(vids) == 0 {
|
||
result = &search.VideoResultData{
|
||
Result: []*search.Video{},
|
||
}
|
||
return
|
||
}
|
||
if len(vids) > ps {
|
||
ps = len(vids)
|
||
}
|
||
eReq.WhereIn("vid", vids)
|
||
}
|
||
if p.Cids != "" {
|
||
p.Cids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Cids, ",")))), ",")
|
||
if cids, err = s.SplitInts(p.Cids); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
if len(cids) > ps {
|
||
ps = len(cids)
|
||
}
|
||
eReq.WhereIn("cid", cids)
|
||
}
|
||
if p.Vids != "" {
|
||
if vids, err = s.SplitInts(p.Vids); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
if len(vids) > ps {
|
||
ps = len(vids)
|
||
}
|
||
eReq.WhereIn("vid", vids)
|
||
}
|
||
if p.ArcMids != "" {
|
||
if mids, err = s.SplitInts(p.ArcMids); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
if len(mids) > ps {
|
||
ps = len(mids)
|
||
}
|
||
eReq.WhereIn("arc_mid", mids)
|
||
}
|
||
if p.Xcode != "" {
|
||
if xcodes, err = s.SplitInts(p.Xcode); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
eReq.WhereIn("xcode_state", xcodes)
|
||
}
|
||
|
||
if p.TypeID != "" {
|
||
if tids, err = s.SplitInts(p.TypeID); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
for _, tid := range tids {
|
||
if ids, ok := s.typeCache2[int16(tid)]; ok {
|
||
tids = append(tids, ids...)
|
||
}
|
||
}
|
||
eReq.WhereIn("arc_typeid", tids)
|
||
}
|
||
if p.Filename != "" {
|
||
if fNames = strings.Split(p.Filename, ","); err != nil {
|
||
err = ecode.RequestErr
|
||
return
|
||
}
|
||
eReq.WhereIn("filename", fNames)
|
||
}
|
||
if p.TagID != "" {
|
||
eReq.WhereEq("tag_id", p.TagID)
|
||
}
|
||
|
||
if p.Status != "" {
|
||
if p.Status == "-100" {
|
||
eReq.WhereEq("relation_state", "-100")
|
||
p.Status = ""
|
||
} else {
|
||
eReq.WhereEq("relation_state", "0")
|
||
eReq.WhereEq("status", p.Status)
|
||
}
|
||
}
|
||
if p.UserType != "" {
|
||
eReq.WhereEq("user_type", p.UserType)
|
||
}
|
||
if p.DurationFrom != "" && p.DurationTo != "" {
|
||
eReq.WhereRange("duration", p.DurationFrom, p.DurationTo, elastic.RangeScopeLcRc)
|
||
} else if p.DurationFrom != "" && p.DurationTo == "" {
|
||
eReq.WhereRange("duration", p.DurationFrom, "", elastic.RangeScopeLcRc)
|
||
} else if p.DurationFrom == "" && p.DurationTo != "" {
|
||
eReq.WhereRange("duration", "", p.DurationTo, elastic.RangeScopeLcRc)
|
||
}
|
||
|
||
//Order by
|
||
if p.Order != "" {
|
||
order = p.Order
|
||
} else if p.Action == "trash" {
|
||
order = "v_mtime"
|
||
} else {
|
||
order = "arc_senddate"
|
||
}
|
||
if p.Sort == 1 {
|
||
sort = "asc"
|
||
} else {
|
||
sort = "desc"
|
||
}
|
||
eReq.Order(order, sort)
|
||
|
||
//Page
|
||
eReq.Ps(ps)
|
||
eReq.Pn(p.Pn)
|
||
|
||
//Execute
|
||
log.Info("s.SearchVideo(%+v) SearchVideoQuery(%s)", p, eReq.Params())
|
||
if err = eReq.Scan(c, &result); err != nil {
|
||
log.Error("SearchVideoScan() error(%v)", err)
|
||
return
|
||
}
|
||
if result == nil {
|
||
log.Error("s.SearchVideo(%+v) search return nil result", p)
|
||
result = &search.VideoResultData{
|
||
Result: []*search.Video{},
|
||
}
|
||
return
|
||
}
|
||
if result.Result == nil {
|
||
log.Error("s.SearchVideo(%+v) search return nil video", p)
|
||
result.Result = []*search.Video{}
|
||
return
|
||
}
|
||
if len(result.Result) == 0 {
|
||
return
|
||
}
|
||
if isMonitor {
|
||
result.Page.Total = moniTotal
|
||
}
|
||
aids = []int64{}
|
||
vids = []int64{}
|
||
mids = []int64{}
|
||
for _, v := range result.Result {
|
||
if v.TagID != 0 {
|
||
tagIds = append(tagIds, v.TagID)
|
||
}
|
||
aids = append(aids, v.Aid)
|
||
vids = append(vids, v.Vid)
|
||
if v.ArcMid != 0 {
|
||
mids = append(mids, v.ArcMid)
|
||
}
|
||
}
|
||
//获取Tag名称
|
||
wg.Add(1)
|
||
go func(tags *map[int64]string) {
|
||
defer wg.Done()
|
||
if *tags, err = s.arc.TagNameMap(c, tagIds); err != nil {
|
||
log.Error("s.arc.TagNameMap(%v) error(%v)", tagIds, err)
|
||
err = nil
|
||
}
|
||
log.Info("s.arc.TagNameMap(%v) result(%v)", tagIds, tags)
|
||
}(&tags)
|
||
//获取数据库中的稿件状态
|
||
wg.Add(1)
|
||
go func(aStates *map[int64]int) {
|
||
defer wg.Done()
|
||
if *aStates, err = s.arc.ArcStateMap(c, aids); err != nil {
|
||
log.Error("s.arc.ArcStateMap(%v) error(%v)", aids, err)
|
||
err = nil
|
||
}
|
||
}(&aStates)
|
||
//获取数据库中视频的状态
|
||
wg.Add(1)
|
||
go func(vStates *map[int64]int) {
|
||
defer wg.Done()
|
||
if *vStates, err = s.arc.VideoStateMap(c, vids); err != nil {
|
||
log.Error("s.arc.VideoStateMap(%v) error(%v)", vids, err)
|
||
err = nil
|
||
}
|
||
}(&vStates)
|
||
//获取UP主信息
|
||
wg.Add(1)
|
||
go func(members *map[int64]*accApi.Info) {
|
||
defer wg.Done()
|
||
var infosReply *accApi.InfosReply
|
||
if infosReply, err = s.accRPC.Infos3(c, &accApi.MidsReq{Mids: mids}); err != nil {
|
||
log.Error("s.accRPC.Infos3(%v) error(%v)", mids, err)
|
||
err = nil
|
||
return
|
||
}
|
||
*members = infosReply.Infos
|
||
}(&members)
|
||
|
||
wg.Wait()
|
||
sInt, _ := strconv.Atoi(p.Status)
|
||
for i := 0; i < len(result.Result); i++ {
|
||
v := result.Result[i]
|
||
result.Result[i].ID = v.Vid
|
||
if vs, ok := vStates[v.Vid]; ok {
|
||
result.Result[i].Status = vs
|
||
}
|
||
//需要将status与查询条件中status不一致的视频剔除
|
||
if p.Status != "" && v.Status != sInt {
|
||
result.Result = append(result.Result[:i], result.Result[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
if tn, ok := tags[v.TagID]; ok {
|
||
result.Result[i].TagName = tn
|
||
}
|
||
if as, ok := aStates[v.Aid]; ok {
|
||
result.Result[i].ArcState = as
|
||
}
|
||
if m, ok := members[v.ArcMid]; ok {
|
||
result.Result[i].ArcAuthor = m.Name
|
||
}
|
||
if v.UserType == nil {
|
||
v.UserType = []int64{}
|
||
}
|
||
if v.UserGroup == nil {
|
||
v.UserGroup = []*manager.UpGroup{}
|
||
}
|
||
for _, tp := range v.UserType {
|
||
if up, ok := s.allUpGroupCache[tp]; ok {
|
||
result.Result[i].UserGroup = append(result.Result[i].UserGroup, up)
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// SearchCopyright search video copyright
|
||
func (s *Service) SearchCopyright(c context.Context, kw string) (result *search.CopyrightResultData, err error) {
|
||
return s.search.SearchCopyright(c, kw)
|
||
}
|
||
|
||
// SearchArchive 稿件搜索列表
|
||
func (s *Service) SearchArchive(c *bm.Context, p *search.ArchiveParams) (result *search.ArchiveResultData, err error) {
|
||
var (
|
||
round int
|
||
aids []int64
|
||
froms []int8
|
||
forbid string
|
||
tids []int64
|
||
pn = 1
|
||
ps = 30
|
||
isMonitor bool //是否查看监控列表
|
||
moniMap map[int64]int //监控列表的视频id map。键：vid；值：time（进入监控的时间）
|
||
nPGCAids, sPGCAids, cPGCAids, misAids []int64
|
||
additMap map[int64]*archive.Addit
|
||
tips string
|
||
orders = map[string]string{
|
||
"mtime": "",
|
||
"pubtime": "",
|
||
"ctime": "",
|
||
"dm_count": "",
|
||
"fav_count": "",
|
||
}
|
||
eReq *elastic.Request
|
||
)
|
||
es := elastic.NewElastic(nil)
|
||
if p.OrderType != "" {
|
||
eReq = es.NewRequest("archive_score")
|
||
} else {
|
||
eReq = es.NewRequest("archive")
|
||
}
|
||
eReq.Index("archive")
|
||
if p.Ps != 0 {
|
||
ps = p.Ps
|
||
}
|
||
if ps > 1000 {
|
||
ps = 1000
|
||
}
|
||
//分区 逻辑
|
||
if p.TypeID != "" {
|
||
if tids, err = s.SplitInts(p.TypeID); err != nil {
|
||
return
|
||
}
|
||
for _, tid := range tids {
|
||
if ids, ok := s.typeCache2[int16(tid)]; ok {
|
||
tids = append(tids, ids...)
|
||
}
|
||
}
|
||
}
|
||
//特殊分区逻辑
|
||
if p.SpecialType != "" {
|
||
for i := 0; i < len(tids); i++ { //剔除特殊/普通分区id
|
||
_, ok := s.adtTpsCache[int16(tids[i])]
|
||
if (ok && p.SpecialType == "0") || (!ok && p.SpecialType == "1") {
|
||
tids = append(tids, tids...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
if len(tids) > 0 {
|
||
eReq.WhereIn("typeid", tids)
|
||
if len(tids) > ps {
|
||
ps = len(tids)
|
||
}
|
||
}
|
||
|
||
if p.UserType != "" && p.UserType != "0" {
|
||
eReq.WhereEq("user_type", p.UserType)
|
||
}
|
||
//up_from 逻辑
|
||
if p.UpFroms != "" {
|
||
var upFroms []int64
|
||
if upFroms, err = s.SplitInts(p.UpFroms); err != nil {
|
||
return
|
||
}
|
||
eReq.WhereIn("up_from", upFroms)
|
||
} else { //默认去除PGC稿件
|
||
eReq.WhereIn("up_from", []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera})
|
||
eReq.WhereNot(elastic.NotTypeIn, "up_from")
|
||
}
|
||
//Round 逻辑
|
||
if p.Round != "" {
|
||
if round, err = strconv.Atoi(p.Round); err != nil {
|
||
log.Warn("http.searchArchive() http.PGCListLogic() err(%v)", err)
|
||
return
|
||
}
|
||
if round == 1 {
|
||
eReq.WhereIn("round", []int8{1, archive.RoundReviewSecond})
|
||
} else if round == 2 {
|
||
eReq.WhereIn("round", []int8{2, archive.RoundEnd})
|
||
} else {
|
||
eReq.WhereIn("round", []int{round})
|
||
}
|
||
}
|
||
//Aid 逻辑
|
||
if p.Aids != "" {
|
||
p.Aids = strings.Replace(p.Aids, "\n", ",", -1)
|
||
p.Aids = strings.Join(Slice2String(SliceUnique(Slice2Interface(strings.Split(p.Aids, ",")))), ",")
|
||
if aids, err = s.SplitInts(p.Aids); err != nil {
|
||
return
|
||
}
|
||
eReq.WhereIn("id", aids)
|
||
}
|
||
//Mid 逻辑
|
||
if p.Mids != "" {
|
||
var mids []int64
|
||
p.Mids = strings.Replace(p.Mids, "\n", ",", -1)
|
||
if mids, err = s.SplitInts(p.Mids); err != nil {
|
||
return
|
||
}
|
||
eReq.WhereIn("mid", mids)
|
||
if len(mids) > ps {
|
||
ps = len(mids)
|
||
}
|
||
}
|
||
if p.State != "" {
|
||
states := strings.Split(p.State, ",")
|
||
eReq.WhereIn("state", states)
|
||
}
|
||
if p.Access != "" {
|
||
eReq.WhereEq("access", p.Access)
|
||
}
|
||
if p.Copyright != "" {
|
||
eReq.WhereEq("copyright", p.Copyright)
|
||
}
|
||
if p.IsFirst != "" {
|
||
eReq.WhereEq("is_first", p.IsFirst)
|
||
}
|
||
|
||
//PGC 列表逻辑
|
||
if p.PGCList != "" {
|
||
if err = s.PGCListLogic(c, p.PGCList, p.State, froms, eReq); err != nil {
|
||
return
|
||
}
|
||
if c.IsAborted() { //检查鉴权
|
||
return
|
||
}
|
||
}
|
||
|
||
//搜索关键字逻辑
|
||
if p.Keywords != "" {
|
||
fields := []string{"title", "content", "tag"}
|
||
if p.KwFields != "" {
|
||
fields = strings.Split(p.KwFields, ",")
|
||
for i := 0; i < len(fields); i++ {
|
||
if fields[i] == "channel" {
|
||
fields[i] = "tid_names"
|
||
break
|
||
}
|
||
}
|
||
}
|
||
eReq.WhereLike(fields, []string{p.Keywords}, true, elastic.LikeLevelLow)
|
||
}
|
||
if p.NoMission == "" { //默认去掉活动稿件
|
||
p.NoMission = "1"
|
||
}
|
||
//禁止项逻辑
|
||
if p.Attr == strconv.Itoa(archive.ForbidAttrChannel) {
|
||
forbid = "channel"
|
||
eReq.WhereEq("channel_group_id", archive.FlowGroupNoChannel)
|
||
eReq.WhereEq("channel_pool", archive.PoolArcForbid)
|
||
eReq.WhereEq("channel_state", archive.FlowOpen)
|
||
} else if p.Attr == strconv.Itoa(archive.ForbidAttrHot) {
|
||
forbid = "hot"
|
||
eReq.WhereEq("hot_group_id", archive.FlowGroupNoHot)
|
||
eReq.WhereEq("hot_pool", archive.PoolArcForbid)
|
||
eReq.WhereEq("hot_state", archive.FlowOpen)
|
||
} else if p.Attr != "" {
|
||
attr := 0
|
||
attr, err = strconv.Atoi(p.Attr)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if (uint(attr-1) == archive.AttrBitIsPorder) && int8(round) != archive.RoundReviewFlow {
|
||
s.auth.Permit("PRIVATE_ORDER_ALL")(c) //鉴权
|
||
if c.IsAborted() {
|
||
return
|
||
}
|
||
p.NoMission = "" //不做活动稿件剔除
|
||
}
|
||
eReq.WhereEq("attribute", attr)
|
||
}
|
||
|
||
//回查列表逻辑
|
||
if p.Review != "" {
|
||
if p.ReviewState == "" {
|
||
p.ReviewState = strconv.Itoa(archive.RecheckStateWait)
|
||
}
|
||
switch p.Review {
|
||
case strconv.Itoa(archive.TypeChannelRecheck):
|
||
s.auth.Permit("CHANNEL_REVIEW")(c)
|
||
eReq.WhereEq("recheck_ch_type", p.Review)
|
||
eReq.WhereEq("recheck_ch_staten", p.ReviewState)
|
||
case strconv.Itoa(archive.TypeHotRecheck):
|
||
p.NoMission = ""
|
||
s.auth.Permit("ARC_HOT_REVIEW")(c)
|
||
eReq.WhereEq("recheck_hot_type", p.Review)
|
||
eReq.WhereEq("recheck_hot_staten", p.ReviewState)
|
||
|
||
case strconv.Itoa(archive.TypeInspireRecheck):
|
||
p.NoMission = ""
|
||
s.auth.Permit("ARC_INSPIRE_REVIEW")(c)
|
||
eReq.WhereEq("recheck_inspire_type", p.Review)
|
||
eReq.WhereEq("recheck_inspire_staten", p.ReviewState)
|
||
}
|
||
if c.IsAborted() {
|
||
return
|
||
}
|
||
p.IsOrder = 0
|
||
} else if p.Round == strconv.Itoa(int(archive.RoundAuditUGCPayFlow)) { //付费列表需要展示活动稿件
|
||
p.NoMission = ""
|
||
}
|
||
//活动逻辑
|
||
if p.MissionID != "" {
|
||
eReq.WhereEq("mission_id", p.MissionID)
|
||
}
|
||
if p.MissionID != "" || p.NoMission == "0" { //需要活动稿件
|
||
eReq.WhereRange("mission_id", 1, nil, elastic.RangeScopeLcRo)
|
||
} else if p.NoMission == "1" { //不需要活动稿件
|
||
eReq.WhereRange("mission_id", 0, nil, elastic.RangeScopeLoRo)
|
||
eReq.WhereNot(elastic.NotTypeRange, "mission_id")
|
||
}
|
||
//商单逻辑
|
||
if p.IsOrder == 1 { //商单 order_id 大于0
|
||
eReq.WhereRange("order_id", 0, nil, elastic.RangeScopeLoRo)
|
||
if p.OrderId != "" {
|
||
eReq.WhereEq("order_id", p.OrderId)
|
||
}
|
||
} else if forbid == "" && p.Review == "" { //除了禁止列表和回查列表，都要去除商单order_id <= 0
|
||
eReq.WhereRange("order_id", 0, nil, elastic.RangeScopeLoRo)
|
||
eReq.WhereNot(elastic.NotTypeRange, "order_id")
|
||
}
|
||
|
||
//监控结果列表逻辑
|
||
if p.MonitorList != "" {
|
||
eReq = es.NewRequest("archive_score") //去掉其它条件
|
||
eReq.Index("archive")
|
||
isMonitor = true
|
||
var (
|
||
rid int
|
||
)
|
||
moniP := strings.Split(p.MonitorList, "_")
|
||
if len(moniP) != 3 {
|
||
err = errors.New("监控列表标识字段格式错误")
|
||
return
|
||
}
|
||
if rid, err = strconv.Atoi(moniP[2]); err != nil {
|
||
return
|
||
}
|
||
if moniMap, err = s.MonitorStayOids(c, int64(rid)); err != nil {
|
||
return
|
||
}
|
||
for aid := range moniMap {
|
||
aids = append(aids, aid)
|
||
}
|
||
if len(aids) == 0 {
|
||
result = &search.ArchiveResultData{
|
||
Result: []*search.Archive{},
|
||
}
|
||
return
|
||
}
|
||
/*if len(aids) > ps {
|
||
ps = len(aids)
|
||
}*/
|
||
eReq.WhereIn("id", aids)
|
||
}
|
||
//分页、排序
|
||
if p.Pn > 0 {
|
||
pn = p.Pn
|
||
}
|
||
if _, ok := orders[p.Order]; !ok {
|
||
p.Order = "ctime"
|
||
}
|
||
if p.Order == "" {
|
||
p.Order = "ctime"
|
||
}
|
||
eReq.OrderScoreFirst(p.ScoreFirst != "0")
|
||
|
||
if p.Sort == "" {
|
||
p.Sort = "desc"
|
||
}
|
||
eReq.Order(p.Order, p.Sort)
|
||
eReq.Pn(pn)
|
||
eReq.Ps(ps)
|
||
log.Info("SearchArchiveQuery(%s)", eReq.Params())
|
||
if err = eReq.Scan(c, &result); err != nil {
|
||
log.Error("SearchArchiveQuery() error(%v)", err)
|
||
return
|
||
}
|
||
if isMonitor {
|
||
result.MoniAids = moniMap
|
||
}
|
||
if len(aids) > 0 && !isMonitor {
|
||
//获取稿件addit
|
||
if additMap, err = s.arc.AdditBatch(c, aids); err != nil {
|
||
log.Error("s.arc.AdditBatch(%v) error(%v) additMap(%v)", aids, err, additMap)
|
||
err = nil
|
||
}
|
||
for _, v := range aids {
|
||
if _, ok := additMap[v]; ok {
|
||
switch additMap[v].UpFrom {
|
||
case archive.UpFromPGC:
|
||
nPGCAids = append(nPGCAids, v)
|
||
case archive.UpFromSecretPGC:
|
||
sPGCAids = append(sPGCAids, v)
|
||
case archive.UpFromCoopera:
|
||
cPGCAids = append(cPGCAids, v)
|
||
}
|
||
if additMap[v].MissionID > 0 {
|
||
misAids = append(misAids, v)
|
||
}
|
||
}
|
||
}
|
||
|
||
if len(nPGCAids) > 0 {
|
||
tips += "PGC稿件：" + xstr.JoinInts(nPGCAids)
|
||
}
|
||
if len(sPGCAids) > 0 {
|
||
tips += "PGC机密：" + xstr.JoinInts(sPGCAids)
|
||
}
|
||
if len(cPGCAids) > 0 {
|
||
tips += "PGC嵌套：" + xstr.JoinInts(cPGCAids)
|
||
}
|
||
if len(misAids) > 0 {
|
||
tips += "活动稿件：" + xstr.JoinInts(misAids)
|
||
}
|
||
|
||
result.Tips = tips
|
||
}
|
||
if err = s.KneadArchiveResult(c, result, p, additMap); err != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// PGCListLogic PGC列表查询相关逻辑
|
||
func (s *Service) PGCListLogic(c *bm.Context, lnStr string, pState string, froms []int8, eReq *elastic.Request) (err error) {
|
||
var (
|
||
state int ////临时存储PGC列表中查询的state状态，需要和pState字符串配合使用！
|
||
lni int
|
||
ln int8
|
||
pgcConfig map[int8]*search.ArcPGCConfig
|
||
)
|
||
|
||
if lni, err = strconv.Atoi(lnStr); err != nil {
|
||
log.Warn("s.PGCListLogic() err(%v)", err)
|
||
return
|
||
}
|
||
ln = int8(lni)
|
||
if state, err = strconv.Atoi(pState); err != nil {
|
||
err = errors.New("PGC列表中的state参数错误")
|
||
return
|
||
}
|
||
if len(froms) != 0 {
|
||
for _, v := range froms {
|
||
if v != archive.UpFromPGC && v != archive.UpFromSecretPGC && v != archive.UpFromCoopera {
|
||
err = errors.New("PGC列表中的from参数错误")
|
||
break
|
||
}
|
||
}
|
||
}
|
||
pgcConfig = make(map[int8]*search.ArcPGCConfig)
|
||
|
||
//PGC常规二审列表 round=10 state=-1,-30,-40,-6 upfrom=1
|
||
pgcConfig[1] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromPGC},
|
||
Rounds: []int8{
|
||
archive.RoundBegin,
|
||
archive.RoundAuditSecond,
|
||
},
|
||
States: []int8{
|
||
archive.RecheckStateWait,
|
||
archive.StateForbidSubmit,
|
||
archive.StateForbidUserDelay,
|
||
archive.StateForbidFixed,
|
||
},
|
||
InState: pState != "" && state < 0,
|
||
Auth: "PGC_NORMAL_2",
|
||
}
|
||
//PGC常规三审列表 round=20 state=-1,-30,-40,-6 upfrom=1
|
||
pgcConfig[2] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromPGC},
|
||
Rounds: []int8{archive.RoundAuditThird},
|
||
States: []int8{
|
||
archive.RecheckStateWait,
|
||
archive.StateForbidSubmit,
|
||
archive.StateForbidUserDelay,
|
||
archive.StateForbidFixed,
|
||
},
|
||
InState: pState != "" && state < 0,
|
||
Auth: "PGC_NORMAL_3",
|
||
}
|
||
//PGC机密待审列表 state=-1,-30,-40,-6 upfrom=5
|
||
pgcConfig[3] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromSecretPGC},
|
||
Rounds: []int8{},
|
||
States: []int8{
|
||
archive.RecheckStateWait,
|
||
archive.StateForbidSubmit,
|
||
archive.StateForbidUserDelay,
|
||
archive.StateForbidFixed,
|
||
},
|
||
InState: pState != "" && state < 0,
|
||
Auth: "PGC_SECRET_WAIT",
|
||
}
|
||
//PGC机密回查列表 round=90 state≥0 upfrom=5
|
||
pgcConfig[4] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromSecretPGC},
|
||
Rounds: []int8{archive.RoundTriggerClick},
|
||
States: []int8{
|
||
archive.StateOpen,
|
||
archive.StateOrange,
|
||
},
|
||
InState: pState != "" && state >= 0,
|
||
Auth: "PGC_SECRET_RECHECK",
|
||
}
|
||
|
||
//PGC全部已过审 round=99 state≥0 upfrom=1,5,6
|
||
pgcConfig[5] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera},
|
||
Rounds: []int8{archive.RoundEnd},
|
||
States: []int8{
|
||
archive.StateOpen,
|
||
archive.StateOrange,
|
||
},
|
||
InState: pState != "" && state >= 0,
|
||
Auth: "PGC_OPEN",
|
||
}
|
||
|
||
//全部打回列表 state=-2,-3,-4,-7,-11,-16,-100 up_from=1,5,6
|
||
pgcConfig[6] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromPGC, archive.UpFromSecretPGC, archive.UpFromCoopera},
|
||
Rounds: []int8{},
|
||
States: []int8{
|
||
archive.StateForbidRecycle,
|
||
archive.StateForbidPolice,
|
||
archive.StateForbidLock,
|
||
archive.StateForbidLater,
|
||
archive.StateForbidFixing,
|
||
archive.StateForbidXcodeFail,
|
||
archive.StateForbidUpDelete,
|
||
},
|
||
InState: pState != "" && state < 0,
|
||
Auth: "PGC_RECICLE",
|
||
}
|
||
|
||
//合作方嵌套列表 state=-1,-30,-6,-40 up_from=6
|
||
pgcConfig[7] = &search.ArcPGCConfig{
|
||
UPFrom: []int8{archive.UpFromCoopera},
|
||
Rounds: []int8{},
|
||
States: []int8{
|
||
archive.StateForbidWait,
|
||
archive.StateForbidSubmit,
|
||
archive.StateForbidFixed,
|
||
archive.StateForbidUserDelay,
|
||
},
|
||
InState: pState != "" && state < 0,
|
||
Auth: "PGC_PARTNER",
|
||
}
|
||
if _, ok := pgcConfig[ln]; !ok || pgcConfig[ln] == nil {
|
||
err = errors.New("PGC列表不存在")
|
||
return
|
||
}
|
||
if !pgcConfig[ln].InState { //如果前端传了合法的state，则加上state条件
|
||
pgcConfig[ln].States = []int8{int8(state)}
|
||
}
|
||
if len(froms) != 0 { //如果前端传了up_from，则加上up_from条件
|
||
pgcConfig[ln].UPFrom = froms
|
||
}
|
||
if len(pgcConfig[ln].UPFrom) == 0 {
|
||
err = errors.New("PGC列表中的UPFrom不能设置为空")
|
||
return
|
||
}
|
||
s.auth.Permit(pgcConfig[ln].Auth)(c) //鉴权
|
||
eReq.WhereIn("up_from", pgcConfig[ln].UPFrom)
|
||
eReq.WhereIn("state", pgcConfig[ln].States)
|
||
eReq.WhereIn("round", pgcConfig[ln].Rounds)
|
||
return
|
||
}
|
||
|
||
// KneadArchiveResult 拼接稿件数据
|
||
func (s *Service) KneadArchiveResult(c *bm.Context, result *search.ArchiveResultData, p *search.ArchiveParams, additMap map[int64]*archive.Addit) (err error) {
|
||
var (
|
||
mids, aids []int64
|
||
ups map[int64]*accApi.Card
|
||
rStates map[int64]int8
|
||
chNames map[int64][]string
|
||
archives = result.Result
|
||
dbArchives map[int64]*archive.Archive
|
||
wg sync.WaitGroup
|
||
)
|
||
for _, v := range archives {
|
||
if v.Mid != 0 {
|
||
mids = append(mids, v.Mid)
|
||
}
|
||
aids = append(aids, v.ID)
|
||
}
|
||
|
||
//获取频道信息
|
||
wg.Add(1)
|
||
go func(chNames *map[int64][]string) {
|
||
defer wg.Done()
|
||
*chNames = s.ChannelNamesByAids(c, aids)
|
||
}(&chNames)
|
||
|
||
wg.Add(1)
|
||
go func(dbArchives *map[int64]*archive.Archive) {
|
||
defer wg.Done()
|
||
if *dbArchives, err = s.arc.Archives(c, aids); err != nil || dbArchives == nil {
|
||
log.Error("s.arc.Archives(%v) error(%v) archives(%v)", mids, err, dbArchives)
|
||
err = nil
|
||
}
|
||
}(&dbArchives)
|
||
|
||
//获取UP主信息
|
||
wg.Add(1)
|
||
go func(ups *map[int64]*accApi.Card) {
|
||
defer wg.Done()
|
||
if *ups, err = s.upCards(c, mids); err != nil || ups == nil {
|
||
log.Error("s.upCards(%v) error(%v) ups(%v)", mids, err, ups)
|
||
err = nil
|
||
*ups = make(map[int64]*accApi.Card)
|
||
}
|
||
}(&ups)
|
||
//获取回查稿件实时状态
|
||
if p.Review != "" && p.ReviewState != "" {
|
||
wg.Add(1)
|
||
go func(rStates *map[int64]int8) {
|
||
defer wg.Done()
|
||
tp, _ := strconv.Atoi(p.Review)
|
||
if *rStates, err = s.arc.RecheckStateMap(c, tp, aids); err != nil || rStates == nil {
|
||
log.Error("s.arc.RecheckStateMap(%v,%v) error(%v) rStates(%v)", tp, aids, err, rStates)
|
||
err = nil
|
||
}
|
||
}(&rStates)
|
||
}
|
||
|
||
wg.Wait()
|
||
for i := 0; i < len(archives); i++ {
|
||
v := archives[i]
|
||
if a, ok := dbArchives[v.ID]; ok && a.Cover != "" {
|
||
archives[i].Cover = coverURL(a.Cover)
|
||
}
|
||
if m, ok := ups[v.Mid]; ok {
|
||
archives[i].Official = m.Official
|
||
archives[i].Author = m.Name
|
||
}
|
||
if p.Review != "" && p.ReviewState != "" {
|
||
if state, ok := rStates[v.ID]; ok { //将与查询条件中回查状态不一致的稿件剔除
|
||
rState, err := strconv.Atoi(p.ReviewState)
|
||
if err != nil {
|
||
log.Error("s.KneadArchive() error(%v) reviewState(%v)", err, p.ReviewState)
|
||
err = nil
|
||
continue
|
||
}
|
||
if state != int8(rState) {
|
||
archives = append(archives[:i], archives[i+1:]...)
|
||
i--
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
if _, ok := additMap[v.ID]; ok {
|
||
archives[i].UpFrom = additMap[v.ID].UpFrom
|
||
if additMap[v.ID].MissionID > 0 {
|
||
archives[i].MissionID = additMap[v.ID].MissionID
|
||
}
|
||
}
|
||
if names, ok := chNames[v.ID]; ok {
|
||
archives[i].TagNames = names
|
||
}
|
||
if archives[i].TagNames == nil {
|
||
archives[i].TagNames = []string{}
|
||
}
|
||
if archives[i].UserType == nil {
|
||
archives[i].UserType = []int64{}
|
||
}
|
||
if v.UserGroup == nil {
|
||
v.UserGroup = []*manager.UpGroup2{}
|
||
}
|
||
if v.Attribute == nil {
|
||
v.Attribute = []int{}
|
||
}
|
||
v.Attrs = v.Attribute
|
||
for _, tp := range v.UserType {
|
||
if up, ok := s.allUpGroupCache[tp]; ok {
|
||
//因为前端希望稿件列表返回的up_group与任务质检结构一致，所以在这做一次转换
|
||
gp := &manager.UpGroup2{
|
||
GroupID: up.ID,
|
||
GroupName: up.Name,
|
||
GroupTag: up.ShortTag,
|
||
}
|
||
result.Result[i].UserGroup = append(result.Result[i].UserGroup, gp)
|
||
}
|
||
}
|
||
}
|
||
result.Result = archives
|
||
return
|
||
}
|