534 lines
15 KiB
Go
534 lines
15 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"hash/crc32"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"go-common/app/admin/main/videoup/model/archive"
|
||
mngmdl "go-common/app/admin/main/videoup/model/manager"
|
||
accApi "go-common/app/service/main/account/api"
|
||
upsrpc "go-common/app/service/main/up/api/v1"
|
||
"go-common/library/log"
|
||
"go-common/library/sync/errgroup"
|
||
xtime "go-common/library/time"
|
||
|
||
"go-common/library/xstr"
|
||
)
|
||
|
||
//ERROR
|
||
var (
|
||
ErrRPCEmpty = errors.New("rpc reply empty")
|
||
)
|
||
|
||
func (s *Service) archiveRound(c context.Context, a *archive.Archive, aid, mid int64, typeID int16, nowRound, newState int8, cancelMission bool) (round int8) {
|
||
//非特殊分区私单定时发布时，稿件进入四审
|
||
//一个私单且定时发布的稿件 应该是先通过待审 传递到 私单四审 ，私单四审开放浏览后到达设置的定时时间最后再自动发布
|
||
if s.isPorder(a) && newState == archive.StateForbidUserDelay && !s.isAuditType(typeID) {
|
||
round = archive.RoundReviewFlow
|
||
return
|
||
}
|
||
//定时发布的付费稿件 投上来就是round24 admin提交不需要再走付费审核
|
||
|
||
//定时发布
|
||
if newState == archive.StateForbidAdminDelay || newState == archive.StateForbidUserDelay {
|
||
round = nowRound
|
||
return
|
||
}
|
||
var addit *archive.Addit
|
||
//活动稿件（非私单且非付费） | pgc 稿件 up_from(1,5,6) 直接round 99 简单流程业务
|
||
if addit, _ = s.arc.Addit(c, aid); addit != nil && (addit.UpFrom == archive.UpFromPGC || addit.UpFrom == archive.UpFromSecretPGC || addit.UpFrom == archive.UpFromCoopera || (addit.MissionID > 0 && !s.isPorder(a) && !s.isUGCPay(a))) {
|
||
if addit.UpFrom == archive.UpFromSecretPGC && newState == archive.StateForbidWait {
|
||
//pgc 机密待审state=-1 不变更round
|
||
round = nowRound
|
||
return
|
||
}
|
||
if archive.NormalState(newState) {
|
||
//pgc 生产组机密稿件(番剧、付费版权，严格要求时效和保密性) up_from=5 开放回查流程 90
|
||
if addit.UpFrom == archive.UpFromSecretPGC && nowRound < archive.RoundTriggerClick {
|
||
//三查
|
||
round = archive.RoundTriggerClick
|
||
return
|
||
}
|
||
}
|
||
//pgc 生产组常规稿件(片包等其他内容) up_from=1 进三审
|
||
if addit.UpFrom == archive.UpFromPGC && nowRound < archive.RoundAuditThird {
|
||
round = archive.RoundAuditThird
|
||
return
|
||
}
|
||
//pgc 合作方嵌套，终结
|
||
if addit.UpFrom == archive.UpFromCoopera && nowRound < archive.RoundAuditThird {
|
||
round = archive.RoundEnd
|
||
return
|
||
}
|
||
round = archive.RoundEnd
|
||
return
|
||
}
|
||
//其他稿件 （非定时，活动，pgc）
|
||
if nowRound == archive.RoundAuditSecond {
|
||
//二审阶段
|
||
if newState == archive.StateForbidWait {
|
||
//1、非特殊分区私单进入私单四审；2、私单活动稿件进入私单四审
|
||
if (s.isPorder(a) && !s.isAuditType(typeID)) || (s.isPorder(a) && !cancelMission && addit.MissionID > 0) {
|
||
//私单四审
|
||
round = archive.RoundReviewFlow
|
||
} else if s.isUGCPay(a) && (!s.isAuditType(typeID) || !s.isPorder(a) || (!cancelMission && addit.MissionID > 0)) {
|
||
//付费稿件 非特殊分区 非私单
|
||
round = archive.RoundAuditUGCPayFlow
|
||
} else if s.isAuditType(typeID) || (addit != nil && addit.OrderID > 0) {
|
||
//特殊分区 ,商单到三审 二审到三审
|
||
round = archive.RoundAuditThird
|
||
} else {
|
||
//不变
|
||
round = archive.RoundAuditSecond
|
||
}
|
||
} else if archive.NormalState(newState) {
|
||
//回查控制
|
||
round = s.normalRound(c, aid, mid, typeID, nowRound, newState)
|
||
} else if newState == archive.StateForbidFixed {
|
||
//1、非特殊分区私单进入私单四审修复待审；2、私单+活动稿件进入私单四审修复待审
|
||
if (s.isPorder(a) && !s.isAuditType(typeID)) || (s.isPorder(a) && !cancelMission && addit.MissionID > 0) {
|
||
round = archive.RoundReviewFlow
|
||
} else if s.isAuditType(typeID) && !(!cancelMission && addit.MissionID > 0) {
|
||
//特殊分区 二审到三审
|
||
round = archive.RoundAuditThird
|
||
} else if s.isUGCPay(a) && (!s.isAuditType(typeID) || !s.isPorder(a) || (!cancelMission && addit.MissionID > 0)) {
|
||
//付费稿件 非特殊分区 非私单
|
||
round = archive.RoundAuditUGCPayFlow
|
||
} else {
|
||
//不变
|
||
round = archive.RoundAuditSecond
|
||
}
|
||
} else {
|
||
round = archive.RoundEnd
|
||
}
|
||
} else if nowRound == archive.RoundReviewFlow {
|
||
//私单四审21
|
||
if archive.NormalState(newState) {
|
||
if s.isAuditType(typeID) || addit.MissionID > 0 {
|
||
round = archive.RoundEnd
|
||
} else {
|
||
round = s.normalRound(c, aid, mid, typeID, nowRound, newState)
|
||
}
|
||
} else {
|
||
round = archive.RoundEnd
|
||
}
|
||
} else if nowRound == archive.RoundAuditUGCPayFlow {
|
||
//付费待审 24
|
||
if archive.NormalState(newState) {
|
||
if s.isAuditType(typeID) || addit.MissionID > 0 {
|
||
round = archive.RoundEnd
|
||
} else {
|
||
round = s.normalRound(c, aid, mid, typeID, nowRound, newState)
|
||
}
|
||
} else {
|
||
round = archive.RoundEnd
|
||
}
|
||
} else if nowRound == archive.RoundReviewFirst {
|
||
//一查
|
||
if archive.NormalState(newState) {
|
||
round = archive.RoundReviewFirstWaitTrigger
|
||
} else {
|
||
round = archive.RoundEnd
|
||
}
|
||
} else if nowRound == archive.RoundAuditThird {
|
||
//三审
|
||
if s.isPorder(a) {
|
||
//私单四审
|
||
round = archive.RoundReviewFlow
|
||
} else if s.isUGCPay(a) {
|
||
round = archive.RoundAuditUGCPayFlow
|
||
} else {
|
||
round = archive.RoundEnd
|
||
}
|
||
} else if nowRound == archive.RoundReviewSecond || nowRound == archive.RoundTriggerClick {
|
||
//二查 三查
|
||
round = archive.RoundEnd
|
||
} else {
|
||
round = nowRound
|
||
}
|
||
return
|
||
}
|
||
|
||
//normalRound 回查逻辑
|
||
func (s *Service) normalRound(c context.Context, aid, mid int64, typeID int16, nowRound, newState int8) (round int8) {
|
||
if s.isWhite(mid) || s.isBlack(mid) {
|
||
round = archive.RoundReviewSecond
|
||
} else if plf, _ := s.profile(c, mid); plf != nil && plf.Follower >= s.fansCache {
|
||
//社区回查 粉丝阈值
|
||
round = archive.RoundReviewSecond
|
||
} else if plf != nil && plf.Follower < s.fansCache && s.isRoundType(typeID) {
|
||
//回查分区
|
||
round = archive.RoundReviewFirst // NOTE: if audit type, state must not open!!! so cannot execute here...
|
||
} else {
|
||
//点击量回查
|
||
round = archive.RoundReviewFirstWaitTrigger
|
||
if plf == nil {
|
||
log.Info("archive(%d) card(%d) is nil", aid, mid)
|
||
} else {
|
||
log.Info("archive(%d) card(%d) fans(%d) little than config(%d)", aid, mid, plf.Follower, s.fansCache)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) hadPassed(c context.Context, aid int64) (had bool) {
|
||
id, err := s.arc.GetFirstPassByAID(c, aid)
|
||
if err != nil {
|
||
log.Error("hadPassed s.arc.GetFirstPassByAID error(%v) aid(%d)", err, aid)
|
||
return
|
||
}
|
||
|
||
had = id > 0
|
||
return
|
||
}
|
||
|
||
func (s *Service) isPorder(a *archive.Archive) bool {
|
||
if a == nil {
|
||
return false
|
||
}
|
||
return a.AttrVal(archive.AttrBitIsPorder) == archive.AttrYes
|
||
}
|
||
|
||
//ugc pay only
|
||
func (s *Service) isUGCPay(a *archive.Archive) bool {
|
||
if a == nil {
|
||
return false
|
||
}
|
||
return a.AttrVal(archive.AttrBitUGCPay) == archive.AttrYes
|
||
}
|
||
|
||
func (s *Service) profile(c context.Context, mid int64) (card *accApi.ProfileStatReply, err error) {
|
||
if card, err = s.accRPC.ProfileWithStat3(c, &accApi.MidReq{Mid: mid}); err != nil {
|
||
log.Error("s.accRPC.ProfileWithStat3(%d) error(%v)", mid, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) upCards(c context.Context, mids []int64) (p map[int64]*accApi.Card, err error) {
|
||
p = make(map[int64]*accApi.Card)
|
||
if len(mids) == 0 {
|
||
return
|
||
}
|
||
var res *accApi.CardsReply
|
||
if res, err = s.accRPC.Cards3(c, &accApi.MidsReq{Mids: mids}); err != nil {
|
||
p = nil
|
||
log.Error("s.accRPC.Cards3(%v) error(%v)", mids, err)
|
||
return
|
||
}
|
||
p = res.Cards
|
||
return
|
||
}
|
||
|
||
func (s *Service) archivePtime(c context.Context, aid int64, newState int8, newPtime xtime.Time) (ptime xtime.Time) {
|
||
if newState >= archive.StateOpen {
|
||
if !s.hadPassed(c, aid) {
|
||
ptime = xtime.Time(time.Now().Unix())
|
||
return
|
||
}
|
||
}
|
||
ptime = newPtime
|
||
return
|
||
}
|
||
|
||
func (s *Service) archiveAttr(c context.Context, ap *archive.ArcParam, isExt bool) (attrs map[uint]int32, forbidAttrs map[string]map[uint]int32) {
|
||
//批量和单个提交都需要补全对应属性值
|
||
|
||
attrs = make(map[uint]int32)
|
||
attrs[archive.AttrBitNoRank] = ap.Attrs.NoRank
|
||
attrs[archive.AttrBitNoDynamic] = ap.Attrs.NoDynamic
|
||
attrs[archive.AttrBitNoWeb] = ap.Attrs.NoWeb
|
||
attrs[archive.AttrBitNoMobile] = ap.Attrs.NoMobile
|
||
attrs[archive.AttrBitNoSearch] = ap.Attrs.NoSearch
|
||
attrs[archive.AttrBitOverseaLock] = ap.Attrs.OverseaLock
|
||
attrs[archive.AttrBitNoRecommend] = ap.Attrs.NoRecommend
|
||
attrs[archive.AttrBitNoReprint] = ap.Attrs.NoReprint
|
||
attrs[archive.AttrBitHasHD5] = ap.Attrs.HasHD5
|
||
attrs[archive.AttrBitAllowBp] = ap.Attrs.AllowBp
|
||
attrs[archive.AttrBitIsPorder] = ap.Attrs.IsPorder
|
||
attrs[archive.AttrBitLimitArea] = ap.Attrs.LimitArea
|
||
attrs[archive.AttrBitPushBlog] = ap.Attrs.PushBlog
|
||
attrs[archive.AttrBitUGCPay] = ap.Attrs.UGCPay
|
||
attrs[archive.AttrBitParentMode] = ap.Attrs.ParentMode
|
||
// pgc
|
||
attrs[archive.AttrBitIsMovie] = ap.Attrs.IsMovie
|
||
attrs[archive.AttrBitBadgepay] = ap.Attrs.BadgePay
|
||
attrs[archive.AttrBitIsBangumi] = ap.Attrs.IsBangumi
|
||
attrs[archive.AttrBitIsPGC] = ap.Attrs.IsPGC
|
||
if isExt {
|
||
attrs[archive.AttrBitAllowTag] = ap.Attrs.AllowTag
|
||
attrs[archive.AttrBitJumpURL] = ap.Attrs.JumpURL
|
||
}
|
||
forbidAttrs = make(map[string]map[uint]int32, 4)
|
||
forbidAttrs[archive.ForbidRank] = map[uint]int32{
|
||
archive.ForbidRankMain: ap.Forbid.Rank.Main,
|
||
archive.ForbidRankRecentArc: ap.Forbid.Rank.RecentArc,
|
||
archive.ForbidRankAllArc: ap.Forbid.Rank.AllArc,
|
||
}
|
||
forbidAttrs[archive.ForbidDynamic] = map[uint]int32{
|
||
archive.ForbidDynamicMain: ap.Forbid.Dynamic.Main,
|
||
}
|
||
forbidAttrs[archive.ForbidRecommend] = map[uint]int32{
|
||
archive.ForbidRecommendMain: ap.Forbid.Recommend.Main,
|
||
}
|
||
forbidAttrs[archive.ForbidShow] = map[uint]int32{
|
||
archive.ForbidShowMain: ap.Forbid.Show.Main,
|
||
archive.ForbidShowMobile: ap.Forbid.Show.Mobile,
|
||
archive.ForbidShowWeb: ap.Forbid.Show.Web,
|
||
archive.ForbidShowOversea: ap.Forbid.Show.Oversea,
|
||
archive.ForbidShowOnline: ap.Forbid.Show.Online,
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) isAccess(c context.Context, aid int64) (wm bool) {
|
||
var vs []*archive.Video
|
||
if vs, _ = s.arc.NewVideosByAid(c, aid); len(vs) <= 0 {
|
||
return
|
||
}
|
||
for _, v := range vs {
|
||
if v.Status == 10000 {
|
||
wm = true
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// CheckArchive check typeid
|
||
func (s *Service) CheckArchive(aps []*archive.ArcParam) bool {
|
||
for _, ap := range aps {
|
||
if ap.Aid == 0 || ap.UID == 0 {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// CheckVideo check video
|
||
func (s *Service) CheckVideo(vps []*archive.VideoParam) bool {
|
||
for _, vp := range vps {
|
||
if vp.ID == 0 || vp.Aid == 0 || vp.Filename == "" || vp.Cid == 0 || vp.UID == 0 {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// CheckStaff check
|
||
func (s *Service) CheckStaff(vps []*archive.StaffParam) bool {
|
||
//允许为空 不允许为Nil
|
||
if len(vps) == 0 {
|
||
return true
|
||
}
|
||
for _, vp := range vps {
|
||
if vp.MID == 0 || vp.Title == "" {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
// TypeTopParent get archive type's first level type
|
||
func (s *Service) TypeTopParent(tid int16) (tp *archive.Type, err error) {
|
||
if _, ok := s.typeCache[tid]; !ok {
|
||
err = errors.New("archive type id not exist. id:" + strconv.Itoa(int(tid)))
|
||
return
|
||
}
|
||
if s.typeCache[tid].PID == 0 {
|
||
tp = s.typeCache[tid]
|
||
} else {
|
||
tp, err = s.TypeTopParent(s.typeCache[tid].PID)
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
//StringHandler handle two strings 以s1顺序为准
|
||
func StringHandler(s1 string, s2 string, delimiter string, subtraction bool) string {
|
||
if strings.TrimSpace(s2) == "" {
|
||
return s1
|
||
}
|
||
|
||
var (
|
||
res []string
|
||
duplicate []int
|
||
)
|
||
s1Arr := strings.Split(s1, delimiter)
|
||
s2Arr := strings.Split(s2, delimiter)
|
||
for _, s1Item := range s1Arr {
|
||
dupIndex := -1
|
||
for k, s2Item := range s2Arr {
|
||
if s1Item == s2Item {
|
||
dupIndex = k
|
||
break
|
||
}
|
||
}
|
||
|
||
if dupIndex >= 0 && subtraction {
|
||
continue
|
||
}
|
||
if dupIndex >= 0 {
|
||
duplicate = append(duplicate, dupIndex)
|
||
}
|
||
res = append(res, s1Item)
|
||
}
|
||
|
||
if !subtraction {
|
||
for k, s2Item := range s2Arr {
|
||
s2Item = strings.TrimSpace(s2Item)
|
||
if s2Item == "" {
|
||
continue
|
||
}
|
||
add := true
|
||
for _, dup := range duplicate {
|
||
if k == dup {
|
||
add = false
|
||
break
|
||
}
|
||
}
|
||
if add {
|
||
res = append(res, s2Item)
|
||
}
|
||
}
|
||
}
|
||
return strings.Join(res, delimiter)
|
||
}
|
||
|
||
// SplitInts 去掉id字符串中的空白字符
|
||
func (s *Service) SplitInts(str string) ([]int64, error) {
|
||
empties := []string{" ", "\n", "\t", "\r"}
|
||
for _, v := range empties {
|
||
str = strings.Replace(str, v, "", -1)
|
||
}
|
||
str = strings.Trim(str, ",")
|
||
return xstr.SplitInts(str)
|
||
}
|
||
|
||
// coverURL convert cover url to full url.
|
||
func coverURL(uri string) (cover string) {
|
||
if uri == "" {
|
||
cover = "http://static.hdslb.com/images/transparent.gif"
|
||
return
|
||
}
|
||
cover = uri
|
||
if strings.Index(uri, "http://") == 0 {
|
||
return
|
||
}
|
||
if len(uri) >= 10 && uri[:10] == "/templets/" {
|
||
return
|
||
}
|
||
if strings.HasPrefix(uri, "group1") {
|
||
cover = "http://i0.hdslb.com/" + uri
|
||
return
|
||
}
|
||
if pos := strings.Index(uri, "/uploads/"); pos != -1 && (pos == 0 || pos == 3) {
|
||
cover = uri[pos+8:]
|
||
}
|
||
cover = strings.Replace(cover, "{IMG}", "", -1)
|
||
cover = "http://i" + strconv.FormatInt(int64(crc32.ChecksumIEEE([]byte(cover)))%3, 10) + ".hdslb.com" + cover
|
||
return
|
||
}
|
||
|
||
func (s *Service) upGroupMids(c context.Context, gid int64) (mids []int64, err error) {
|
||
var (
|
||
total int
|
||
maxps = 10000
|
||
req = &upsrpc.UpGroupMidsReq{
|
||
Pn: 1,
|
||
GroupID: gid,
|
||
Ps: maxps,
|
||
}
|
||
reply *upsrpc.UpGroupMidsReply
|
||
)
|
||
|
||
for {
|
||
reply, err = s.upsRPC.UpGroupMids(c, req)
|
||
if err == nil && (reply == nil || reply.Mids == nil) {
|
||
err = ErrRPCEmpty
|
||
}
|
||
if err != nil {
|
||
log.Error("UpGroupMids req(%+v) error(%v)", req, err)
|
||
return
|
||
}
|
||
total = reply.Total
|
||
mids = append(mids, reply.Mids...)
|
||
if reply.Size() != maxps {
|
||
break
|
||
}
|
||
req.Pn++
|
||
}
|
||
log.Info("upGroupMids(%d) reply total(%d) len(%d)", gid, total, len(mids))
|
||
return
|
||
}
|
||
|
||
func (s *Service) upSpecial(c context.Context) (ups map[int8]map[int64]struct{}, err error) {
|
||
var (
|
||
g errgroup.Group
|
||
whitegroup, blackgroup, pgcgroup, ugcxgroup, policygroup, dangergroup, twoforbidgroup, pgcwhitegroup map[int64]struct{}
|
||
)
|
||
ups = make(map[int8]map[int64]struct{})
|
||
|
||
f := func(gid int8) (map[int64]struct{}, error) {
|
||
group := make(map[int64]struct{})
|
||
mids, e := s.upGroupMids(c, int64(gid))
|
||
if e != nil {
|
||
return group, e
|
||
}
|
||
for _, mid := range mids {
|
||
group[mid] = struct{}{}
|
||
}
|
||
return group, nil
|
||
}
|
||
g.Go(func() error {
|
||
whitegroup, err = f(mngmdl.UpperTypeWhite)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
blackgroup, err = f(mngmdl.UpperTypeBlack)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
pgcgroup, err = f(mngmdl.UpperTypePGC)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
ugcxgroup, err = f(mngmdl.UpperTypeUGCX)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
policygroup, err = f(mngmdl.UpperTypePolity)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
dangergroup, err = f(mngmdl.UpperTypeDanger)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
twoforbidgroup, err = f(mngmdl.UpperTypeTwoForbid)
|
||
return err
|
||
})
|
||
g.Go(func() error {
|
||
pgcwhitegroup, err = f(mngmdl.UpperTypePGCWhite)
|
||
return err
|
||
})
|
||
if err = g.Wait(); err != nil {
|
||
return
|
||
}
|
||
|
||
ups[mngmdl.UpperTypeWhite] = whitegroup
|
||
ups[mngmdl.UpperTypeBlack] = blackgroup
|
||
ups[mngmdl.UpperTypePGC] = pgcgroup
|
||
ups[mngmdl.UpperTypeUGCX] = ugcxgroup
|
||
ups[mngmdl.UpperTypePolity] = policygroup
|
||
ups[mngmdl.UpperTypeDanger] = dangergroup
|
||
ups[mngmdl.UpperTypeTwoForbid] = twoforbidgroup
|
||
ups[mngmdl.UpperTypePGCWhite] = pgcwhitegroup
|
||
return
|
||
}
|