Create & Init Project...

app/interface/main/esports/service/BUILD

@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "favorite.go",
+        "match.go",
+        "match_active.go",
+        "pointdata.go",
+        "search.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/interface/main/esports/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/esports/conf:go_default_library",
+        "//app/interface/main/esports/dao:go_default_library",
+        "//app/interface/main/esports/model:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/favorite/api/gorpc:go_default_library",
+        "//app/service/main/favorite/model:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/metadata:go_default_library",
+        "//library/sync/errgroup:go_default_library",
+        "//library/sync/pipeline/fanout:go_default_library",
+        "//library/xstr:go_default_library",
+        "//vendor/github.com/robfig/cron: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"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "favorite_test.go",
+        "match_test.go",
+        "search_test.go",
+        "service_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/esports/conf:go_default_library",
+        "//app/interface/main/esports/model:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)

app/interface/main/esports/service/favorite.go

@@ -0,0 +1,375 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/esports/model"
+	favmdl "go-common/app/service/main/favorite/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+)
+
+const (
+	_firstPs    = 5
+	_firstAppPs = 50
+	_favDay     = 15
+)
+
+var _empStime = make([]string, 0)
+
+// AddFav add favorite contest.
+func (s *Service) AddFav(c context.Context, mid, cid int64) (err error) {
+	var (
+		contest *model.Contest
+		mapC    map[int64]*model.Contest
+		ip      = metadata.String(c, metadata.RemoteIP)
+	)
+	if mapC, err = s.dao.EpContests(c, []int64{cid}); err != nil {
+		return
+	}
+	contest = mapC[cid]
+	if contest == nil || contest.ID == 0 {
+		err = ecode.EsportsContestNotExist
+		return
+	}
+	if contest.LiveRoom <= 0 {
+		err = ecode.EsportsContestFavNot
+		return
+	}
+	nowTime := time.Now().Unix()
+	if contest.Etime > 0 && nowTime >= contest.Etime {
+		err = ecode.EsportsContestEnd
+		return
+	}
+	if contest.Stime == 0 || nowTime >= contest.Stime {
+		err = ecode.EsportsContestStart
+		return
+	}
+	subDay := timeSub(contest.Stime)
+	if subDay > _favDay {
+		err = ecode.EsportsContestNotDay
+		return
+	}
+	arg := &favmdl.ArgAdd{Type: favmdl.TypeEsports, Mid: mid, Oid: cid, Fid: 0, RealIP: ip}
+	if err = s.fav.Add(c, arg); err != nil {
+		log.Error("AddFav s.fav.Add(%+v) error(%v)", arg, err)
+		return
+	}
+	if err = s.dao.DelFavCoCache(c, mid); err != nil {
+		log.Error("AddFav s.dao.DelFavCoCache mid(%d) error(%v)", mid, err)
+		return
+	}
+	return
+}
+
+func timeSub(stime int64) int {
+	var (
+		nowTime, endTime time.Time
+	)
+	nowTime = time.Now()
+	endTime = time.Unix(stime, 0)
+	nowTime = time.Date(nowTime.Year(), nowTime.Month(), nowTime.Day(), 0, 0, 0, 0, time.Local)
+	endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, time.Local)
+	return int(endTime.Sub(nowTime).Hours() / 24)
+}
+
+// DelFav delete favorite contest.
+func (s *Service) DelFav(c context.Context, mid, cid int64) (err error) {
+	var (
+		contest *model.Contest
+		mapC    map[int64]*model.Contest
+		ip      = metadata.String(c, metadata.RemoteIP)
+	)
+	if mapC, err = s.dao.EpContests(c, []int64{cid}); err != nil {
+		return
+	}
+	contest = mapC[cid]
+	if contest == nil || contest.ID == 0 {
+		err = ecode.EsportsContestNotExist
+		return
+	}
+	arg := &favmdl.ArgDel{Type: favmdl.TypeEsports, Mid: mid, Oid: cid, Fid: 0, RealIP: ip}
+	if err = s.fav.Del(c, arg); err != nil {
+		log.Error("DelFav s.fav.Del(%+v) error(%v)", arg, err)
+		return
+	}
+	if err = s.dao.DelFavCoCache(c, mid); err != nil {
+		log.Error("DelFav s.dao.DelFavCoCache mid(%d) error(%v)", mid, err)
+		return
+	}
+	return
+}
+
+// ListFav list favorite contests.
+func (s *Service) ListFav(c context.Context, mid, vmid int64, pn, ps int) (rs []*model.Contest, count int, err error) {
+	var (
+		isFirst                     bool
+		uid                         int64
+		favRes                      *favmdl.Favorites
+		cids                        []int64
+		ip                          = metadata.String(c, metadata.RemoteIP)
+		teams, seasons              []*model.Filter
+		cData                       map[int64]*model.Contest
+		favContest                  []*model.Contest
+		group                       *errgroup.Group
+		contErr, teamErr, seasonErr error
+	)
+
+	if vmid > 0 {
+		uid = vmid
+	} else {
+		uid = mid
+	}
+	isFirst = pn == 1 && ps == _firstPs
+	if isFirst {
+		if rs, count, err = s.dao.FavCoCache(c, uid); err != nil {
+			err = nil
+		}
+		if len(rs) > 0 {
+			s.fmtContest(c, rs, mid)
+			return
+		}
+	}
+	arg := &favmdl.ArgFavs{Type: favmdl.TypeEsports, Mid: mid, Vmid: vmid, Fid: 0, Pn: pn, Ps: ps, RealIP: ip}
+	if favRes, err = s.fav.Favorites(c, arg); err != nil {
+		log.Error("ListFav s.fav.Favorites(%+v) error(%v)", arg, err)
+		return
+	}
+	count = favRes.Page.Count
+	if favRes == nil || len(favRes.List) == 0 || count == 0 {
+		rs = _emptContest
+		return
+	}
+	for _, fav := range favRes.List {
+		cids = append(cids, fav.Oid)
+	}
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if cData, contErr = s.dao.EpContests(c, cids); contErr != nil {
+			log.Error("s.dao.Contest error(%v)", contErr)
+		}
+		return contErr
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(errCtx); teamErr != nil {
+			log.Error("s.dao.Teams error %v", teamErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if seasons, seasonErr = s.dao.SeasonAll(errCtx); seasonErr != nil {
+			log.Error("s.dao.SeasonAll error %v", seasonErr)
+		}
+		return nil
+	})
+	err = group.Wait()
+	if err != nil {
+		return
+	}
+	for _, fav := range favRes.List {
+		if contest, ok := cData[fav.Oid]; ok {
+			favContest = append(favContest, contest)
+		}
+	}
+	rs = s.ContestInfo(c, cids, favContest, teams, seasons, mid)
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetFavCoCache(c, uid, rs, count)
+		})
+	}
+	return
+}
+
+// SeasonFav list favorite season.
+func (s *Service) SeasonFav(c context.Context, mid int64, p *model.ParamSeason) (rs []*model.Season, count int, err error) {
+	var (
+		uid        int64
+		elaContest []*model.ElaSub
+		mapSeasons map[int64]*model.Season
+		cids       []int64
+		sids       []int64
+		dbContests map[int64]*model.Contest
+	)
+	if p.VMID > 0 {
+		uid = p.VMID
+	} else {
+		uid = mid
+	}
+	if elaContest, count, err = s.dao.SeasonFav(c, uid, p); err != nil {
+		log.Error("s.dao.StimeFav error(%v)", err)
+		return
+	}
+	for _, contest := range elaContest {
+		cids = append(cids, contest.Oid)
+		sids = append(sids, contest.Sid)
+	}
+	if len(cids) > 0 {
+		if dbContests, err = s.dao.EpContests(c, cids); err != nil {
+			log.Error("s.dao.EpContests error(%v)", err)
+			return
+		}
+	} else {
+		rs = _emptSeason
+		return
+	}
+	if mapSeasons, err = s.dao.EpSeasons(c, sids); err != nil {
+		log.Error("s.dao.EpSeasons error(%v)", err)
+		return
+	}
+	ms := make(map[int64]struct{}, len(cids))
+	for _, contest := range elaContest {
+		if _, ok := ms[contest.Sid]; ok {
+			continue
+		}
+		// del over contest stime.
+		if contest, ok := dbContests[contest.Oid]; ok {
+			if contest.Etime > 0 && time.Now().Unix() > contest.Etime {
+				continue
+			}
+		}
+		ms[contest.Sid] = struct{}{}
+		if season, ok := mapSeasons[contest.Sid]; ok {
+			rs = append(rs, season)
+		}
+	}
+	if len(rs) == 0 {
+		rs = _emptSeason
+	}
+	return
+}
+
+// StimeFav list favorite contests stime.
+func (s *Service) StimeFav(c context.Context, mid int64, p *model.ParamSeason) (rs []string, count int, err error) {
+	var (
+		uid        int64
+		elaContest []*model.ElaSub
+		cids       []int64
+		dbContests map[int64]*model.Contest
+	)
+	if p.VMID > 0 {
+		uid = p.VMID
+	} else {
+		uid = mid
+	}
+	if elaContest, count, err = s.dao.StimeFav(c, uid, p); err != nil {
+		log.Error("s.dao.StimeFav error(%v)", err)
+	}
+	for _, contest := range elaContest {
+		cids = append(cids, contest.Oid)
+	}
+	if len(cids) > 0 {
+		if dbContests, err = s.dao.EpContests(c, cids); err != nil {
+			log.Error("s.dao.EpContests error(%v)", err)
+			return
+		}
+	} else {
+		rs = _empStime
+		return
+	}
+	ms := make(map[string]struct{}, len(cids))
+	for _, contest := range elaContest {
+		tm := time.Unix(contest.Stime, 0)
+		stime := tm.Format("2006-01-02")
+		if _, ok := ms[stime]; ok {
+			continue
+		}
+		ms[stime] = struct{}{}
+		// del over contest stime.
+		if contest, ok := dbContests[contest.Oid]; ok {
+			if contest.Etime > 0 && time.Now().Unix() > contest.Etime {
+				continue
+			}
+		}
+		rs = append(rs, stime)
+	}
+	if len(rs) == 0 {
+		rs = _empStime
+	}
+	return
+}
+
+// ListAppFav list favorite contests.
+func (s *Service) ListAppFav(c context.Context, mid int64, p *model.ParamFav) (rs []*model.Contest, count int, err error) {
+	var (
+		uid                         int64
+		cids                        []int64
+		isFirst                     bool
+		teams, seasons              []*model.Filter
+		cData                       map[int64]*model.Contest
+		favContest                  []*model.Contest
+		group                       *errgroup.Group
+		contErr, teamErr, seasonErr error
+	)
+	if p.VMID > 0 {
+		uid = p.VMID
+	} else {
+		uid = mid
+	}
+	isFirst = p.Pn == 1 && p.Ps == _firstAppPs && p.Stime == "" && p.Etime == "" && len(p.Sids) == 0 && p.Sort == 0
+	if isFirst {
+		if rs, count, err = s.dao.FavCoAppCache(c, uid); err != nil {
+			err = nil
+		}
+		if len(rs) > 0 {
+			s.fmtContest(c, rs, uid)
+			return
+		}
+	}
+	if cids, count, err = s.dao.SearchFav(c, uid, p); err != nil {
+		log.Error("s.dao.SearchFav error(%v)", err)
+		return
+	}
+	if len(cids) == 0 || count == 0 {
+		rs = _emptContest
+		return
+	}
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if cData, contErr = s.dao.EpContests(c, cids); contErr != nil {
+			log.Error("s.dao.Contest error(%v)", contErr)
+		}
+		return contErr
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(errCtx); teamErr != nil {
+			log.Error("s.dao.Teams error %v", teamErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if seasons, seasonErr = s.dao.SeasonAll(errCtx); seasonErr != nil {
+			log.Error("s.dao.SeasonAll error %v", seasonErr)
+		}
+		return nil
+	})
+	err = group.Wait()
+	if err != nil {
+		return
+	}
+	for _, cid := range cids {
+		if contest, ok := cData[cid]; ok {
+			favContest = append(favContest, contest)
+		}
+	}
+	rs = s.ContestInfo(c, cids, favContest, teams, seasons, uid)
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetAppFavCoCache(c, uid, rs, count)
+		})
+	}
+	return
+}
+
+func (s *Service) isFavs(c context.Context, mid int64, cids []int64) (res map[int64]bool, err error) {
+	if mid > 0 {
+		ip := metadata.String(c, metadata.RemoteIP)
+		if res, err = s.fav.IsFavs(c, &favmdl.ArgIsFavs{Type: favmdl.TypeEsports, Mid: mid, Oids: cids, RealIP: ip}); err != nil {
+			log.Error("s.fav.IsFavs(%d,%+v) error(%d)", mid, cids, err)
+			err = nil
+		}
+	}
+	return
+}

app/interface/main/esports/service/favorite_test.go

@@ -0,0 +1,31 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_AddFav(t *testing.T) {
+	Convey("test service addfav", t, WithService(func(s *Service) {
+		err := s.AddFav(context.Background(), 180, 3)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestService_DelFav(t *testing.T) {
+	Convey("test service delfav", t, WithService(func(s *Service) {
+		err := s.DelFav(context.Background(), 180, 0)
+		So(err, ShouldBeNil)
+	}))
+}
+
+func TestService_ListFav(t *testing.T) {
+	Convey("test service listfav", t, WithService(func(s *Service) {
+		res, count, err := s.ListFav(context.Background(), 10, 10, 1, 10)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan)
+		println(count)
+	}))
+}

app/interface/main/esports/service/match.go

@@ -0,0 +1,816 @@
+package service
+
+import (
+	"context"
+	"sort"
+	"strconv"
+	"time"
+
+	"go-common/app/interface/main/esports/model"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+const (
+	_gameNoSub = 6
+	_gameSub   = 3
+	_gameIn    = 5
+	_gameLive  = 4
+	_gameOver  = 1
+	_caleDay   = 3
+	_typeMatch = "matchs"
+	_typeGame  = "games"
+	_typeTeam  = "teams"
+	_typeYear  = "years"
+	_typeTag   = "tags"
+	_downline  = 0
+)
+
+var (
+	_emptContest       = make([]*model.Contest, 0)
+	_emptCalendar      = make([]*model.Calendar, 0)
+	_emptFilter        = make([]*model.Filter, 0)
+	_emptVideoList     = make([]*arcmdl.Arc, 0)
+	_emptSeason        = make([]*model.Season, 0)
+	_emptContestDetail = make([]*model.ContestsData, 0)
+)
+
+// FilterMatch filter match.
+func (s *Service) FilterMatch(c context.Context, p *model.ParamFilter) (rs map[string][]*model.Filter, err error) {
+	var (
+		tmpRs                map[string][]*model.Filter
+		fm                   *model.FilterES
+		fMap                 map[string]map[int64]*model.Filter
+		matchs, games, teams []*model.Filter
+	)
+	isAll := p.Tid == 0 && p.Gid == 0 && p.Mid == 0 && p.Stime == ""
+	if rs, err = s.dao.FMatCache(c); err != nil {
+		err = nil
+	}
+	if isAll && len(rs) > 0 {
+		return
+	}
+	matchs, games, teams = s.filterLeft(c)
+	tmpRs = make(map[string][]*model.Filter, 3)
+	tmpRs[_typeMatch] = matchs
+	tmpRs[_typeGame] = games
+	tmpRs[_typeTeam] = teams
+	if fm, err = s.dao.FilterMatch(c, p); err != nil {
+		log.Error("s.dao.FilterMatch error(%v)", err)
+		return
+	}
+	fMap = s.filterMap(tmpRs)
+	if tmpRs, err = s.fmtES(fm, fMap); err != nil {
+		log.Error("FilterMatch s.filterES error(%v)", err)
+	}
+	rs = make(map[string][]*model.Filter, 3)
+	rs[_typeMatch] = tmpRs[_typeMatch]
+	rs[_typeGame] = tmpRs[_typeGame]
+	rs[_typeTeam] = tmpRs[_typeTeam]
+	if isAll {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetFMatCache(c, rs)
+		})
+	} else {
+		if len(rs[_typeMatch]) == 0 && len(rs[_typeGame]) == 0 && len(rs[_typeTeam]) == 0 {
+			if tmpRs, err = s.dao.FMatCache(c); err != nil {
+				err = nil
+			}
+			if len(tmpRs) > 0 {
+				rs = tmpRs
+			}
+		}
+	}
+	return
+}
+
+func (s *Service) filterLeft(c context.Context) (matchs, games, teams []*model.Filter) {
+	var (
+		matchErr, gameErr, teamErr error
+	)
+	group := &errgroup.Group{}
+	group.Go(func() error {
+		if matchs, matchErr = s.dao.Matchs(context.Background()); matchErr != nil {
+			log.Error("s.dao.Matchs error %v", matchErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if games, gameErr = s.dao.Games(context.Background()); gameErr != nil {
+			log.Error("s.dao.Games error %v", gameErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(context.Background()); teamErr != nil {
+			log.Error("s.dao.Teams error %v", teamErr)
+		}
+		return nil
+	})
+	group.Wait()
+	if len(matchs) == 0 {
+		matchs = _emptFilter
+	}
+	if len(games) == 0 {
+		games = _emptFilter
+	}
+	if len(teams) == 0 {
+		teams = _emptFilter
+	}
+	return
+}
+
+// Calendar contest calendar count
+func (s *Service) Calendar(c context.Context, p *model.ParamFilter) (rs []*model.Calendar, err error) {
+	var fc map[string]int64
+	before3 := time.Now().AddDate(0, 0, -_caleDay).Format("2006-01-02")
+	after3 := time.Now().AddDate(0, 0, _caleDay).Format("2006-01-02")
+	todayAll := p.Mid == 0 && p.Gid == 0 && p.Tid == 0 && p.Stime == before3 && p.Etime == after3
+	if todayAll {
+		if rs, err = s.dao.CalendarCache(c, p); err != nil {
+			err = nil
+		}
+		if len(rs) > 0 {
+			return
+		}
+	}
+	if fc, err = s.dao.FilterCale(c, p); err != nil {
+		log.Error("s.dao.FilterCale error(%v)", err)
+		return
+	}
+	if len(fc) == 0 {
+		rs = _emptCalendar
+		return
+	}
+	for d, c := range fc {
+		rs = append(rs, &model.Calendar{Stime: d, Count: c})
+	}
+	if todayAll {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetCalendarCache(c, p, rs)
+		})
+	}
+	return
+}
+
+func (s *Service) fmtContest(c context.Context, contests []*model.Contest, mid int64) {
+	cids := s.contestIDs(contests)
+	favContest, _ := s.isFavs(c, mid, cids)
+	for _, contest := range contests {
+		if contest.Etime > 0 && time.Now().Unix() > contest.Etime {
+			contest.GameState = _gameOver
+		} else if contest.Stime <= time.Now().Unix() && (contest.Etime >= time.Now().Unix() || contest.Etime == 0) {
+			if contest.LiveRoom == 0 {
+				contest.GameState = _gameIn
+			} else {
+				contest.GameState = _gameLive
+			}
+		} else if contest.LiveRoom > 0 {
+			if v, ok := favContest[contest.ID]; ok && v && mid > 0 {
+				contest.GameState = _gameSub
+			} else {
+				contest.GameState = _gameNoSub
+			}
+		}
+	}
+}
+
+// ListContest contest list.
+func (s *Service) ListContest(c context.Context, mid int64, p *model.ParamContest) (rs []*model.Contest, total int, err error) {
+	var (
+		teams, seasons              []*model.Filter
+		cData, tmpRs                []*model.Contest
+		dbContests                  map[int64]*model.Contest
+		group                       *errgroup.Group
+		cids                        []int64
+		contErr, teamErr, seasonErr error
+	)
+	// get from cache.
+	isFirst := p.Mid == 0 && p.Gid == 0 && p.Tid == 0 && p.Stime == "" && p.GState == "" && p.Pn == 1 && len(p.Sids) == 0 && p.Sort == 0
+	if isFirst {
+		if rs, total, err = s.dao.ContestCache(c, p.Ps); err != nil {
+			err = nil
+		} else if len(rs) > 0 {
+			s.fmtContest(c, rs, mid)
+			return
+		}
+	}
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if cData, total, contErr = s.dao.SearchContest(errCtx, p); contErr != nil {
+			log.Error("s.dao.SearchContest error(%v)", contErr)
+		}
+		return contErr
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(errCtx); teamErr != nil {
+			log.Error("s.dao.Teams error(%v)", teamErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if seasons, seasonErr = s.dao.SeasonAll(errCtx); seasonErr != nil {
+			log.Error("s.dao.SeasonAll error %v", seasonErr)
+		}
+		return nil
+	})
+	err = group.Wait()
+	if err != nil {
+		return
+	}
+	if total == 0 || len(cData) == 0 {
+		rs = _emptContest
+		return
+	}
+	cids = s.contestIDs(cData)
+	if len(cids) > 0 {
+		if dbContests, err = s.dao.EpContests(c, cids); err != nil {
+			log.Error("s.dao.EpContests error(%v)", err)
+			return
+		}
+	}
+	for _, c := range cData {
+		if contest, ok := dbContests[c.ID]; ok {
+			tmpRs = append(tmpRs, contest)
+		}
+	}
+	rs = s.ContestInfo(c, cids, tmpRs, teams, seasons, mid)
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetContestCache(c, p.Ps, rs, total)
+		})
+	}
+	return
+}
+
+func (s *Service) contestIDs(cData []*model.Contest) (rs []int64) {
+	for _, contest := range cData {
+		rs = append(rs, contest.ID)
+	}
+	return
+}
+
+// ContestInfo contest add  team season.
+func (s *Service) ContestInfo(c context.Context, cids []int64, cData []*model.Contest, teams, seasons []*model.Filter, mid int64) (rs []*model.Contest) {
+	var (
+		mapTeam, mapSeason map[int64]*model.Filter
+	)
+	mapTeam = make(map[int64]*model.Filter, len(teams))
+	for _, team := range teams {
+		mapTeam[team.ID] = team
+	}
+	mapSeason = make(map[int64]*model.Filter, len(seasons))
+	for _, season := range seasons {
+		mapSeason[season.ID] = season
+	}
+	favContest, _ := s.isFavs(c, mid, cids)
+	for _, contest := range cData {
+		if contest == nil {
+			continue
+		}
+		if v, ok := mapTeam[contest.HomeID]; ok && v != nil {
+			contest.HomeTeam = v
+		} else {
+			contest.HomeTeam = struct{}{}
+		}
+		if v, ok := mapTeam[contest.AwayID]; ok && v != nil {
+			contest.AwayTeam = v
+		} else {
+			contest.AwayTeam = struct{}{}
+		}
+		if v, ok := mapTeam[contest.SuccessTeam]; ok && v != nil {
+			contest.SuccessTeaminfo = v
+		} else {
+			contest.SuccessTeaminfo = struct{}{}
+		}
+		if v, ok := mapSeason[contest.Sid]; ok && v != nil {
+			contest.Season = v
+		} else {
+			contest.Season = struct{}{}
+		}
+		if contest.Etime > 0 && time.Now().Unix() > contest.Etime {
+			contest.GameState = _gameOver
+		} else if contest.Stime <= time.Now().Unix() && (contest.Etime >= time.Now().Unix() || contest.Etime == 0) {
+			if contest.LiveRoom == 0 {
+				contest.GameState = _gameIn
+			} else {
+				contest.GameState = _gameLive
+			}
+		} else if contest.LiveRoom > 0 {
+			if v, ok := favContest[contest.ID]; ok && v && mid > 0 {
+				contest.GameState = _gameSub
+			} else {
+				contest.GameState = _gameNoSub
+			}
+		}
+		rs = append(rs, contest)
+	}
+	return
+}
+
+// ListVideo video list.
+func (s *Service) ListVideo(c context.Context, p *model.ParamVideo) (rs []*arcmdl.Arc, total int, err error) {
+	var (
+		vData     []*model.SearchVideo
+		aids      []int64
+		arcsReply *arcmdl.ArcsReply
+	)
+	isFirst := p.Mid == 0 && p.Gid == 0 && p.Tid == 0 && p.Year == 0 && p.Tag == 0 && p.Sort == 0 && p.Pn == 1
+	if isFirst {
+		// get from cache.
+		if rs, total, err = s.dao.VideoCache(c, p.Ps); err != nil {
+			err = nil
+		} else if len(rs) > 0 {
+			return
+		}
+	}
+	if vData, total, err = s.dao.SearchVideo(c, p); err != nil {
+		log.Error("s.dao.SearchVideo(%v) error(%v)", p, err)
+		return
+	}
+	if total == 0 {
+		rs = _emptVideoList
+		return
+	}
+	for _, arc := range vData {
+		aids = append(aids, arc.AID)
+	}
+	if arcsReply, err = s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: aids}); err != nil {
+		log.Error("ListVideo s.arc.Archives3 error(%v)", err)
+		return
+	}
+	for _, aid := range aids {
+		if arc, ok := arcsReply.Arcs[aid]; ok && arc.IsNormal() {
+			rs = append(rs, arc)
+		}
+	}
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetVideoCache(c, p.Ps, rs, total)
+		})
+	}
+	return
+}
+
+// FilterVideo filter video.
+func (s *Service) FilterVideo(c context.Context, p *model.ParamFilter) (rs map[string][]*model.Filter, err error) {
+	var (
+		tmpRs                             map[string][]*model.Filter
+		fv                                *model.FilterES
+		fMap                              map[string]map[int64]*model.Filter
+		matchs, games, teams, tags, years []*model.Filter
+	)
+	isAll := p.Year == 0 && p.Tag == 0 && p.Tid == 0 && p.Gid == 0 && p.Mid == 0
+	if rs, err = s.dao.FVideoCache(c); err != nil {
+		err = nil
+	}
+	if isAll && len(rs) > 0 {
+		return
+	}
+	matchs, games, teams, tags, years = s.filterTop(c)
+	tmpRs = make(map[string][]*model.Filter, 3)
+	tmpRs[_typeMatch] = matchs
+	tmpRs[_typeGame] = games
+	tmpRs[_typeTeam] = teams
+	tmpRs[_typeYear] = years
+	tmpRs[_typeTag] = tags
+	if fv, err = s.dao.FilterVideo(c, p); err != nil {
+		log.Error("s.dao.FilterVideo error(%v)", err)
+		return
+	}
+	fMap = s.filterMap(tmpRs)
+	if rs, err = s.fmtES(fv, fMap); err != nil {
+		log.Error("FilterVideo s.filterES error(%v)", err)
+	}
+	if isAll {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetFVideoCache(c, rs)
+		})
+	} else {
+		if len(rs[_typeMatch]) == 0 && len(rs[_typeGame]) == 0 && len(rs[_typeTeam]) == 0 && len(rs[_typeYear]) == 0 && len(rs[_typeTag]) == 0 {
+			if tmpRs, err = s.dao.FVideoCache(c); err != nil {
+				err = nil
+			}
+			if len(tmpRs) > 0 {
+				rs = tmpRs
+			}
+		}
+	}
+	return
+}
+
+func (s *Service) filterTop(c context.Context) (matchs, games, teams, tags, years []*model.Filter) {
+	var (
+		matchErr, gameErr, teamErr, tagErr, yearErr error
+	)
+	group := &errgroup.Group{}
+	group.Go(func() error {
+		if matchs, matchErr = s.dao.Matchs(context.Background()); matchErr != nil {
+			log.Error("s.dao.Matchs error %v", matchErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if games, gameErr = s.dao.Games(context.Background()); gameErr != nil {
+			log.Error("s.dao.Games error %v", gameErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(context.Background()); teamErr != nil {
+			log.Error("s.dao.Teams error %v", teamErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if tags, tagErr = s.dao.Tags(context.Background()); tagErr != nil {
+			log.Error("s.dao.tags error %v", tagErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if years, yearErr = s.dao.Years(context.Background()); yearErr != nil {
+			log.Error("s.dao.Years error %v", yearErr)
+		}
+		return nil
+	})
+	group.Wait()
+	if len(matchs) == 0 {
+		matchs = _emptFilter
+	}
+	if len(games) == 0 {
+		games = _emptFilter
+	}
+	if len(teams) == 0 {
+		teams = _emptFilter
+	}
+	if len(years) == 0 {
+		years = _emptFilter
+	}
+	if len(tags) == 0 {
+		tags = _emptFilter
+	}
+	return
+}
+
+func (s *Service) fmtES(fv *model.FilterES, fMap map[string]map[int64]*model.Filter) (rs map[string][]*model.Filter, err error) {
+	var (
+		intMid, intGid, intTeam, intTag, intYear int64
+		matchs, games, teams, tags, years        []*model.Filter
+	)
+	group := &errgroup.Group{}
+	group.Go(func() error {
+		for _, midGroup := range fv.GroupByMatch {
+			if intMid, err = strconv.ParseInt(midGroup.Key, 10, 64); err != nil {
+				err = nil
+				continue
+			}
+			if match, ok := fMap[_typeMatch][intMid]; ok {
+				matchs = append(matchs, match)
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		for _, gidGroup := range fv.GroupByGid {
+			if intGid, err = strconv.ParseInt(gidGroup.Key, 10, 64); err != nil {
+				err = nil
+				continue
+			}
+			if game, ok := fMap[_typeGame][intGid]; ok {
+				games = append(games, game)
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		for _, teamGroup := range fv.GroupByTeam {
+			if intTeam, err = strconv.ParseInt(teamGroup.Key, 10, 64); err != nil {
+				err = nil
+				continue
+			}
+			if team, ok := fMap[_typeTeam][intTeam]; ok {
+				teams = append(teams, team)
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		for _, tagGroup := range fv.GroupByTag {
+			if intTag, err = strconv.ParseInt(tagGroup.Key, 10, 64); err != nil {
+				err = nil
+				continue
+			}
+			if tag, ok := fMap[_typeTag][intTag]; ok {
+				tags = append(tags, tag)
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		for _, yearGroup := range fv.GroupByYear {
+			if intYear, err = strconv.ParseInt(yearGroup.Key, 10, 64); err != nil {
+				err = nil
+				continue
+			}
+			if year, ok := fMap[_typeYear][intYear]; ok {
+				years = append(years, year)
+			}
+		}
+		return nil
+	})
+	group.Wait()
+	rs = make(map[string][]*model.Filter, 5)
+	if len(matchs) == 0 {
+		matchs = _emptFilter
+	} else {
+		sort.Slice(matchs, func(i, j int) bool {
+			return matchs[i].Rank > matchs[j].Rank || (matchs[i].Rank == matchs[j].Rank && matchs[i].ID < matchs[j].ID)
+		})
+	}
+	if len(games) == 0 {
+		games = _emptFilter
+	} else {
+		sort.Slice(games, func(i, j int) bool { return games[i].ID < games[j].ID })
+	}
+	if len(teams) == 0 {
+		teams = _emptFilter
+	} else {
+		sort.Slice(teams, func(i, j int) bool { return teams[i].ID < teams[j].ID })
+	}
+	if len(years) == 0 {
+		years = _emptFilter
+	} else {
+		sort.Slice(years, func(i, j int) bool { return years[i].ID < years[j].ID })
+	}
+	if len(tags) == 0 {
+		tags = _emptFilter
+	} else {
+		sort.Slice(tags, func(i, j int) bool { return tags[i].ID < tags[j].ID })
+	}
+	rs[_typeMatch] = matchs
+	rs[_typeGame] = games
+	rs[_typeTeam] = teams
+	rs[_typeTag] = tags
+	rs[_typeYear] = years
+	return
+}
+
+func (s *Service) filterMap(f map[string][]*model.Filter) (rs map[string]map[int64]*model.Filter) {
+	var (
+		match, game, team, tag, year                *model.Filter
+		mapMatch, mapGame, mapTeam, mapTag, mapYear map[int64]*model.Filter
+	)
+	group := &errgroup.Group{}
+	group.Go(func() error {
+		mapMatch = make(map[int64]*model.Filter, len(f[_typeMatch]))
+		for _, match = range f[_typeMatch] {
+			if match != nil {
+				mapMatch[match.ID] = match
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		mapGame = make(map[int64]*model.Filter, len(f[_typeGame]))
+		for _, game = range f[_typeGame] {
+			if game != nil {
+				mapGame[game.ID] = game
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		mapTeam = make(map[int64]*model.Filter, len(f[_typeTeam]))
+		for _, team = range f[_typeTeam] {
+			if team != nil {
+				mapTeam[team.ID] = team
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		mapTag = make(map[int64]*model.Filter, len(f[_typeTag]))
+		for _, tag = range f[_typeTag] {
+			if tag != nil {
+				mapTag[tag.ID] = tag
+			}
+		}
+		return nil
+	})
+	group.Go(func() error {
+		mapYear = make(map[int64]*model.Filter, len(f[_typeYear]))
+		for _, year = range f[_typeYear] {
+			if year != nil {
+				mapYear[year.ID] = year
+			}
+		}
+		return nil
+	})
+	group.Wait()
+	rs = make(map[string]map[int64]*model.Filter, 5)
+	rs[_typeMatch] = mapMatch
+	rs[_typeGame] = mapGame
+	rs[_typeTeam] = mapTeam
+	rs[_typeTag] = mapTag
+	rs[_typeYear] = mapYear
+	return
+}
+
+// Season season list.
+func (s *Service) Season(c context.Context, p *model.ParamSeason) (rs []*model.Season, count int, err error) {
+	var (
+		seasons []*model.Season
+		start   = (p.Pn - 1) * p.Ps
+		end     = start + p.Ps - 1
+	)
+	if rs, count, err = s.dao.SeasonCache(c, start, end); err != nil || len(rs) == 0 {
+		err = nil
+		if seasons, err = s.dao.Season(c); err != nil {
+			log.Error("s.dao.Season error(%v)", err)
+			return
+		}
+		count = len(seasons)
+		if count == 0 || count < start {
+			rs = _emptSeason
+			return
+		}
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetSeasonCache(c, seasons, count)
+		})
+		if count > end+1 {
+			rs = seasons[start : end+1]
+		} else {
+			rs = seasons[start:]
+		}
+	}
+	return
+}
+
+// AppSeason  app season list.
+func (s *Service) AppSeason(c context.Context, p *model.ParamSeason) (rs []*model.Season, count int, err error) {
+	var (
+		seasons []*model.Season
+		start   = (p.Pn - 1) * p.Ps
+		end     = start + p.Ps - 1
+	)
+	if rs, count, err = s.dao.SeasonMCache(c, start, end); err != nil || len(rs) == 0 {
+		err = nil
+		if seasons, err = s.dao.AppSeason(c); err != nil {
+			log.Error("s.dao.AppSeason error(%v)", err)
+			return
+		}
+		count = len(seasons)
+		if count == 0 || count < start {
+			rs = _emptSeason
+			return
+		}
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.SetSeasonMCache(c, seasons, count)
+		})
+		if count > end+1 {
+			rs = seasons[start : end+1]
+		} else {
+			rs = seasons[start:]
+		}
+	}
+	sort.Slice(rs, func(i, j int) bool {
+		return rs[i].Rank > rs[j].Rank || (rs[i].Rank == rs[j].Rank && rs[i].Stime > rs[j].Stime)
+	})
+	return
+}
+
+// Contest contest data.
+func (s *Service) Contest(c context.Context, mid, cid int64) (res *model.ContestDataPage, err error) {
+	var (
+		contest             *model.Contest
+		contestData         []*model.ContestsData
+		teams               map[int64]*model.Team
+		season              map[int64]*model.Season
+		teamErr, contestErr error
+		games               []*model.Game
+		gameMap             map[int64]*model.Game
+	)
+	if res, err = s.dao.GetCSingleData(c, cid); err != nil || res == nil {
+		err = nil
+		res = &model.ContestDataPage{}
+		group, errCtx := errgroup.WithContext(c)
+		group.Go(func() error {
+			if contest, contestErr = s.dao.Contest(errCtx, cid); contestErr != nil {
+				log.Error("SingleData.dao.Contest error(%v)", teamErr)
+			}
+			return contestErr
+		})
+		group.Go(func() error {
+			if contestData, _ = s.dao.ContestData(errCtx, cid); err != nil {
+				log.Error("SingleData.dao.ContestData error(%v)", teamErr)
+			}
+			return nil
+		})
+		err = group.Wait()
+		if err != nil {
+			return
+		}
+		if contest.ID == 0 {
+			err = ecode.NothingFound
+			return
+		}
+		if len(contestData) == 0 {
+			contestData = _emptContestDetail
+		}
+		if teams, err = s.dao.EpTeams(c, []int64{contest.HomeID, contest.AwayID}); err != nil {
+			log.Error("SingleData.dao.Teams error(%v)", err)
+			err = nil
+		}
+		if season, err = s.dao.EpSeasons(c, []int64{contest.Sid}); err != nil {
+			log.Error("SingleData.dao.EpSeasons error(%v)", err)
+			err = nil
+		}
+		s.ContestInfos(contest, teams, season)
+		res.Contest = contest
+		res.Detail = contestData
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddCSingleData(c, cid, res)
+		})
+	}
+	if res.Contest.DataType == _lolType {
+		games = s.lolGameMap.Data[res.Contest.MatchID]
+	} else if res.Contest.DataType == _dotaType {
+		games = s.dotaGameMap.Data[res.Contest.MatchID]
+	}
+	if len(games) > 0 {
+		gameMap = make(map[int64]*model.Game, len(games))
+		for _, game := range games {
+			gameMap[game.ID] = game
+		}
+		for _, data := range res.Detail {
+			if g, ok := gameMap[data.PointData]; ok {
+				if g.Finished == true || (res.Contest.Etime > 0 && time.Now().Unix() > res.Contest.Etime) {
+					data.GameStatus = 1
+				} else if g.Finished == false {
+					data.GameStatus = 2
+				}
+			}
+		}
+	}
+	tmp := []*model.Contest{res.Contest}
+	s.fmtContest(c, tmp, mid)
+	return
+}
+
+// ContestInfos contest infos.
+func (s *Service) ContestInfos(contest *model.Contest, teams map[int64]*model.Team, season map[int64]*model.Season) {
+	if homeTeam, ok := teams[contest.HomeID]; ok {
+		contest.HomeTeam = homeTeam
+	} else {
+		contest.HomeTeam = struct{}{}
+	}
+	if awayTeam, ok := teams[contest.AwayID]; ok {
+		contest.AwayTeam = awayTeam
+	} else {
+		contest.AwayTeam = struct{}{}
+	}
+	if sea, ok := season[contest.Sid]; ok {
+		contest.Season = sea
+	} else {
+		contest.Season = struct{}{}
+	}
+}
+
+// Recent contest recents.
+func (s *Service) Recent(c context.Context, mid int64, param *model.ParamCDRecent) (res []*model.Contest, err error) {
+	var (
+		teams  map[int64]*model.Team
+		season map[int64]*model.Season
+	)
+	if res, err = s.dao.GetCRecent(c, param); err != nil || len(res) == 0 {
+		err = nil
+		if res, err = s.dao.ContestRecent(c, param.HomeID, param.AwayID, param.CID, param.Ps); err != nil {
+			log.Error("ContestRecent.dao.ContestRecent error(%v)", err)
+			return
+		}
+		if len(res) == 0 {
+			res = _emptContest
+			return
+		}
+		for _, contest := range res {
+			if teams, err = s.dao.EpTeams(c, []int64{contest.HomeID, contest.AwayID}); err != nil {
+				log.Error("SingleData.dao.Teams error(%v)", err)
+				err = nil
+			}
+			if season, err = s.dao.EpSeasons(c, []int64{contest.Sid}); err != nil {
+				log.Error("SingleData.dao.EpSeasons error(%v)", err)
+				err = nil
+			}
+			s.ContestInfos(contest, teams, season)
+			contest.SuccessTeaminfo = struct{}{}
+		}
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddCRecent(c, param, res)
+		})
+	}
+	s.fmtContest(c, res, mid)
+	return
+}

app/interface/main/esports/service/match_active.go

@@ -0,0 +1,537 @@
+package service
+
+import (
+	"context"
+	"time"
+
+	"go-common/app/interface/main/esports/model"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+	"go-common/library/xstr"
+)
+
+var (
+	_emptActDetail = make([]*model.ActiveDetail, 0)
+	_emptActModule = make([]*model.Module, 0)
+	_emptActVideos = make([]*arcmdl.Arc, 0)
+	_emptTreeList  = make([][]*model.TreeList, 0)
+)
+
+//ArcsInfo archive info
+func (s *Service) ArcsInfo(c context.Context, aids []int64) (arc []*arcmdl.Arc, err error) {
+	var (
+		arcsReply *arcmdl.ArcsReply
+		res       map[int64]*arcmdl.Arc
+	)
+	if arcsReply, err = s.arcClient.Arcs(c, &arcmdl.ArcsRequest{Aids: aids}); err != nil {
+		log.Error("s.arcClient.Arcs(%v) error(%v)", aids, err)
+		return
+	}
+	if arcsReply == nil {
+		return
+	}
+	res = make(map[int64]*arcmdl.Arc)
+	for k, v := range arcsReply.Arcs {
+		if v != nil && v.IsNormal() {
+			res[k] = v
+		}
+	}
+	for _, aid := range aids {
+		if v, ok := res[aid]; ok {
+			arc = append(arc, v)
+		}
+	}
+	return
+}
+
+// ActModules matchs active videos
+func (s *Service) ActModules(c context.Context, mmid int64) (res []*arcmdl.Arc, err error) {
+	var (
+		mModule *model.Module
+		aids    []int64
+	)
+	if res, err = s.dao.GetActModuleCache(c, mmid); err != nil || res == nil {
+		if mModule, err = s.dao.Module(c, mmid); err != nil {
+			return
+		}
+		if mModule == nil {
+			err = ecode.EsportsActVideoNotExist
+			return
+		}
+		if aids, err = xstr.SplitInts(mModule.Oids); err != nil {
+			return
+		}
+		if res, err = s.ArcsInfo(c, aids); err != nil {
+			return
+		}
+		if res == nil {
+			res = _emptActVideos
+			return
+		}
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddActModuleCache(c, mmid, res)
+		})
+	}
+	return
+}
+
+//MatchAct match act
+func (s *Service) MatchAct(c context.Context, aid int64) (act *model.Active, err error) {
+	if act, err = s.dao.GetMActCache(c, aid); err != nil || act == nil {
+		if act, err = s.dao.Active(c, aid); err != nil {
+			log.Error("s.dao.Active error(%v)", err)
+			return
+		}
+		if act != nil {
+			s.cache.Do(c, func(c context.Context) {
+				s.dao.AddMActCache(c, aid, act)
+			})
+		}
+	}
+	return
+}
+
+// ActPage matchs active page info
+func (s *Service) ActPage(c context.Context, aid int64) (res *model.ActivePage, err error) {
+	var (
+		act                                 *model.Active
+		modules                             []*model.Module
+		aids                                []int64
+		actDetail                           []*model.ActiveDetail
+		videos                              []*arcmdl.Arc
+		moduleErr, actDetailError, actError error
+		mapSeasons                          map[int64]*model.Season
+	)
+	if res, err = s.dao.GetActPageCache(c, aid); err != nil || res == nil {
+		res = &model.ActivePage{}
+		group, errCtx := errgroup.WithContext(c)
+		group.Go(func() error {
+			if act, actError = s.MatchAct(errCtx, aid); actError != nil {
+				log.Error("s.dao.Active error(%v)", moduleErr)
+			}
+			return actError
+		})
+		group.Go(func() error {
+			if modules, moduleErr = s.dao.Modules(errCtx, aid); moduleErr != nil {
+				log.Error("s.dao.Modules error(%v)", moduleErr)
+				return nil
+			}
+			if len(modules) > 0 && modules[0].Oids != "" {
+				if aids, moduleErr = xstr.SplitInts(modules[0].Oids); moduleErr != nil {
+					log.Error("s.ActPage.SplitInts oids error(%v) error(%v)", modules[0].Oids, moduleErr)
+					return nil
+				}
+				if videos, moduleErr = s.ArcsInfo(c, aids); moduleErr != nil {
+					log.Error("s.ActPage.ArcsInfo aids(%v) error(%v)", aids, moduleErr)
+				}
+			}
+			return nil
+		})
+		group.Go(func() error {
+			if actDetail, actDetailError = s.dao.ActDetail(errCtx, aid); actDetailError != nil {
+				log.Error("s.dao.ActDetail error(%v)", actDetailError)
+			}
+			return nil
+		})
+		err = group.Wait()
+		if err != nil {
+			return
+		}
+		if act == nil {
+			err = ecode.EsportsActNotExist
+			return
+		}
+		res.Active = act
+		if len(actDetail) == 0 {
+			res.ActiveDetail = _emptActDetail
+		} else {
+			res.ActiveDetail = actDetail
+		}
+		if len(modules) == 0 {
+			res.Modules = _emptActModule
+		} else {
+			res.Modules = modules
+		}
+		if len(videos) == 0 {
+			res.Videos = _emptActVideos
+		} else {
+			res.Videos = videos
+		}
+		if mapSeasons, err = s.dao.EpSeasons(c, []int64{act.Sid}); err != nil {
+			log.Error("s.dao.EpSeasons error(%v)", err)
+			err = nil
+		}
+		if season, ok := mapSeasons[act.Sid]; ok {
+			res.Season = season
+		} else {
+			res.Season = &model.Season{}
+		}
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddActPageCache(c, aid, res)
+		})
+	}
+	return
+}
+
+//ContestCommon act match same deal logic
+func (s *Service) ContestCommon(c context.Context, mid int64, p *model.ParamContest) (rs []*model.Contest, total int, err error) {
+	var (
+		cData, tmpRs                []*model.Contest
+		contErr, teamErr, seasonErr error
+		teams, seasons              []*model.Filter
+		cids                        []int64
+		dbContests                  map[int64]*model.Contest
+	)
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		if cData, total, contErr = s.dao.SearchContestQuery(errCtx, p); contErr != nil {
+			log.Error("s.dao.SearchContest error(%v)", contErr)
+		}
+		return contErr
+	})
+	group.Go(func() error {
+		if teams, teamErr = s.dao.Teams(errCtx); teamErr != nil {
+			log.Error("s.dao.Teams error(%v)", teamErr)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if seasons, seasonErr = s.dao.SeasonAll(errCtx); seasonErr != nil {
+			log.Error("s.dao.SeasonAll error %v", seasonErr)
+		}
+		return nil
+	})
+	err = group.Wait()
+	if err != nil {
+		return
+	}
+	if total == 0 || len(cData) == 0 {
+		rs = _emptContest
+		return
+	}
+	cids = s.contestIDs(cData)
+	if len(cids) > 0 {
+		if dbContests, err = s.dao.EpContests(c, cids); err != nil {
+			log.Error("s.dao.Contest error(%v)", err)
+			return
+		}
+	}
+	for _, c := range cData {
+		if contest, ok := dbContests[c.ID]; ok {
+			tmpRs = append(tmpRs, contest)
+		}
+	}
+	rs = s.ContestInfo(c, cids, tmpRs, teams, seasons, mid)
+	return
+}
+
+// ActTop act match top data
+func (s *Service) ActTop(c context.Context, mid int64, param *model.ParamActTop) (res []*model.Contest, total int, err error) {
+	var (
+		act          *model.Active
+		sids         []int64
+		mapSeasons   map[int64]*model.Season
+		sTime, eTime time.Time
+		season       *model.Season
+		ok           bool
+	)
+	isFirst := param.Pn == 1 && param.Sort == 0 && param.Stime == ""
+	if isFirst {
+		if res, total, err = s.dao.GetActTopCache(c, param.Aid, int64(param.Ps)); err != nil {
+			err = nil
+		} else if len(res) > 0 {
+			s.fmtContest(c, res, mid)
+			return
+		}
+	}
+	if act, err = s.MatchAct(c, param.Aid); err != nil {
+		log.Error("s.MatchAct error(%v)", err)
+		return
+	}
+	if act == nil || act.Sid <= 0 {
+		err = ecode.EsportsActNotExist
+		return
+	}
+	sids = []int64{act.Sid}
+	if mapSeasons, err = s.dao.EpSeasons(c, sids); err != nil {
+		log.Error("MatchAct s.dao.EpSeasons error(%v)", err)
+		return
+	}
+	season, ok = mapSeasons[act.Sid]
+	if !ok {
+		log.Error("s.ActTop sid(%d) not exists", act.Sid)
+		return
+	}
+	if param.Stime != "" {
+		sTime, _ = time.ParseInLocation("2006-01-02", param.Stime, time.Local)
+		if sTime.Unix() <= season.Stime {
+			param.Stime = time.Unix(season.Stime, 0).Format("2006-01-02 15:04:05")
+		} else {
+			sTime, _ = time.ParseInLocation("2006-01-02", param.Stime, time.Local)
+			param.Stime = time.Unix(sTime.Unix(), 0).Format("2006-01-02") + " 00:00:00"
+		}
+	} else {
+		param.Stime = time.Unix(season.Stime, 0).Format("2006-01-02 15:04:05")
+	}
+	if param.Etime != "" {
+		if season.Etime != 0 {
+			eTime, _ = time.ParseInLocation("2006-01-02", param.Etime, time.Local)
+			if eTime.Unix() >= season.Etime {
+				param.Etime = time.Unix(season.Etime, 0).Format("2006-01-02 15:04:05")
+			} else {
+				eTime, _ = time.ParseInLocation("2006-01-02", param.Etime, time.Local)
+				param.Etime = time.Unix(eTime.Unix(), 0).Format("2006-01-02") + " 23:59:59"
+			}
+		} else {
+			eTime, _ = time.ParseInLocation("2006-01-02", param.Etime, time.Local)
+			param.Etime = time.Unix(eTime.Unix(), 0).Format("2006-01-02") + " 23:59:59"
+		}
+	} else {
+		if season.Etime != 0 {
+			param.Etime = time.Unix(season.Etime, 0).Format("2006-01-02 15:04:05")
+		}
+	}
+	p := &model.ParamContest{
+		Mid:   act.Mid,
+		Sids:  []int64{act.Sid},
+		Sort:  param.Sort,
+		Stime: param.Stime,
+		Etime: param.Etime,
+		Pn:    param.Pn,
+		Ps:    param.Ps,
+	}
+	if res, total, err = s.ContestCommon(c, mid, p); err != nil {
+		return
+	}
+	if len(res) == 0 {
+		res = _emptContest
+		return
+	}
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddActTopCache(c, param.Aid, int64(param.Ps), res, total)
+		})
+	}
+	return
+}
+
+// ActPoints act match point match
+func (s *Service) ActPoints(c context.Context, mid int64, param *model.ParamActPoint) (res []*model.Contest, total int, err error) {
+	var (
+		act    *model.Active
+		detail *model.ActiveDetail
+	)
+	isFirst := param.Pn == 1 && param.Sort == 0
+	if isFirst {
+		if res, total, err = s.dao.GetActPointsCache(c, param.Aid, param.MdID, int64(param.Ps)); err != nil {
+			err = nil
+		} else if len(res) > 0 {
+			s.fmtContest(c, res, mid)
+			return
+		}
+	}
+	if act, err = s.MatchAct(c, param.Aid); err != nil {
+		log.Error("s.dao.Active error(%v)", err)
+		return
+	}
+	if act == nil || act.Sid <= 0 {
+		err = ecode.EsportsActNotExist
+		return
+	}
+	p := &model.ParamContest{
+		Mid:  act.Mid,
+		Sids: []int64{act.Sid},
+		Sort: param.Sort,
+		Pn:   param.Pn,
+		Ps:   param.Ps,
+	}
+	detail, err = s.dao.PActDetail(c, param.MdID)
+	if err != nil {
+		log.Error("s.dao.PActDetail error(%v)", err)
+		return
+	}
+	if detail != nil {
+		if detail.STime != 0 {
+			p.Stime = time.Unix(detail.STime, 0).Format("2006-01-02 15:04:05")
+		}
+		if detail.ETime != 0 {
+			p.Etime = time.Unix(detail.ETime, 0).Format("2006-01-02 15:04:05")
+		}
+	} else {
+		err = ecode.EsportsActPointNotExist
+		return
+	}
+	if res, total, err = s.ContestCommon(c, mid, p); err != nil {
+		return
+	}
+	if len(res) == 0 {
+		res = _emptContest
+		return
+	}
+	if isFirst {
+		s.cache.Do(c, func(c context.Context) {
+			s.dao.AddActPointsCache(c, param.Aid, param.MdID, int64(param.Ps), res, total)
+		})
+	}
+	return
+}
+
+//contestTeam get contest team
+func (s *Service) contestTeam(c context.Context, contests map[int64]*model.Contest, teams map[int64]*model.Filter) (list []*model.ContestInfo, err error) {
+	for _, v := range contests {
+		contest := &model.ContestInfo{Contest: v}
+		if v.HomeID > 0 {
+			if team, ok := teams[v.HomeID]; ok {
+				contest.HomeName = team.Title
+				contest.HomeTeam = team
+			} else {
+				contest.HomeName = ""
+				contest.HomeTeam = struct{}{}
+			}
+		} else {
+			contest.HomeName = ""
+			contest.HomeTeam = struct{}{}
+		}
+		if v.AwayID > 0 {
+			if team, ok := teams[v.AwayID]; ok {
+				contest.AwayName = team.Title
+				contest.AwayTeam = team
+			} else {
+				contest.AwayName = ""
+				contest.AwayTeam = struct{}{}
+			}
+		} else {
+			contest.AwayName = ""
+			contest.AwayTeam = struct{}{}
+		}
+		if v.SuccessTeam > 0 {
+			if team, ok := teams[v.SuccessTeam]; ok {
+				contest.SuccessName = team.Title
+			} else {
+				contest.SuccessName = ""
+			}
+		} else {
+			contest.SuccessName = ""
+		}
+		contest.Season = struct{}{}
+		contest.SuccessTeaminfo = struct{}{}
+		list = append(list, contest)
+	}
+	return
+}
+
+//TeamMap get team and map team id to team
+func (s *Service) TeamMap(ctx context.Context) (res map[int64]*model.Filter, err error) {
+	var (
+		teams []*model.Filter
+	)
+	if teams, err = s.dao.Teams(ctx); err != nil {
+		log.Error("LoadKnockoutTree s.dao.Teams error(%v)", err)
+		return
+	}
+	res = make(map[int64]*model.Filter)
+	for _, v := range teams {
+		res[v.ID] = v
+	}
+	return
+}
+
+// BuildKnockTree knock tree.
+func (s *Service) BuildKnockTree(c context.Context) {
+	var (
+		trees       []*model.Tree
+		sTree       []*model.TreeList
+		mids        []int64
+		contests    map[int64]*model.Contest
+		cInfos      []*model.ContestInfo
+		mapContests map[int64]*model.ContestInfo
+		treeList    [][]*model.TreeList
+		err         error
+		details     []*model.ActiveDetail
+		teamMap     map[int64]*model.Filter
+	)
+	if teamMap, err = s.TeamMap(c); err != nil {
+		log.Error("LoadKnockoutTree TeamMap error(%v)", err)
+		return
+	}
+	if details, err = s.dao.KDetails(c); err != nil {
+		log.Error("LoadKnockoutTree s.dao.KDetails error(%v)", err)
+		return
+	}
+	//build tree
+	for _, detail := range details {
+		if detail.Online == _downline {
+			//edit status; must add cache time
+			if s.dao.AddActKnockCacheTime(c, detail.ID); err != nil {
+				log.Error("LoadKnockoutTree s.dao.AddActKnockCacheTime error(%v)", err)
+				continue
+			}
+		} else {
+			treeList = _emptTreeList
+			sTree = make([]*model.TreeList, 0)
+			if trees, err = s.dao.Trees(c, detail.ID); err != nil {
+				log.Error("s.dao.Trees error(%v)", err)
+				return
+			}
+			for _, tree := range trees {
+				mids = append(mids, tree.Mid)
+			}
+			if len(mids) == 0 {
+				continue
+			} else {
+				count := len(mids)
+				if contests, err = s.dao.EpContests(c, mids); err != nil {
+					log.Error("s.dao.RawEpContests error(%v)", err)
+					continue
+				}
+				if cInfos, err = s.contestTeam(c, contests, teamMap); err != nil {
+					log.Error("s.contestTeam Error (%v)", err)
+					continue
+				}
+				mapContests = make(map[int64]*model.ContestInfo, count)
+				for _, info := range cInfos {
+					mapContests[info.ID] = info
+				}
+				for _, tree := range trees {
+					if tree.Pid == 0 {
+						if len(sTree) > 0 {
+							treeList = append(treeList, sTree)
+						}
+						sTree = nil
+						if cInfo, ok := mapContests[tree.Mid]; ok {
+							sTree = append(sTree, &model.TreeList{Tree: tree, ContestInfo: cInfo})
+						} else {
+							sTree = append(sTree, &model.TreeList{Tree: tree})
+						}
+					} else {
+						if cInfo, ok := mapContests[tree.Mid]; ok {
+							sTree = append(sTree, &model.TreeList{Tree: tree, ContestInfo: cInfo})
+						} else {
+							sTree = append(sTree, &model.TreeList{Tree: tree})
+						}
+					}
+				}
+				if len(sTree) > 0 {
+					treeList = append(treeList, sTree)
+				}
+				if len(treeList) > 0 {
+					go s.dao.AddActKnockoutCache(context.Background(), detail.ID, treeList)
+				}
+			}
+		}
+	}
+}
+
+// ActKnockout knockout tree
+func (s *Service) ActKnockout(c context.Context, madID int64) (res [][]*model.TreeList, err error) {
+	if res, err = s.dao.GetActKnockoutCache(c, madID); err != nil {
+		return
+	}
+	if len(res) == 0 {
+		res = _emptTreeList
+		err = ecode.EsportsActKnockNotExist
+	}
+	return
+}

app/interface/main/esports/service/match_test.go

@@ -0,0 +1,80 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/esports/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Calendar(t *testing.T) {
+	Convey("test service calendar", t, WithService(func(s *Service) {
+		res, err := s.Calendar(context.Background(), &model.ParamFilter{Stime: "2018-07-27", Etime: "2018-08-02"})
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func TestService_FilterMatch(t *testing.T) {
+	Convey("test service filterMatch", t, WithService(func(s *Service) {
+		res, err := s.FilterMatch(context.Background(), &model.ParamFilter{Mid: 0})
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+func TestService_FilterVideo(t *testing.T) {
+	Convey("test service filterVideo", t, WithService(func(s *Service) {
+		res, err := s.FilterVideo(context.Background(), &model.ParamFilter{Mid: 0})
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}
+
+func TestService_ListVideo(t *testing.T) {
+	Convey("test service listVideo", t, WithService(func(s *Service) {
+		arg := &model.ParamVideo{
+			Mid:  int64(0),
+			Gid:  int64(0),
+			Tid:  int64(0),
+			Year: int64(2018),
+			Tag:  int64(1),
+			Pn:   1,
+			Ps:   30,
+		}
+		res, total, err := s.ListVideo(context.Background(), arg)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		println(total)
+	}))
+}
+
+func TestService_ListContest(t *testing.T) {
+	Convey("test service listContest", t, WithService(func(s *Service) {
+		arg := &model.ParamContest{
+			Mid:    int64(0),
+			GState: "0,3,4",
+			Pn:     1,
+			Ps:     10,
+		}
+		mid := int64(12309)
+		res, total, err := s.ListContest(context.Background(), mid, arg)
+		So(err, ShouldBeNil)
+		So(len(res), ShouldBeGreaterThan, 0)
+		println(total)
+	}))
+}
+
+func TestService_Season(t *testing.T) {
+	Convey("test service Season", t, WithService(func(s *Service) {
+		arg := &model.ParamSeason{
+			Pn: 1,
+			Ps: 5,
+		}
+		res, count, err := s.Season(context.Background(), arg)
+		So(err, ShouldBeNil)
+		So(count, ShouldBeGreaterThan, 0)
+		So(len(res), ShouldBeGreaterThan, 0)
+	}))
+}

app/interface/main/esports/service/pointdata.go

@@ -0,0 +1,127 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/interface/main/esports/model"
+)
+
+// Game get game.
+func (s *Service) Game(c context.Context, p *model.ParamGame) (rs map[int64]*model.Game, err error) {
+	var (
+		ok      bool
+		games   []*model.Game
+		gameMap map[int64]*model.Game
+	)
+	rs = make(map[int64]*model.Game, len(p.GameIDs))
+	if p.Tp == _lolType {
+		if games, ok = s.lolGameMap.Data[p.MatchID]; !ok {
+			return
+		}
+	} else if p.Tp == _dotaType {
+		if games, ok = s.dotaGameMap.Data[p.MatchID]; !ok {
+			return
+		}
+	}
+	count := len(games)
+	if count == 0 {
+		return
+	}
+	gameMap = make(map[int64]*model.Game, count)
+	for _, game := range games {
+		gameMap[game.ID] = game
+	}
+	for _, id := range p.GameIDs {
+		if game, ok := gameMap[id]; ok {
+			rs[id] = game
+		}
+	}
+	return
+}
+
+// Items get items.
+func (s *Service) Items(c context.Context, p *model.ParamLeidas) (rs map[int64]*model.Item, err error) {
+	rs = make(map[int64]*model.Item, len(p.IDs))
+	if p.Tp == _lolType {
+		for _, id := range p.IDs {
+			if item, ok := s.lolItemsMap.Data[id]; ok {
+				rs[id] = item
+			}
+		}
+	} else if p.Tp == _dotaType {
+		for _, id := range p.IDs {
+			if item, ok := s.dotaItemsMap.Data[id]; ok {
+				rs[id] = item
+			}
+		}
+	}
+	return
+}
+
+// Heroes lol:champions ; dota2 heroes.
+func (s *Service) Heroes(c context.Context, p *model.ParamLeidas) (rs interface{}, err error) {
+	var (
+		champions  map[int64]*model.Champion
+		dotaHeroes map[int64]*model.Hero
+	)
+	if p.Tp == _lolType {
+		champions = make(map[int64]*model.Champion, len(p.IDs))
+		for _, id := range p.IDs {
+			if item, ok := s.lolChampions.Data[id]; ok {
+				champions[id] = item
+			}
+		}
+		rs = champions
+	} else if p.Tp == _dotaType {
+		dotaHeroes = make(map[int64]*model.Hero, len(p.IDs))
+		for _, id := range p.IDs {
+			if item, ok := s.dotaHeroes.Data[id]; ok {
+				dotaHeroes[id] = item
+			}
+		}
+		rs = dotaHeroes
+	}
+	return
+}
+
+// Abilities lol:spells;dota2:abilities.
+func (s *Service) Abilities(c context.Context, p *model.ParamLeidas) (rs interface{}, err error) {
+	infos := make(map[int64]*model.LdInfo, len(p.IDs))
+	if p.Tp == _lolType {
+		for _, id := range p.IDs {
+			if info, ok := s.lolSpells.Data[id]; ok {
+				infos[id] = info
+			}
+		}
+		rs = infos
+	} else if p.Tp == _dotaType {
+		for _, id := range p.IDs {
+			if info, ok := s.dotaAbilities.Data[id]; ok {
+				infos[id] = info
+			}
+		}
+		rs = infos
+	}
+	return
+}
+
+// Players get players.
+func (s *Service) Players(c context.Context, p *model.ParamLeidas) (rs interface{}, err error) {
+	infos := make(map[int64]*model.LdInfo, len(p.IDs))
+	if p.Tp == _lolType {
+		for _, id := range p.IDs {
+			if info, ok := s.lolPlayers.Data[id]; ok {
+				infos[id] = info
+			}
+		}
+		rs = infos
+	} else if p.Tp == _dotaType {
+		for _, id := range p.IDs {
+			if info, ok := s.dotaPlayers.Data[id]; ok {
+				infos[id] = info
+			}
+		}
+		rs = infos
+	}
+	return
+}

app/interface/main/esports/service/search.go

@@ -0,0 +1,13 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/interface/main/esports/model"
+)
+
+// Search  search video list.
+func (s *Service) Search(c context.Context, mid int64, p *model.ParamSearch, buvid string) (rs *model.SearchEsp, err error) {
+	rs, err = s.dao.Search(c, mid, p, buvid)
+	return
+}

app/interface/main/esports/service/search_test.go

@@ -0,0 +1,23 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"go-common/app/interface/main/esports/model"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Search(t *testing.T) {
+	Convey("test service Search", t, WithService(func(s *Service) {
+		arg := &model.ParamSearch{
+			Keyword: "dota",
+			Pn:      1,
+			Ps:      30,
+		}
+		res, err := s.Search(context.Background(), 0, arg, "")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeEmpty)
+	}))
+}

app/interface/main/esports/service/service.go

@@ -0,0 +1,364 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"math"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"go-common/app/interface/main/esports/conf"
+	"go-common/app/interface/main/esports/dao"
+	"go-common/app/interface/main/esports/model"
+	arcclient "go-common/app/service/main/archive/api"
+	favrpc "go-common/app/service/main/favorite/api/gorpc"
+	"go-common/library/log"
+	"go-common/library/sync/pipeline/fanout"
+
+	"github.com/robfig/cron"
+)
+
+const (
+	_perPage       = 100
+	_lolType       = 1
+	_dotaType      = 2
+	_firstPage     = "1"
+	_lolGame       = "lol/games"
+	_dotaGame      = "dota2/games"
+	_lolItems      = "lol/items"
+	_dotaItems     = "dota2/items"
+	_lolChampions  = "lol/champions"
+	_lolHeroes     = "dota2/heroes"
+	_lolSpells     = "lol/spells"
+	_dotaAbilities = "dota2/abilities"
+	_lolPlayers    = "lol/players"
+	_dotaPlayers   = "dota2/players"
+)
+
+// Service service struct.
+type Service struct {
+	c   *conf.Config
+	dao *dao.Dao
+	// rpc
+	fav *favrpc.Service
+	// cache proc
+	cache                     *fanout.Fanout
+	arcClient                 arcclient.ArchiveClient
+	lolGameMap, dotaGameMap   *model.SyncGame
+	lolItemsMap, dotaItemsMap *model.SyncItem
+	lolChampions              *model.SyncChampion
+	dotaHeroes                *model.SyncHero
+	lolSpells, dotaAbilities  *model.SyncInfo
+	lolPlayers, dotaPlayers   *model.SyncInfo
+	// cron
+	cron *cron.Cron
+}
+
+// New new service.
+func New(c *conf.Config) *Service {
+	s := &Service{
+		c:     c,
+		dao:   dao.New(c),
+		fav:   favrpc.New2(c.FavoriteRPC),
+		cache: fanout.New("cache"),
+		lolGameMap: &model.SyncGame{
+			Data: make(map[int64][]*model.Game),
+		},
+		dotaGameMap: &model.SyncGame{
+			Data: make(map[int64][]*model.Game),
+		},
+		lolItemsMap: &model.SyncItem{
+			Data: make(map[int64]*model.Item),
+		},
+		dotaItemsMap: &model.SyncItem{
+			Data: make(map[int64]*model.Item),
+		},
+		lolChampions: &model.SyncChampion{
+			Data: make(map[int64]*model.Champion),
+		},
+		dotaHeroes: &model.SyncHero{
+			Data: make(map[int64]*model.Hero),
+		},
+		lolSpells: &model.SyncInfo{
+			Data: make(map[int64]*model.LdInfo),
+		},
+		dotaAbilities: &model.SyncInfo{
+			Data: make(map[int64]*model.LdInfo),
+		},
+		lolPlayers: &model.SyncInfo{
+			Data: make(map[int64]*model.LdInfo),
+		},
+		dotaPlayers: &model.SyncInfo{
+			Data: make(map[int64]*model.LdInfo),
+		},
+		cron: cron.New(),
+	}
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	go s.loadKnockTreeCache()
+	go s.loadLdGame()
+	go s.createCron()
+	return s
+}
+
+// Ping ping service.
+func (s *Service) Ping(c context.Context) (err error) {
+	if err = s.dao.Ping(c); err != nil {
+		log.Error("s.dao.Ping error(%v)", err)
+	}
+	return
+}
+
+// loadCache load cache
+func (s *Service) loadKnockTreeCache() {
+	for {
+		s.BuildKnockTree(context.Background())
+		time.Sleep(time.Duration(conf.Conf.Rule.KnockTree))
+	}
+}
+
+func (s *Service) loadLdGame() {
+	var (
+		contestDatas []*model.Contest
+		err          error
+	)
+	for {
+		if contestDatas, err = s.dao.ContestDatas(context.Background()); err != nil {
+			log.Error("loadLeida  s.dao.ContestDatas error(%v)", err)
+			time.Sleep(time.Second)
+			continue
+		}
+		for _, data := range contestDatas {
+			tmp := data
+			go s.setGamesMap(tmp)
+		}
+		time.Sleep(time.Duration(conf.Conf.Leidata.AfterSleep))
+	}
+}
+func (s *Service) createCron() {
+	go s.lolPlayersCron()
+	go s.dotaPlayersCron()
+	go s.infoCron()
+	s.cron.AddFunc(s.c.Leidata.LolPlayersCron, s.lolPlayersCron)
+	s.cron.AddFunc(s.c.Leidata.DotaPlayersCron, s.dotaPlayersCron)
+	s.cron.AddFunc(s.c.Leidata.InfoCron, s.infoCron)
+	s.cron.Start()
+}
+func (s *Service) lolPlayersCron() {
+	go s.loadLdPages(_lolPlayers)
+	log.Info("createCron lolPlayersCron start")
+}
+func (s *Service) dotaPlayersCron() {
+	go s.loadLdPages(_dotaPlayers)
+	log.Info("createCron dotaPlayersCron start")
+}
+func (s *Service) infoCron() {
+	go s.loadLdPages(_lolItems)
+	go s.loadLdPages(_dotaItems)
+	go s.loadLdPages(_lolSpells)
+	go s.loadLdPages(_dotaAbilities)
+	go s.loadLdPages(_lolChampions)
+	go s.loadLdPages(_lolHeroes)
+	log.Info("createCron infoCron start")
+}
+
+func (s *Service) setGamesMap(data *model.Contest) {
+	var (
+		err     error
+		params  url.Values
+		rs      json.RawMessage
+		games   []*model.Game
+		endTime time.Time
+		isTime  bool
+	)
+	params = url.Values{}
+	params.Set("match_id", strconv.FormatInt(data.MatchID, 10))
+	if data.Etime > 0 {
+		endTime = time.Unix(data.Etime, 0).Add(time.Duration(s.c.Leidata.EndSleep))
+		if time.Now().Unix() > endTime.Unix() {
+			isTime = true
+		}
+	}
+	if !isTime && data.Stime > 0 && time.Now().Unix() < data.Stime {
+		isTime = true
+	}
+	if data.DataType == _lolType {
+		if _, ok := s.lolGameMap.Data[data.MatchID]; ok && isTime {
+			return
+		}
+		if rs, _, err = s.leida(params, _lolGame); err == nil {
+			if err = json.Unmarshal(rs, &games); err == nil {
+				s.lolGameMap.Lock()
+				s.lolGameMap.Data[data.MatchID] = games
+				s.lolGameMap.Unlock()
+			}
+		}
+	} else if data.DataType == _dotaType {
+		if _, ok := s.dotaGameMap.Data[data.MatchID]; ok && isTime {
+			return
+		}
+		if rs, _, err = s.leida(params, _dotaGame); err == nil {
+			if err = json.Unmarshal(rs, &games); err == nil {
+				s.dotaGameMap.Lock()
+				s.dotaGameMap.Data[data.MatchID] = games
+				s.dotaGameMap.Unlock()
+			}
+		}
+	}
+}
+
+func (s *Service) loadLdPages(tp string) {
+	var (
+		err    error
+		params url.Values
+		count  int
+	)
+	params = url.Values{}
+	params.Set("page", _firstPage)
+	params.Set("per_page", strconv.Itoa(_perPage))
+	if count, err = s.setPages(tp, params); err != nil {
+		return
+	}
+	for i := 2; i <= count; i++ {
+		time.Sleep(time.Second)
+		params.Set("page", strconv.Itoa(i))
+		params.Set("per_page", strconv.Itoa(_perPage))
+		s.setPages(tp, params)
+	}
+}
+
+func (s *Service) setPages(tp string, params url.Values) (count int, err error) {
+	var (
+		rs        json.RawMessage
+		items     []*model.Item
+		infos     []*model.LdInfo
+		champions []*model.Champion
+		heroes    []*model.Hero
+	)
+	switch tp {
+	case _lolItems:
+		if rs, count, err = s.leida(params, _lolItems); err == nil {
+			if err = json.Unmarshal(rs, &items); err == nil {
+				for _, item := range items {
+					s.lolItemsMap.Lock()
+					s.lolItemsMap.Data[item.ID] = item
+					s.lolItemsMap.Unlock()
+				}
+			}
+		}
+	case _dotaItems:
+		if rs, count, err = s.leida(params, _dotaItems); err == nil {
+			if err = json.Unmarshal(rs, &items); err == nil {
+				for _, item := range items {
+					s.dotaItemsMap.Lock()
+					s.dotaItemsMap.Data[item.ID] = item
+					s.dotaItemsMap.Unlock()
+				}
+			}
+		}
+	case _lolSpells:
+		if rs, count, err = s.leida(params, _lolSpells); err == nil {
+			if err = json.Unmarshal(rs, &infos); err == nil {
+				for _, info := range infos {
+					s.lolSpells.Lock()
+					s.lolSpells.Data[info.ID] = info
+					s.lolSpells.Unlock()
+				}
+			}
+		}
+	case _dotaAbilities:
+		if rs, count, err = s.leida(params, _dotaAbilities); err == nil {
+			if err = json.Unmarshal(rs, &infos); err == nil {
+				for _, info := range infos {
+					s.dotaAbilities.Lock()
+					s.dotaAbilities.Data[info.ID] = info
+					s.dotaAbilities.Unlock()
+				}
+			}
+		}
+	case _lolPlayers:
+		if rs, count, err = s.leida(params, _lolPlayers); err == nil {
+			if err = json.Unmarshal(rs, &infos); err == nil {
+				for _, info := range infos {
+					s.lolPlayers.Lock()
+					s.lolPlayers.Data[info.ID] = info
+					s.lolPlayers.Unlock()
+				}
+			}
+		}
+	case _dotaPlayers:
+		if rs, count, err = s.leida(params, _dotaPlayers); err == nil {
+			if err = json.Unmarshal(rs, &infos); err == nil {
+				for _, info := range infos {
+					s.dotaPlayers.Lock()
+					s.dotaPlayers.Data[info.ID] = info
+					s.dotaPlayers.Unlock()
+				}
+			}
+		}
+	case _lolChampions:
+		if rs, count, err = s.leida(params, _lolChampions); err == nil {
+			if err = json.Unmarshal(rs, &champions); err == nil {
+				for _, champion := range champions {
+					s.lolChampions.Lock()
+					s.lolChampions.Data[champion.ID] = champion
+					s.lolChampions.Unlock()
+				}
+			}
+		}
+	case _lolHeroes:
+		if rs, count, err = s.leida(params, _lolHeroes); err == nil {
+			if err = json.Unmarshal(rs, &heroes); err == nil {
+				for _, hero := range heroes {
+					s.dotaHeroes.Lock()
+					s.dotaHeroes.Data[hero.ID] = hero
+					s.dotaHeroes.Unlock()
+				}
+			}
+		}
+	}
+	return
+}
+
+func (s *Service) leida(params url.Values, route string) (rs []byte, count int, err error) {
+	var body, orginBody []byte
+	params.Del("route")
+	params.Set("key", s.c.Leidata.Key)
+	url := s.c.Leidata.URL + "/" + route + "?" + params.Encode()
+	for i := 0; i < s.c.Leidata.Retry; i++ {
+		if body, err = s.dao.Leida(context.Background(), url); err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+		bodyStr := string(body[:])
+		if bodyStr == "" {
+			time.Sleep(time.Second)
+			continue
+		}
+		rsPos := strings.Index(bodyStr, "[")
+		if rsPos > -1 {
+			orginBody = body
+			body = []byte(bodyStr[rsPos:])
+		} else {
+			time.Sleep(time.Second)
+			continue
+		}
+		rs = body
+		totalPos := strings.Index(bodyStr, "X-Total:")
+		if totalPos > 0 {
+			s := string(orginBody[totalPos+9 : rsPos-4])
+			if t, e := strconv.ParseFloat(s, 64); e == nil {
+				count = int(math.Ceil(t / float64(_perPage)))
+			}
+		}
+		break
+	}
+	if err != nil {
+		log.Error("json.Unmarshal url(%s) body(%s) error(%v)", url, string(body), err)
+	}
+	return
+}

app/interface/main/esports/service/service_test.go

@@ -0,0 +1,28 @@
+package service
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/interface/main/esports/conf"
+)
+
+var (
+	svr *Service
+)
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/esports-test.toml")
+	flag.Set("conf", dir)
+	conf.Init()
+	svr = New(conf.Conf)
+	time.Sleep(time.Second)
+
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		f(svr)
+	}
+}