Create & Init Project...

app/interface/main/activity/service/bnj/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bnj.go",
+        "service.go",
+    ],
+    importpath = "go-common/app/interface/main/activity/service/bnj",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/activity/conf:go_default_library",
+        "//app/interface/main/activity/dao/bnj:go_default_library",
+        "//app/interface/main/activity/dao/like:go_default_library",
+        "//app/interface/main/activity/model/bnj:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/sync/errgroup.v2: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/activity/service/bnj/bnj.go

@@ -0,0 +1,158 @@
+package bnj
+
+import (
+	"context"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"go-common/library/sync/errgroup.v2"
+
+	"go-common/app/interface/main/activity/model/bnj"
+	arcmdl "go-common/app/service/main/archive/api"
+	"go-common/library/ecode"
+	"go-common/library/log"
+)
+
+const (
+	_rewardStepOne   = 1
+	_rewardStepThree = 3
+	_lastCD          = 300
+)
+
+// PreviewInfo preview info
+func (s *Service) PreviewInfo(c context.Context, mid int64) *bnj.PreviewInfo {
+	data := &bnj.PreviewInfo{
+		ActID: s.c.Bnj2019.ActID,
+		SubID: s.c.Bnj2019.SubID,
+	}
+	// TODO del admin check
+	if err := s.bnjAdminCheck(mid); err != nil {
+		return data
+	}
+	for _, v := range s.c.Bnj2019.Reward {
+		data.RewardStep = append(data.RewardStep, v.Condition)
+	}
+	if s.timeFinish != 0 {
+		data.TimelinePic = s.c.Bnj2019.TimelinePic
+		data.H5TimelinePic = s.c.Bnj2019.H5TimelinePic
+	}
+	if s.c.Bnj2019.GameCancel != 0 {
+		data.GameCancel = 1
+	}
+	now := time.Now().Unix()
+	group := errgroup.WithCancel(c)
+	if mid > 0 && len(s.c.Bnj2019.Reward) > 0 {
+		for _, v := range s.c.Bnj2019.Reward {
+			if v.Step > 0 {
+				step := v.Step
+				group.Go(func(ctx context.Context) error {
+					if check, e := s.dao.HasReward(ctx, mid, s.c.Bnj2019.SubID, step); e != nil {
+						log.Error("Reward s.dao.HasReward(mid:%d,step:%d) error(%v) check(%v)", mid, step, e, check)
+					} else if check {
+						switch step {
+						case _rewardStepOne:
+							data.HasRewardFirst = 1
+						case _rewardStepThree:
+							data.HasRewardSecond = 1
+						}
+					}
+					return nil
+				})
+			}
+		}
+	}
+	if err := group.Wait(); err != nil {
+		log.Error("PreviewInfo group wait error(%v)", err)
+	}
+	arcs := s.previewArcs
+	for _, v := range s.c.Bnj2019.Info {
+		if v.Publish.Unix() < now {
+			if arc, ok := arcs[v.Aid]; ok && arc.IsNormal() {
+				tmp := &bnj.Info{Nav: v.Nav, Pic: v.Pic, H5Pic: v.H5Pic, Detail: v.Detail, H5Detail: v.H5Detail, Arc: &arcmdl.Arc{Aid: v.Aid}}
+				arc.Pic = strings.Replace(arc.Pic, "http://", "//", 1)
+				if v.Nickname != "" {
+					arc.Author.Name = arc.Author.Name + "&" + v.Nickname
+				}
+				tmp.Arc = arc
+				data.Info = append(data.Info, tmp)
+			}
+		}
+	}
+	if len(data.Info) == 0 {
+		data.Info = make([]*bnj.Info, 0)
+	}
+	return data
+}
+
+// Timeline only return timeline and game cancel.
+func (s *Service) Timeline(c context.Context, mid int64) *bnj.Timeline {
+	data := new(bnj.Timeline)
+	// TODO delete admin check
+	if err := s.bnjAdminCheck(mid); err != nil {
+		return data
+	}
+	if s.timeFinish != 0 {
+		data.TimelinePic = s.c.Bnj2019.TimelinePic
+		data.H5TimelinePic = s.c.Bnj2019.H5TimelinePic
+	}
+	if s.c.Bnj2019.GameCancel != 0 {
+		data.GameCancel = 1
+	}
+	data.LikeCount = s.likeCount
+	return data
+}
+
+// TimeReset reset less time.
+func (s *Service) TimeReset(c context.Context, mid int64) (ttl int64, err error) {
+	if time.Now().Unix() < s.c.Bnj2019.Start.Unix() {
+		err = ecode.ActivityNotStart
+		return
+	}
+	if s.timeFinish != 0 {
+		err = ecode.ActivityBnjTimeFinish
+		return
+	}
+	var value bool
+	if value, err = s.dao.CacheResetCD(c, mid, s.resetCD); err != nil {
+		log.Error("TimeReset s.dao.CacheResetCD(%d) error(%v) value(%v)", mid, err, value)
+		err = nil
+		return
+	}
+	if !value {
+		if ttl, err = s.dao.TTLResetCD(c, mid); err != nil {
+			log.Error("TimeReset s.dao.TTLResetCD(%d) error(%v) value(%v)", mid, err)
+			err = nil
+		}
+		return
+	}
+	if s.timeReset == 0 {
+		atomic.StoreInt64(&s.resetMid, mid)
+		atomic.StoreInt64(&s.timeReset, 1)
+	}
+	return
+}
+
+// DelTime .
+func (s *Service) DelTime(c context.Context, key string) (err error) {
+	switch key {
+	case "time_finish":
+		if err = s.dao.DelCacheTimeFinish(c); err != nil {
+			log.Error("DelTime DelCacheTimeFinish error(%v)", err)
+		}
+	case "time_less":
+		if err = s.dao.DelCacheTimeLess(c); err != nil {
+			log.Error("DelTime DelCacheTimeLess error(%v)", err)
+		}
+	}
+	return
+}
+
+func (s *Service) bnjAdminCheck(mid int64) (err error) {
+	if s.c.Bnj2019.AdminCheck != 0 {
+		if _, ok := s.bnjAdmins[mid]; !ok {
+			err = ecode.AccessDenied
+		}
+	}
+	return
+}

app/interface/main/activity/service/bnj/service.go

@@ -0,0 +1,159 @@
+package bnj
+
+import (
+	"context"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"go-common/app/interface/main/activity/conf"
+	"go-common/app/interface/main/activity/dao/bnj"
+	"go-common/app/interface/main/activity/dao/like"
+	bnjmdl "go-common/app/interface/main/activity/model/bnj"
+	arcclient "go-common/app/service/main/archive/api"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+)
+
+// Service .
+type Service struct {
+	c           *conf.Config
+	arcClient   arcclient.ArchiveClient
+	dao         *bnj.Dao
+	likeDao     *like.Dao
+	resetPub    *databus.Databus
+	previewArcs map[int64]*arcclient.Arc
+	bnjAdmins   map[int64]struct{}
+	likeCount   int64
+	timeReset   int64
+	resetMid    int64
+	timeFinish  int64
+	resetCD     int32
+}
+
+// New init bnj service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:        c,
+		dao:      bnj.New(c),
+		likeDao:  like.New(c),
+		resetPub: databus.New(c.Databus.Bnj),
+	}
+	var err error
+	if s.arcClient, err = arcclient.NewClient(c.ArcClient); err != nil {
+		panic(err)
+	}
+	if s.c.Bnj2019.AdminCheck != 0 {
+		tmp := make(map[int64]struct{}, len(s.c.Bnj2019.Admins))
+		for _, mid := range s.c.Bnj2019.Admins {
+			tmp[mid] = struct{}{}
+		}
+		s.bnjAdmins = tmp
+	}
+	go s.bnjTimeproc()
+	return s
+}
+
+// Close .
+func (s *Service) Close() {
+	s.dao.Close()
+	s.resetPub.Close()
+}
+
+func (s *Service) timeResetproc() {
+	for {
+		time.Sleep(time.Second)
+		if s.timeFinish != 0 {
+			log.Info("timeResetproc finish")
+			break
+		}
+		if s.timeReset == 1 {
+			// sub databus
+			msg := &bnjmdl.ResetMsg{Mid: s.resetMid, Ts: time.Now().Unix()}
+			if err := s.resetPub.Send(context.Background(), strconv.FormatInt(s.resetMid, 10), msg); err != nil {
+				log.Error("timeResetproc s.resetPub.Send(%+v) error(%v)", msg, err)
+			}
+			atomic.StoreInt64(&s.timeReset, 0)
+			atomic.StoreInt64(&s.resetMid, 0)
+		}
+	}
+}
+
+func (s *Service) timeFinishproc() {
+	for {
+		time.Sleep(time.Second)
+		if value, err := s.dao.CacheTimeFinish(context.Background()); err != nil {
+			log.Error("timeFinishproc s.dao.CacheTimeFinish error(%v)")
+		} else if value > 0 {
+			log.Info("timeFinishproc cache value finish")
+			atomic.StoreInt64(&s.timeFinish, value)
+		}
+	}
+}
+
+func (s *Service) bnjTimeproc() {
+	for {
+		time.Sleep(time.Second)
+		if time.Now().Unix() > s.c.Bnj2019.Start.Unix() {
+			go s.timeResetproc()
+			go s.timeFinishproc()
+			go s.bnjResetCDproc()
+			go s.bnjArcproc()
+			log.Info("bnjTimeproc start")
+			break
+		}
+	}
+}
+
+func (s *Service) bnjResetCDproc() {
+	for {
+		time.Sleep(time.Second)
+		lid := s.c.Bnj2019.SubID
+		scoreMap, err := s.likeDao.LikeActLidCounts(context.Background(), []int64{lid})
+		if err != nil || scoreMap == nil {
+			log.Error("bnjScoreproc s.likeDao.LikeActLidCounts(%d) error(%v)", lid, err)
+			continue
+		}
+		if score, ok := scoreMap[lid]; ok {
+			if score >= s.c.Bnj2019.Reward[len(s.c.Bnj2019.Reward)-1].Condition && s.resetCD != _lastCD {
+				atomic.StoreInt32(&s.resetCD, _lastCD)
+				log.Info("bnjResetCDproc finish")
+			}
+			if score > s.likeCount {
+				atomic.StoreInt64(&s.likeCount, score)
+			}
+		}
+	}
+}
+
+func (s *Service) bnjArcproc() {
+	for {
+		time.Sleep(time.Second)
+		now := time.Now().Unix()
+		var aids []int64
+		for _, v := range s.c.Bnj2019.Info {
+			if v.Publish.Unix() < now {
+				if v.Aid > 0 {
+					aids = append(aids, v.Aid)
+				}
+			}
+		}
+		if len(aids) > 0 {
+			if arcsReply, err := s.arcClient.Arcs(context.Background(), &arcclient.ArcsRequest{Aids: aids}); err != nil {
+				log.Error("bnjArcproc s.arcClient.Arcs(%v) error(%v)", aids, err)
+			} else if len(arcsReply.Arcs) > 0 {
+				tmp := make(map[int64]*arcclient.Arc, len(aids))
+				for _, aid := range aids {
+					if arc, ok := arcsReply.Arcs[aid]; ok && arc != nil {
+						tmp[aid] = arc
+					} else {
+						log.Error("bnjArcproc aid(%d) data(%v)", aid, arc)
+						continue
+					}
+				}
+				s.previewArcs = tmp
+			}
+		}
+		log.Error("bnjArcproc aids(%v) conf error", aids)
+	}
+}