Create & Init Project...

app/interface/main/app-intl/service/feed/BUILD

@@ -0,0 +1,70 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "black.go",
+        "cache.go",
+        "index.go",
+        "infoc.go",
+        "operate.go",
+        "player.go",
+        "rank.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/interface/main/app-intl/service/feed",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/app-card/model:go_default_library",
+        "//app/interface/main/app-card/model/card:go_default_library",
+        "//app/interface/main/app-card/model/card/ai:go_default_library",
+        "//app/interface/main/app-card/model/card/banner:go_default_library",
+        "//app/interface/main/app-card/model/card/cm:go_default_library",
+        "//app/interface/main/app-card/model/card/operate:go_default_library",
+        "//app/interface/main/app-card/model/card/rank:go_default_library",
+        "//app/interface/main/app-intl/conf:go_default_library",
+        "//app/interface/main/app-intl/dao/account:go_default_library",
+        "//app/interface/main/app-intl/dao/archive:go_default_library",
+        "//app/interface/main/app-intl/dao/black:go_default_library",
+        "//app/interface/main/app-intl/dao/card:go_default_library",
+        "//app/interface/main/app-intl/dao/location:go_default_library",
+        "//app/interface/main/app-intl/dao/rank:go_default_library",
+        "//app/interface/main/app-intl/dao/recommend:go_default_library",
+        "//app/interface/main/app-intl/dao/relation:go_default_library",
+        "//app/interface/main/app-intl/dao/tag:go_default_library",
+        "//app/interface/main/app-intl/model:go_default_library",
+        "//app/interface/main/app-intl/model/feed:go_default_library",
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/archive/model/archive:go_default_library",
+        "//app/service/main/location/model:go_default_library",
+        "//app/service/main/relation/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/log/infoc:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/stat/prom:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/text/translate/chinese:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/app-intl/service/feed/black.go

@@ -0,0 +1,35 @@
+package feed
+
+import (
+	"context"
+	"time"
+
+	"go-common/library/log"
+)
+
+// loadBlackCache is.
+func (s *Service) loadBlackCache() {
+	bs, err := s.blk.Black(context.Background())
+	if err != nil {
+		log.Error("s.blk.Black error(%v)", err)
+		return
+	}
+	s.blackCache = bs
+	log.Info("reBlackList success")
+}
+
+// blackproc load blacklist cache.
+func (s *Service) blackproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadBlackCache()
+	}
+}
+
+// BlackList is.
+func (s *Service) BlackList(c context.Context, mid int64) (aidm map[int64]struct{}, err error) {
+	if mid == 0 {
+		return
+	}
+	return s.blk.BlackList(c, mid)
+}

app/interface/main/app-intl/service/feed/cache.go

@@ -0,0 +1,180 @@
+package feed
+
+import (
+	"context"
+	"hash/crc32"
+	"math/rand"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/app/interface/main/app-intl/model"
+	"go-common/library/log"
+)
+
+// indexCache is.
+func (s *Service) indexCache(c context.Context, mid int64, count int) (rs []*ai.Item, err error) {
+	var (
+		pos, nextPos int
+	)
+	cache := s.rcmdCache
+	if len(cache) < count {
+		return
+	}
+	if pos, err = s.rcmd.PositionCache(c, mid); err != nil {
+		return
+	}
+	rs = make([]*ai.Item, 0, count)
+	if pos < len(cache)-count-1 {
+		nextPos = pos + count
+		rs = append(rs, cache[pos:nextPos]...)
+	} else if pos < len(cache)-1 {
+		nextPos = count - (len(cache) - pos)
+		rs = append(rs, cache[pos:]...)
+		rs = append(rs, cache[:nextPos]...)
+	} else {
+		nextPos = count - 1
+		rs = append(rs, cache[:nextPos]...)
+	}
+	s.addCache(func() {
+		s.rcmd.AddPositionCache(context.Background(), mid, nextPos)
+	})
+	return
+}
+
+// recommendCache is.
+func (s *Service) recommendCache(count int) (rs []*ai.Item) {
+	cache := s.rcmdCache
+	index := len(cache)
+	if count > 0 && count < index {
+		index = count
+	}
+	rs = make([]*ai.Item, 0, index)
+	for _, idx := range rand.Perm(len(cache))[:index] {
+		rs = append(rs, cache[idx])
+	}
+	return
+}
+
+// group is.
+func (s *Service) group(mid int64, buvid string) (group int) {
+	if mid == 0 && buvid == "" {
+		group = -1
+		return
+	}
+	if mid != 0 {
+		if v, ok := s.groupCache[mid]; ok {
+			group = v
+			return
+		}
+		group = int(mid % 20)
+		return
+	}
+	group = int(crc32.ChecksumIEEE([]byte(buvid)) % 20)
+	return
+}
+
+// loadRcmdCache is.
+func (s *Service) loadRcmdCache() {
+	is, err := s.rcmd.RcmdCache(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+	}
+	if len(is) >= 50 {
+		for _, i := range is {
+			i.Goto = model.GotoAv
+		}
+		s.rcmdCache = is
+		return
+	}
+	aids, err := s.rcmd.Hots(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+	}
+	if len(aids) == 0 {
+		if aids, err = s.rcmd.RcmdAidsCache(context.Background()); err != nil {
+			return
+		}
+	}
+	if len(aids) < 50 && len(s.rcmdCache) != 0 {
+		return
+	}
+	s.rcmdCache = s.fromAids(aids)
+	s.addCache(func() {
+		s.rcmd.AddRcmdAidsCache(context.Background(), aids)
+	})
+}
+
+// fromAids is.
+func (s *Service) fromAids(aids []int64) (is []*ai.Item) {
+	is = make([]*ai.Item, 0, len(aids))
+	for _, aid := range aids {
+		i := &ai.Item{
+			ID:   aid,
+			Goto: model.GotoAv,
+		}
+		is = append(is, i)
+	}
+	return
+}
+
+// rcmdproc is.
+func (s *Service) rcmdproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadRcmdCache()
+	}
+}
+
+// loadRankCache is.
+func (s *Service) loadRankCache() {
+	rank, err := s.rank.AllRank(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	s.rankCache = rank
+}
+
+// rankproc is.
+func (s *Service) rankproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadRankCache()
+	}
+}
+
+// loadUpCardCache is.
+func (s *Service) loadUpCardCache() {
+	follow, err := s.card.Follow(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	s.followCache = follow
+}
+
+// upCardproc is.
+func (s *Service) upCardproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadUpCardCache()
+	}
+}
+
+// loadGroupCache is.
+func (s *Service) loadGroupCache() {
+	group, err := s.rcmd.Group(context.Background())
+	if err != nil {
+		log.Error("%+v", err)
+		return
+	}
+	s.groupCache = group
+}
+
+// groupproc is.
+func (s *Service) groupproc() {
+	for {
+		time.Sleep(s.tick)
+		s.loadGroupCache()
+	}
+}

app/interface/main/app-intl/service/feed/index.go

@@ -0,0 +1,438 @@
+package feed
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	cdm "go-common/app/interface/main/app-card/model"
+	"go-common/app/interface/main/app-card/model/card"
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/app/interface/main/app-card/model/card/banner"
+	"go-common/app/interface/main/app-card/model/card/cm"
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-intl/model"
+	"go-common/app/interface/main/app-intl/model/feed"
+	tag "go-common/app/interface/main/tag/model"
+	account "go-common/app/service/main/account/model"
+	"go-common/app/service/main/archive/model/archive"
+	locmdl "go-common/app/service/main/location/model"
+	relation "go-common/app/service/main/relation/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+	"go-common/library/text/translate/chinese"
+)
+
+// Index is.
+func (s *Service) Index(c context.Context, buvid string, mid int64, plat int8, param *feed.IndexParam, now time.Time, style int) (is []card.Handler, userFeature json.RawMessage, isRcmd, newUser bool, code int, autoPlay, clean int8, autoPlayInfoc string, err error) {
+	var (
+		rs        []*ai.Item
+		adm       map[int]*cm.AdInfo
+		adAidm    map[int64]struct{}
+		banners   []*banner.Banner
+		version   string
+		blackAidm map[int64]struct{}
+		adInfom   map[int]*cm.AdInfo
+		follow    *operate.Card
+		ip        = metadata.String(c, metadata.RemoteIP)
+		info      *locmdl.Info
+		isTW      = model.TWLocale(param.Locale)
+	)
+	// 国际版不做abtest
+	clean = 0
+	autoPlay = 2
+	group := s.group(mid, buvid)
+	if info, err = s.loc.Info(c, ip); err != nil {
+		log.Warn("s.loc.Info(%v) error(%v)", ip, err)
+		err = nil
+	}
+	if !s.c.Feed.Index.Abnormal {
+		g, ctx := errgroup.WithContext(c)
+		g.Go(func() error {
+			rs, userFeature, isRcmd, newUser, code = s.indexRcmd(ctx, plat, param.Build, buvid, mid, group, param.LoginEvent, info, param.Interest, param.Network, style, param.Column, param.Flush, autoPlayInfoc, now)
+			if isTW {
+				for _, r := range rs {
+					if r.RcmdReason != nil {
+						r.RcmdReason.Content = chinese.Convert(ctx, r.RcmdReason.Content)
+					}
+				}
+			}
+			return nil
+		})
+		g.Go(func() (err error) {
+			if blackAidm, err = s.BlackList(ctx, mid); err != nil {
+				log.Error("%+v", err)
+				err = nil
+			}
+			return
+		})
+		if err = g.Wait(); err != nil {
+			return
+		}
+		rs, adInfom = s.mergeItem(c, mid, rs, adm, adAidm, banners, version, blackAidm, plat, follow)
+	} else {
+		count := s.indexCount(plat)
+		rs = s.recommendCache(count)
+		log.Warn("feed index show disaster recovery data len(%d)", len(is))
+	}
+	is, isRcmd, err = s.dealItem(c, param.Column, mid, buvid, plat, param.Build, rs, isRcmd, param.MobiApp, param.Device, param.Network, param.OpenEvent, param.AdExtra, param.Qn, param.Fnver, param.Fnval, follow, isTW, now)
+	s.dealAdLoc(is, param, adInfom, now)
+	return
+}
+
+// indexRcmd is.
+func (s *Service) indexRcmd(c context.Context, plat int8, build int, buvid string, mid int64, group int, loginEvent int, info *locmdl.Info, interest, network string, style int, column cdm.ColumnStatus, flush int, autoPlay string, now time.Time) (is []*ai.Item, userFeature json.RawMessage, isRcmd, newUser bool, code int) {
+	count := s.indexCount(plat)
+	if buvid != "" || mid != 0 {
+		var (
+			err    error
+			zoneID int64
+		)
+		if info != nil {
+			zoneID = info.ZoneID
+		}
+		if is, userFeature, code, newUser, err = s.rcmd.Recommend(c, plat, buvid, mid, build, loginEvent, zoneID, group, interest, network, style, column, flush, autoPlay, now); err != nil {
+			log.Error("%+v", err)
+		} else if len(is) != 0 {
+			isRcmd = true
+		}
+		var fromCache bool
+		if len(is) == 0 && mid != 0 && !ecode.ServiceUnavailable.Equal(err) {
+			if is, err = s.indexCache(c, mid, count); err != nil {
+				log.Error("%+v", err)
+			}
+			if len(is) != 0 {
+				s.pHit.Incr("index_cache")
+			} else {
+				s.pMiss.Incr("index_cache")
+			}
+			fromCache = true
+		}
+		if len(is) == 0 || (fromCache && len(is) < count) {
+			is = s.recommendCache(count)
+		}
+	} else {
+		is = s.recommendCache(count)
+	}
+	return
+}
+
+// mergeItem is.
+func (s *Service) mergeItem(c context.Context, mid int64, rs []*ai.Item, adm map[int]*cm.AdInfo, adAidm map[int64]struct{}, banners []*banner.Banner, version string, blackAids map[int64]struct{}, plat int8, follow *operate.Card) (is []*ai.Item, adInfom map[int]*cm.AdInfo) {
+	if len(rs) == 0 {
+		return
+	}
+	if len(banners) != 0 {
+		rs = append([]*ai.Item{{Goto: model.GotoBanner, Banners: banners, Version: version}}, rs...)
+	}
+	is = make([]*ai.Item, 0, len(rs)+len(adm))
+	adInfom = make(map[int]*cm.AdInfo, len(adm))
+	for _, r := range rs {
+		if r.Goto == model.GotoAv {
+			if _, ok := blackAids[r.ID]; ok {
+				continue
+			} else if _, ok := s.blackCache[r.ID]; ok {
+				continue
+			}
+			if _, ok := adAidm[r.ID]; ok {
+				continue
+			}
+		} else if r.Goto == model.GotoBanner && len(is) != 0 {
+			// banner 必须在第一位
+			continue
+		} else if r.Goto == model.GotoLogin && mid != 0 {
+			continue
+		}
+		is = append(is, r)
+	}
+	return
+}
+
+// dealAdLoc is.
+func (*Service) dealAdLoc(is []card.Handler, param *feed.IndexParam, adInfom map[int]*cm.AdInfo, now time.Time) {
+	il := len(is)
+	if il == 0 {
+		return
+	}
+	if param.Idx < 1 {
+		param.Idx = now.Unix()
+	}
+	for i, h := range is {
+		if param.Pull {
+			h.Get().Idx = param.Idx + int64(il-i)
+		} else {
+			h.Get().Idx = param.Idx - int64(i+1)
+		}
+		if ad, ok := adInfom[i]; ok {
+			h.Get().AdInfo = ad
+		} else if h.Get().AdInfo != nil {
+			h.Get().AdInfo.CardIndex = i
+		}
+	}
+}
+
+// dealItem is.
+func (s *Service) dealItem(c context.Context, column cdm.ColumnStatus, mid int64, buvid string, plat int8, build int, rs []*ai.Item, isRcmd bool, mobiApp, device, network, openEvent, adExtra string, qn, fnver, fnval int, follow *operate.Card, isTW bool, now time.Time) (is []card.Handler, isAI bool, err error) {
+	if len(rs) == 0 {
+		is = []card.Handler{}
+		return
+	}
+	var (
+		aids, tids                       []int64
+		upIDs, avUpIDs, rmUpIDs, mtUpIDs []int64
+		am                               map[int64]*archive.ArchiveWithPlayer
+		tagm                             map[int64]*tag.Tag
+		rank                             *operate.Card
+		cardm                            map[int64]*account.Card
+		statm                            map[int64]*relation.Stat
+		isAtten                          map[int64]int8
+		arcOK                            bool
+	)
+	followm := map[int64]*operate.Card{}
+	isAI = isRcmd
+	for _, r := range rs {
+		if r == nil {
+			continue
+		}
+		if isTW && r.RcmdReason != nil {
+			r.RcmdReason.Content = chinese.Convert(c, r.RcmdReason.Content)
+		}
+		switch r.Goto {
+		case model.GotoAv, model.GotoPlayer, model.GotoUpRcmdAv:
+			if r.ID != 0 {
+				aids = append(aids, r.ID)
+			}
+			if r.Tid != 0 {
+				tids = append(tids, r.Tid)
+			}
+		case model.GotoRank:
+			os, aid := s.RankCard(plat)
+			rank = &operate.Card{}
+			rank.FromRank(os)
+			aids = append(aids, aid...)
+		case model.GotoChannelRcmd:
+			cardm, aid, tid := s.channelRcmdCard(c, r.ID)
+			for id, card := range cardm {
+				followm[id] = card
+			}
+			aids = append(aids, aid...)
+			tids = append(tids, tid...)
+		}
+	}
+	g, ctx := errgroup.WithContext(c)
+	if len(aids) != 0 {
+		g.Go(func() (err error) {
+			if am, err = s.ArchivesWithPlayer(ctx, aids, qn, mobiApp, fnver, fnval); err != nil {
+				return
+			}
+			arcOK = true
+			for _, a := range am {
+				avUpIDs = append(avUpIDs, a.Author.Mid)
+				if isTW {
+					out := chinese.Converts(ctx, a.Title, a.Desc, a.TypeName)
+					a.Title = out[a.Title]
+					a.Desc = out[a.Desc]
+					a.TypeName = out[a.TypeName]
+				}
+			}
+			return
+		})
+	}
+	if len(tids) != 0 {
+		g.Go(func() (err error) {
+			if tagm, err = s.tg.InfoByIDs(ctx, mid, tids); err != nil {
+				log.Error("%+v", err)
+				err = nil
+			}
+			return
+		})
+	}
+	if err = g.Wait(); err != nil {
+		log.Error("%+v", err)
+		if isRcmd {
+			count := s.indexCount(plat)
+			rs = s.recommendCache(count)
+		}
+	} else {
+		upIDs = append(upIDs, avUpIDs...)
+		upIDs = append(upIDs, rmUpIDs...)
+		upIDs = append(upIDs, mtUpIDs...)
+		g, ctx = errgroup.WithContext(c)
+		if len(upIDs) != 0 {
+			g.Go(func() (err error) {
+				if cardm, err = s.acc.Cards3(ctx, upIDs); err != nil {
+					log.Error("%+v", err)
+					err = nil
+				}
+				return
+			})
+			g.Go(func() (err error) {
+				if statm, err = s.rel.Stats(ctx, upIDs); err != nil {
+					log.Error("%+v", err)
+					err = nil
+				}
+				return
+			})
+			if mid != 0 {
+				g.Go(func() error {
+					isAtten = s.acc.IsAttention(ctx, upIDs, mid)
+					return nil
+				})
+			}
+		}
+		g.Wait()
+	}
+	isAI = isAI && arcOK
+	var cardTotal int
+	is = make([]card.Handler, 0, len(rs))
+	for _, r := range rs {
+		if r == nil {
+			continue
+		}
+		var (
+			main     interface{}
+			cardType cdm.CardType
+		)
+		op := &operate.Card{}
+		op.From(cdm.CardGt(r.Goto), r.ID, r.Tid, plat, build)
+		h := card.Handle(plat, cdm.CardGt(r.Goto), cardType, column, r, tagm, isAtten, statm, cardm)
+		if h == nil {
+			continue
+		}
+		switch r.Goto {
+		case model.GotoAv, model.GotoPlayer, model.GotoUpRcmdAv:
+			if !arcOK {
+				if r.Archive != nil {
+					if isTW {
+						out := chinese.Converts(c, r.Archive.Title, r.Archive.Desc, r.Archive.TypeName, r.Archive.Author.Name)
+						r.Archive.Title = out[r.Archive.Title]
+						r.Archive.Desc = out[r.Archive.Desc]
+						r.Archive.TypeName = out[r.Archive.TypeName]
+					}
+					am = map[int64]*archive.ArchiveWithPlayer{r.Archive.Aid: {Archive3: r.Archive}}
+				}
+				if r.Tag != nil {
+					tagm = map[int64]*tag.Tag{r.Tag.ID: r.Tag}
+					op.Tid = r.Tag.ID
+				}
+			}
+			if a, ok := am[r.ID]; ok && (a.AttrVal(archive.AttrBitOverseaLock) == 0 || !model.IsOverseas(plat)) {
+				main = am
+				op.TrackID = r.TrackID
+			}
+		case model.GotoRank:
+			main = map[cdm.Gt]interface{}{cdm.GotoAv: am}
+			op = rank
+		case model.GotoChannelRcmd:
+			main = am
+		case model.GotoLogin:
+			op.FromLogin(r.ID)
+		default:
+			log.Warn("unexpected goto(%s) %+v", r.Goto, r)
+			continue
+		}
+		h.From(main, op)
+		// 卡片不正常要continue
+		if !h.Get().Right {
+			continue
+		}
+		is, cardTotal = s.appendItem(plat, is, h, column, cardTotal)
+	}
+	// 双列末尾卡片去空窗
+	if !model.IsIPad(plat) {
+		if cdm.Columnm[column] == cdm.ColumnSvrDouble {
+			is = is[:len(is)-cardTotal%2]
+		}
+	} else {
+		// 复杂的ipad去空窗逻辑
+		if cardTotal%4 == 3 {
+			if is[len(is)-2].Get().CardLen == 2 {
+				is = is[:len(is)-2]
+			} else {
+				is = is[:len(is)-3]
+			}
+		} else if cardTotal%4 == 2 {
+			if is[len(is)-1].Get().CardLen == 2 {
+				is = is[:len(is)-1]
+			} else {
+				is = is[:len(is)-2]
+			}
+		} else if cardTotal%4 == 1 {
+			is = is[:len(is)-1]
+		}
+	}
+	if len(is) == 0 {
+		is = []card.Handler{}
+		return
+	}
+	return
+}
+
+// appendItem is.
+func (s *Service) appendItem(plat int8, rs []card.Handler, h card.Handler, column cdm.ColumnStatus, cardTotal int) (is []card.Handler, total int) {
+	h.Get().ThreePointFrom()
+	// 国际版暂不支持稿件反馈
+	if h.Get().ThreePoint != nil {
+		h.Get().ThreePoint.Feedbacks = nil
+	}
+	if !model.IsIPad(plat) {
+		// 双列大小卡换位去空窗
+		if cdm.Columnm[column] == cdm.ColumnSvrDouble {
+			// 通栏卡
+			if h.Get().CardLen == 0 {
+				if cardTotal%2 == 1 {
+					is = card.SwapTwoItem(rs, h)
+				} else {
+					is = append(rs, h)
+				}
+			} else {
+				is = append(rs, h)
+			}
+		} else {
+			is = append(rs, h)
+		}
+	} else {
+		// ipad卡片不展示标签
+		h.Get().DescButton = nil
+		// ipad大小卡换位去空窗
+		if h.Get().CardLen == 0 {
+			// 通栏卡
+			if cardTotal%4 == 3 {
+				is = card.SwapFourItem(rs, h)
+			} else if cardTotal%4 == 2 {
+				is = card.SwapThreeItem(rs, h)
+			} else if cardTotal%4 == 1 {
+				is = card.SwapTwoItem(rs, h)
+			} else {
+				is = append(rs, h)
+			}
+		} else if h.Get().CardLen == 2 {
+			// 半栏卡
+			if cardTotal%4 == 3 {
+				is = card.SwapTwoItem(rs, h)
+			} else if cardTotal%4 == 2 {
+				is = append(rs, h)
+			} else if cardTotal%4 == 1 {
+				is = card.SwapTwoItem(rs, h)
+			} else {
+				is = append(rs, h)
+			}
+		} else {
+			is = append(rs, h)
+		}
+	}
+	total = cardTotal + h.Get().CardLen
+	return
+}
+
+// indexCount is.
+func (s *Service) indexCount(plat int8) (count int) {
+	if plat == model.PlatIPad {
+		count = s.c.Feed.Index.IPadCount
+	} else {
+		count = s.c.Feed.Index.Count
+	}
+	return
+}

app/interface/main/app-intl/service/feed/infoc.go

@@ -0,0 +1,234 @@
+package feed
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/app/interface/main/app-intl/model"
+	"go-common/library/log"
+	binfoc "go-common/library/log/infoc"
+	"go-common/library/net/metadata"
+)
+
+// infoc struct
+type infoc struct {
+	typ         string
+	mid         string
+	client      string
+	build       string
+	buvid       string
+	disid       string
+	ip          string
+	style       string
+	api         string
+	now         string
+	isRcmd      string
+	pull        string
+	userFeature json.RawMessage
+	code        string
+	items       []*ai.Item
+	lp          bool
+	zoneID      string
+	adResponse  string
+	deviceID    string
+	network     string
+	newUser     string
+	flush       string
+	autoPlay    string
+	deviceType  string
+}
+
+// IndexInfoc is.
+func (s *Service) IndexInfoc(c context.Context, mid int64, plat int8, build int, buvid, disid, api string, userFeature json.RawMessage, style, code int, items []*ai.Item, isRcmd, pull, newUser bool, now time.Time, adResponse, deviceID, network string, flush int, autoPlay string, deviceType int) {
+	if items == nil {
+		return
+	}
+	var (
+		isRc      = "0"
+		isPull    = "0"
+		isNewUser = "0"
+		zoneID    int64
+	)
+	if isRcmd {
+		isRc = "1"
+	}
+	if pull {
+		isPull = "1"
+	}
+	if newUser {
+		isNewUser = "1"
+	}
+	ip := metadata.String(c, metadata.RemoteIP)
+	info, err := s.loc.Info(c, ip)
+	if err != nil {
+		log.Warn(" s.loc.Info(%v) error(%v)", ip, err)
+		err = nil
+	}
+	if info != nil {
+		zoneID = info.ZoneID
+	}
+	s.infoc(infoc{"综合推荐", strconv.FormatInt(mid, 10), strconv.Itoa(int(plat)), strconv.Itoa(build), buvid, disid, ip, strconv.Itoa(style), api, strconv.FormatInt(now.Unix(), 10), isRc, isPull, userFeature, strconv.Itoa(code), items, false, strconv.FormatInt(zoneID, 10), adResponse, deviceID, network, isNewUser, strconv.Itoa(flush), autoPlay, strconv.Itoa(deviceType)})
+}
+
+// infoc is.
+func (s *Service) infoc(i interface{}) {
+	select {
+	case s.logCh <- i:
+	default:
+		log.Warn("infocproc chan full")
+	}
+}
+
+// infocproc is.
+func (s *Service) infocproc() {
+	const (
+		// infoc format {"section":{"id":"%s推荐","pos":1,"style":%d,"items":[{"id":%s,"pos":%d,"type":1,"url":""}]}}
+		noItem1 = `{"section":{"id":"`
+		noItem2 = `{","pos":1,"style":`
+		noItem3 = `,"items":[]}}`
+	)
+	var (
+		msg1    = []byte(`{"section":{"id":"`)
+		msg2    = []byte(`","pos":1,"style":`)
+		msg3    = []byte(`,"items":[`)
+		msg4    = []byte(`{"id":`)
+		msg5    = []byte(`,"pos":`)
+		msg6    = []byte(`,"type":`)
+		msg7    = []byte(`,"source":"`)
+		msg8    = []byte(`","tid":`)
+		msg9    = []byte(`,"av_feature":`)
+		msg10   = []byte(`,"url":"`)
+		msg11   = []byte(`","rcmd_reason":"`)
+		msg12   = []byte(`"},`)
+		msg13   = []byte(`]}}`)
+		showInf = binfoc.New(s.c.ShowInfoc)
+		buf     bytes.Buffer
+		list    string
+		trackID string
+	)
+	for {
+		i, ok := <-s.logCh
+		if !ok {
+			log.Warn("infoc proc exit")
+			return
+		}
+		switch l := i.(type) {
+		case infoc:
+			if len(l.items) > 0 {
+				buf.Write(msg1)
+				buf.WriteString(l.typ)
+				buf.Write(msg2)
+				buf.WriteString(l.style)
+				buf.Write(msg3)
+				for i, v := range l.items {
+					if v == nil {
+						continue
+					}
+					if v.TrackID != "" {
+						trackID = v.TrackID
+					}
+					buf.Write(msg4)
+					buf.WriteString(strconv.FormatInt(v.ID, 10))
+					buf.Write(msg5)
+					buf.WriteString(strconv.Itoa(i + 1))
+					buf.Write(msg6)
+					buf.WriteString(gotoMapID(v.Goto))
+					buf.Write(msg7)
+					buf.WriteString(v.Source)
+					buf.Write(msg8)
+					buf.WriteString(strconv.FormatInt(v.Tid, 10))
+					buf.Write(msg9)
+					if v.AvFeature != nil {
+						buf.Write(v.AvFeature)
+					} else {
+						buf.Write([]byte(`""`))
+					}
+					buf.Write(msg10)
+					buf.WriteString("")
+					buf.Write(msg11)
+					if v.RcmdReason != nil {
+						buf.WriteString(v.RcmdReason.Content)
+					}
+					buf.Write(msg12)
+				}
+				buf.Truncate(buf.Len() - 1)
+				buf.Write(msg13)
+				list = buf.String()
+				buf.Reset()
+			} else {
+				list = noItem1 + l.typ + noItem2 + l.style + noItem3
+			}
+			showInf.Info(l.ip, l.now, l.api, l.buvid, l.mid, l.client, l.pull, list, l.disid, l.isRcmd, l.build, l.code, string(l.userFeature), l.zoneID, l.adResponse, l.deviceID, l.network, l.newUser, l.flush, l.autoPlay, trackID, l.deviceType)
+			log.Info("infocproc %s param(mid:%s,buvid:%s,plat:%s,build:%s,isRcmd:%s,code:%s,zone_id:%s,user_feature:%s,ad_response:%s,device_id:%s,network:%s,new_user:%s,flush:%s,autoplay_card:%s,trackid:%s,device_type:%s) response(%s)", l.api, l.mid, l.buvid, l.client, l.build, l.isRcmd, l.code, l.zoneID, l.userFeature, l.adResponse, l.deviceID, l.network, l.newUser, l.flush, l.autoPlay, trackID, l.deviceType, list)
+
+		}
+	}
+}
+
+// gotoMapID is.
+func gotoMapID(gt string) (id string) {
+	if gt == model.GotoAv {
+		id = "1"
+	} else if gt == model.GotoBangumi {
+		id = "2"
+	} else if gt == model.GotoLive {
+		id = "3"
+	} else if gt == model.GotoRank {
+		id = "6"
+	} else if gt == model.GotoAdAv {
+		id = "8"
+	} else if gt == model.GotoAdWeb {
+		id = "9"
+	} else if gt == model.GotoBangumiRcmd {
+		id = "10"
+	} else if gt == model.GotoLogin {
+		id = "11"
+	} else if gt == model.GotoBanner {
+		id = "13"
+	} else if gt == model.GotoAdWebS {
+		id = "14"
+	} else if gt == model.GotoConverge {
+		id = "17"
+	} else if gt == model.GotoSpecial {
+		id = "18"
+	} else if gt == model.GotoArticleS {
+		id = "20"
+	} else if gt == model.GotoGameDownloadS {
+		id = "21"
+	} else if gt == model.GotoShoppingS {
+		id = "22"
+	} else if gt == model.GotoAudio {
+		id = "23"
+	} else if gt == model.GotoPlayer {
+		id = "24"
+	} else if gt == model.GotoSpecialS {
+		id = "25"
+	} else if gt == model.GotoAdLarge {
+		id = "26"
+	} else if gt == model.GotoPlayerLive {
+		id = "27"
+	} else if gt == model.GotoSong {
+		id = "28"
+	} else if gt == model.GotoLiveUpRcmd {
+		id = "29"
+	} else if gt == model.GotoUpRcmdAv {
+		id = "30"
+	} else if gt == model.GotoSubscribe {
+		id = "31"
+	} else if gt == model.GotoChannelRcmd {
+		id = "32"
+	} else if gt == model.GotoMoe {
+		id = "33"
+	} else if gt == model.GotoPGC {
+		id = "34"
+	} else if gt == model.GotoSearchSubscribe {
+		id = "35"
+	} else {
+		id = "-1"
+	}
+	return
+}

app/interface/main/app-intl/service/feed/operate.go

@@ -0,0 +1,32 @@
+package feed
+
+import (
+	"context"
+	"go-common/app/interface/main/app-card/model"
+	"go-common/app/interface/main/app-card/model/card/operate"
+)
+
+// channelRcmdCard is.
+func (s *Service) channelRcmdCard(c context.Context, ids ...int64) (cardm map[int64]*operate.Card, aids, tids []int64) {
+	if len(ids) == 0 {
+		return
+	}
+	cardm = make(map[int64]*operate.Card, len(ids))
+	for _, id := range ids {
+		if o, ok := s.followCache[id]; ok {
+			card := &operate.Card{}
+			card.FromFollow(o)
+			cardm[id] = card
+			switch card.Goto {
+			case model.GotoAv:
+				if card.ID != 0 {
+					aids = append(aids, card.ID)
+				}
+				if card.Tid != 0 {
+					tids = append(tids, card.Tid)
+				}
+			}
+		}
+	}
+	return
+}

app/interface/main/app-intl/service/feed/player.go

@@ -0,0 +1,30 @@
+package feed
+
+import (
+	"context"
+
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/log"
+)
+
+// ArchivesWithPlayer archives witch player
+func (s *Service) ArchivesWithPlayer(c context.Context, aids []int64, qn int, platform string, fnver, fnval int) (res map[int64]*archive.ArchiveWithPlayer, err error) {
+	if res, err = s.arc.ArchivesWithPlayer(c, aids, qn, platform, fnver, fnval); err != nil {
+		log.Error("%+v", err)
+	}
+	if len(res) != 0 {
+		return
+	}
+	am, err := s.arc.Archives(c, aids)
+	if err != nil {
+		return
+	}
+	if len(am) == 0 {
+		return
+	}
+	res = make(map[int64]*archive.ArchiveWithPlayer, len(am))
+	for aid, a := range am {
+		res[aid] = &archive.ArchiveWithPlayer{Archive3: archive.BuildArchive3(a)}
+	}
+	return
+}

app/interface/main/app-intl/service/feed/rank.go

@@ -0,0 +1,26 @@
+package feed
+
+import (
+	"go-common/app/interface/main/app-card/model/card/rank"
+	"go-common/app/interface/main/app-intl/model"
+)
+
+// RankCard is.
+func (s *Service) RankCard(plat int8) (ranks []*rank.Rank, aids []int64) {
+	var limit int
+	if !model.IsIPad(plat) {
+		limit = 3
+	} else {
+		limit = 4
+	}
+	ranks = make([]*rank.Rank, 0, limit)
+	aids = make([]int64, 0, limit)
+	for _, rank := range s.rankCache {
+		ranks = append(ranks, rank)
+		aids = append(aids, rank.Aid)
+		if len(ranks) == limit {
+			break
+		}
+	}
+	return
+}

app/interface/main/app-intl/service/feed/service.go

@@ -0,0 +1,117 @@
+package feed
+
+import (
+	"time"
+
+	"go-common/app/interface/main/app-card/model/card/ai"
+	"go-common/app/interface/main/app-card/model/card/operate"
+	"go-common/app/interface/main/app-card/model/card/rank"
+	"go-common/app/interface/main/app-intl/conf"
+	accdao "go-common/app/interface/main/app-intl/dao/account"
+	arcdao "go-common/app/interface/main/app-intl/dao/archive"
+	blkdao "go-common/app/interface/main/app-intl/dao/black"
+	carddao "go-common/app/interface/main/app-intl/dao/card"
+	locdao "go-common/app/interface/main/app-intl/dao/location"
+	rankdao "go-common/app/interface/main/app-intl/dao/rank"
+	rcmdao "go-common/app/interface/main/app-intl/dao/recommend"
+	reldao "go-common/app/interface/main/app-intl/dao/relation"
+	tagdao "go-common/app/interface/main/app-intl/dao/tag"
+	"go-common/library/log"
+	"go-common/library/stat/prom"
+)
+
+// Service is show service.
+type Service struct {
+	c     *conf.Config
+	pHit  *prom.Prom
+	pMiss *prom.Prom
+	// dao
+	rcmd *rcmdao.Dao
+	tg   *tagdao.Dao
+	blk  *blkdao.Dao
+	rank *rankdao.Dao
+	card *carddao.Dao
+	// rpc
+	arc *arcdao.Dao
+	acc *accdao.Dao
+	rel *reldao.Dao
+	loc *locdao.Dao
+	// tick
+	tick time.Duration
+	// black cache
+	blackCache map[int64]struct{} // black aids
+	// ai cache
+	rcmdCache []*ai.Item
+	// rank cache
+	rankCache []*rank.Rank
+	// follow cache
+	followCache map[int64]*operate.Follow
+	// group cache
+	groupCache map[int64]int
+	// cache
+	cacheCh chan func()
+	// infoc
+	logCh chan interface{}
+}
+
+// New new a show service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:     c,
+		pHit:  prom.CacheHit,
+		pMiss: prom.CacheMiss,
+		// dao
+		rcmd: rcmdao.New(c),
+		blk:  blkdao.New(c),
+		rank: rankdao.New(c),
+		tg:   tagdao.New(c),
+		card: carddao.New(c),
+		// rpc
+		arc: arcdao.New(c),
+		rel: reldao.New(c),
+		acc: accdao.New(c),
+		loc: locdao.New(c),
+		// tick
+		tick: time.Duration(c.Tick),
+		// group cache
+		groupCache: map[int64]int{},
+		// cache
+		cacheCh: make(chan func(), 1024),
+		// infoc
+		logCh: make(chan interface{}, 1024),
+	}
+	s.loadBlackCache()
+	s.loadRcmdCache()
+	s.loadRankCache()
+	s.loadUpCardCache()
+	s.loadGroupCache()
+	go s.cacheproc()
+	go s.blackproc()
+	go s.rcmdproc()
+	go s.rankproc()
+	go s.upCardproc()
+	go s.groupproc()
+	go s.infocproc()
+	return
+}
+
+// addCache is.
+func (s *Service) addCache(f func()) {
+	select {
+	case s.cacheCh <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc is.
+func (s *Service) cacheproc() {
+	for {
+		f, ok := <-s.cacheCh
+		if !ok {
+			log.Warn("cache proc exit")
+			return
+		}
+		f()
+	}
+}