You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
375 lines
9.5 KiB
375 lines
9.5 KiB
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 |
|
}
|
|
|