Create & Init Project...

app/interface/main/web-goblin/service/share/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "share.go",
+    ],
+    importpath = "go-common/app/interface/main/web-goblin/service/share",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/web-goblin/conf:go_default_library",
+        "//app/interface/main/web-goblin/dao/share:go_default_library",
+        "//app/interface/main/web-goblin/model/share:go_default_library",
+        "//app/service/main/account/model:go_default_library",
+        "//app/service/main/account/rpc/client:go_default_library",
+        "//app/service/main/usersuit/model:go_default_library",
+        "//app/service/main/usersuit/rpc/client:go_default_library",
+        "//library/cache:go_default_library",
+        "//library/log:go_default_library",
+        "//library/sync/errgroup: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/web-goblin/service/share/service.go

@@ -0,0 +1,45 @@
+package share
+
+import (
+	"context"
+
+	"go-common/app/interface/main/web-goblin/conf"
+	"go-common/app/interface/main/web-goblin/dao/share"
+	accrpc "go-common/app/service/main/account/rpc/client"
+	suitrpc "go-common/app/service/main/usersuit/rpc/client"
+	"go-common/library/cache"
+	"go-common/library/log"
+)
+
+// Service service struct.
+type Service struct {
+	c   *conf.Config
+	dao *share.Dao
+	// cache proc
+	cache    *cache.Cache
+	suit     *suitrpc.Service2
+	accRPC   *accrpc.Service3
+	Pendants map[int64]int64
+}
+
+// New new service.
+func New(c *conf.Config) *Service {
+	s := &Service{
+		c:        c,
+		dao:      share.New(c),
+		cache:    cache.New(1, 1024),
+		suit:     suitrpc.New(c.SuitRPC),
+		accRPC:   accrpc.New3(c.AccountRPC),
+		Pendants: make(map[int64]int64),
+	}
+	s.loadPendant()
+	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
+}

app/interface/main/web-goblin/service/share/share.go

@@ -0,0 +1,98 @@
+package share
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	shamdl "go-common/app/interface/main/web-goblin/model/share"
+	accmdl "go-common/app/service/main/account/model"
+	suitmdl "go-common/app/service/main/usersuit/model"
+	"go-common/library/log"
+	"go-common/library/sync/errgroup"
+)
+
+// Encourage  share encourage.
+func (s *Service) Encourage(c context.Context, mid int64) (res *shamdl.Encourage, err error) {
+	var (
+		mcShare map[string]int64
+		shares  []*shamdl.Share
+		key     string
+		info    *accmdl.Info
+		gps     []*suitmdl.GroupPendantList
+		shaPend []*shamdl.GroupPendant
+		group   = errgroup.Group{}
+	)
+	group.Go(func() (e error) {
+		if info, e = s.accRPC.Info3(context.Background(), &accmdl.ArgMid{Mid: mid}); e != nil {
+			log.Error("s.accRPC.Info mid(%d) error(%v)", mid, e)
+		}
+		return
+	})
+	group.Go(func() (e error) {
+		if mcShare, e = s.dao.SharesCache(context.Background(), mid); e != nil {
+			log.Error("s.dao.SharesCache mid(%d) error(%v)", mid, e)
+			if shares, e = s.dao.Shares(context.Background(), mid); e != nil {
+				log.Error("s.dao.Shares mid(%d) error(%v)", mid, e)
+				return
+			}
+			count := len(shares)
+			if count > 0 {
+				mcShare = make(map[string]int64, count)
+				for _, share := range shares {
+					key = strconv.FormatInt(share.ShareDate, 10)
+					mcShare[key] = share.DayCount
+				}
+				s.cache.Save(func() {
+					expire := monthShare()
+					s.dao.SetSharesCache(context.Background(), expire, mid, mcShare)
+				})
+			}
+		}
+		return
+	})
+	group.Go(func() (e error) {
+		if gps, e = s.suit.GroupPendantMid(context.Background(), &suitmdl.ArgGPMID{MID: mid, GID: s.c.Rule.Gid}); e != nil {
+			log.Error("s.suit.GroupPendantMid  mid(%d) error(%v)", mid, e)
+		}
+		return
+	})
+	group.Wait()
+	res = new(shamdl.Encourage)
+	if len(gps) > 0 {
+		for _, gp := range gps {
+			shaPend = append(shaPend, &shamdl.GroupPendant{NeedDays: s.Pendants[gp.ID], Pendant: gp})
+		}
+	}
+	if info == nil || info.Mid == 0 {
+		res.UserInfo = struct{}{}
+	} else {
+		res.UserInfo = info
+	}
+	days := int64(len(mcShare))
+	if days > 0 {
+		res.TodayShare = mcShare[time.Now().Format("20060102")]
+		res.ShareDays = int64(days)
+	}
+	if len(shaPend) == 0 {
+		res.Pendants = struct{}{}
+	} else {
+		res.Pendants = shaPend
+	}
+	return
+}
+
+func monthShare() int {
+	now := time.Now()
+	currentYear, currentMonth, _ := now.Date()
+	currentLocation := now.Location()
+	firstOfMonth := time.Date(currentYear, currentMonth, 1, 23, 59, 59, 0, currentLocation)
+	lastOfMonth := firstOfMonth.AddDate(0, 1, -1)
+	return int(lastOfMonth.Sub(now).Seconds())
+}
+
+func (s *Service) loadPendant() {
+	for _, p := range s.c.Pendants {
+		s.Pendants[p.Pid] = p.Level
+	}
+}

app/interface/main/web-goblin/service/web/BUILD

@@ -0,0 +1,70 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "full_test.go",
+        "pgc_test.go",
+        "recruit_test.go",
+        "service_test.go",
+        "ugc_test.go",
+    ],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/web-goblin/conf:go_default_library",
+        "//app/interface/main/web-goblin/model/web:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "channel.go",
+        "full.go",
+        "pgc.go",
+        "recruit.go",
+        "service.go",
+        "ugc.go",
+    ],
+    importpath = "go-common/app/interface/main/web-goblin/service/web",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/tag/model:go_default_library",
+        "//app/interface/main/tag/rpc/client:go_default_library",
+        "//app/interface/main/web-goblin/conf:go_default_library",
+        "//app/interface/main/web-goblin/dao/web:go_default_library",
+        "//app/interface/main/web-goblin/model/web:go_default_library",
+        "//app/service/main/archive/api:go_default_library",
+        "//app/service/main/archive/api/gorpc:go_default_library",
+        "//app/service/main/archive/model/archive: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/xstr: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/web-goblin/service/web/channel.go

@@ -0,0 +1,86 @@
+package web
+
+import (
+	"context"
+
+	tagmdl "go-common/app/interface/main/tag/model"
+	"go-common/app/interface/main/web-goblin/model/web"
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+)
+
+const (
+	_chRqCnt     = 40
+	_chDisplayID = 1
+	_chTypeArc   = 3
+	_chFrom      = 1
+)
+
+var _emptyArcs = make([]*api.Arc, 0)
+
+// Channel .
+func (s *Service) Channel(c context.Context, id, mid int64, buvid string) (channel *web.Channel, err error) {
+	var (
+		aids   []int64
+		arcs   map[int64]*api.Arc
+		tagErr error
+	)
+	ip := metadata.String(c, metadata.RemoteIP)
+	channel = new(web.Channel)
+	if cards, ok := s.channelCards[id]; ok {
+		for _, card := range cards {
+			aids = append(aids, card.Value)
+		}
+	}
+	group, errCtx := errgroup.WithContext(c)
+	group.Go(func() error {
+		arg := &tagmdl.ArgChannelResource{
+			Tid:        id,
+			Mid:        mid,
+			RequestCNT: int32(_chRqCnt),
+			DisplayID:  _chDisplayID,
+			Type:       _chTypeArc,
+			Buvid:      buvid,
+			From:       _chFrom,
+			RealIP:     ip,
+		}
+		if channelResource, chErr := s.tag.ChannelResources(errCtx, arg); chErr != nil {
+			log.Error("Channel s.tag.Resources error(%v)", chErr)
+		} else if channelResource != nil {
+			aids = append(aids, channelResource.Oids...)
+		}
+		return nil
+	})
+	group.Go(func() error {
+		if channel.Tag, tagErr = s.tag.InfoByID(errCtx, &tagmdl.ArgID{ID: id, Mid: mid}); tagErr != nil {
+			log.Error("Channel s.tag.InfoByID(%d, %d) error(%v)", id, mid, err)
+			return tagErr
+		}
+		return nil
+	})
+	if err = group.Wait(); err != nil {
+		return
+	}
+	if len(aids) == 0 {
+		channel.Archives = _emptyArcs
+		return
+	}
+	if arcs, err = s.arc.Archives3(c, &archive.ArgAids2{Aids: aids, RealIP: ip}); err != nil {
+		log.Error("Channel s.arc.Archives3(%v) error(%v)", aids, err)
+		err = nil
+		channel.Archives = _emptyArcs
+		return
+	}
+	for _, aid := range aids {
+		if arc, ok := arcs[aid]; ok && arc.IsNormal() {
+			channel.Archives = append(channel.Archives, arc)
+		}
+	}
+	if len(channel.Archives) > _chRqCnt {
+		channel.Archives = channel.Archives[:_chRqCnt]
+	}
+	return
+}

app/interface/main/web-goblin/service/web/full.go

@@ -0,0 +1,164 @@
+package web
+
+import (
+	"context"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	tagmdl "go-common/app/interface/main/tag/model"
+	"go-common/app/interface/main/web-goblin/dao/web"
+	webmdl "go-common/app/interface/main/web-goblin/model/web"
+	"go-common/app/service/main/archive/api"
+	"go-common/app/service/main/archive/model/archive"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/sync/errgroup"
+)
+
+var (
+	_emptyMiArc = make([]*webmdl.Mi, 0)
+)
+
+const (
+	_tagBlkSize = 50
+	_tagArcType = 3
+)
+
+// FullShort  xiao mi  FullShort .
+func (s *Service) FullShort(c context.Context, pn, ps int64, source string) (res []*webmdl.Mi, err error) {
+	var (
+		aids []int64
+		ip   = metadata.String(c, metadata.RemoteIP)
+		m    = make(map[int64]string)
+	)
+	if aids, err = s.aids(c, pn, ps); err != nil {
+		return
+	}
+	if res, err = s.archiveWithTag(c, aids, ip, m, source); err != nil {
+		log.Error("s.archiveWithTag  error(%v)", err)
+	}
+	return
+}
+
+func (s *Service) archiveWithTag(c context.Context, aids []int64, ip string, op map[int64]string, source string) (list []*webmdl.Mi, err error) {
+	var (
+		arcErr, tagErr error
+		archives       map[int64]*api.Arc
+		pages          []*api.Page
+		pageInfo       map[int64][]*api.Page
+		tags           map[int64][]*tagmdl.Tag
+		mutex          = sync.Mutex{}
+		tempTags       []string
+	)
+	group := new(errgroup.Group)
+	group.Go(func() error {
+		if archives, arcErr = s.arc.Archives3(context.Background(), &archive.ArgAids2{Aids: aids, RealIP: ip}); arcErr != nil {
+			web.PromError("Archives3接口错误", "s.arc.Archives3(%d,%s) error %v", aids, ip, err)
+			return arcErr
+		}
+		return nil
+	})
+	pageInfo = make(map[int64][]*api.Page)
+	for _, aid := range aids {
+		group.Go(func() error {
+			pages = []*api.Page{}
+			if pages, err = s.arc.Page3(context.Background(), &archive.ArgAid2{Aid: aid, RealIP: ip}); err != nil {
+				log.Error("s.arc.Page3 error(%v)", err)
+				return err
+			}
+			mutex.Lock()
+			pageInfo[aid] = pages
+			mutex.Unlock()
+			return nil
+		})
+	}
+	aidsLen := len(aids)
+	tags = make(map[int64][]*tagmdl.Tag, aidsLen)
+	for i := 0; i < aidsLen; i += _tagBlkSize {
+		var partAids []int64
+		if i+_tagBlkSize > aidsLen {
+			partAids = aids[i:]
+		} else {
+			partAids = aids[i : i+_tagBlkSize]
+		}
+		group.Go(func() (err error) {
+			var tmpRes map[int64][]*tagmdl.Tag
+			arg := &tagmdl.ArgResTags{Oids: partAids, Type: _tagArcType, RealIP: ip}
+			if tmpRes, tagErr = s.tag.ResTags(context.Background(), arg); tagErr != nil {
+				web.PromError("ResTags接口错误", "s.tag.ResTag(%+v) error(%v)", arg, tagErr)
+				return
+			}
+			mutex.Lock()
+			for aid, tmpTags := range tmpRes {
+				tags[aid] = tmpTags
+			}
+			mutex.Unlock()
+			return nil
+		})
+	}
+	if err = group.Wait(); err != nil {
+		return
+	}
+	for _, aid := range aids {
+		if arc, ok := archives[aid]; ok && arc.IsNormal() {
+			miArc := new(webmdl.Mi)
+			tempTags = []string{}
+			miArc.FromArchive(arc, pageInfo[aid], op[aid], source)
+			if tag, ok := tags[aid]; ok {
+				for _, v := range tag {
+					tempTags = append(tempTags, v.Name)
+				}
+			}
+			if len(tempTags) == 0 {
+				miArc.Tags = ""
+			} else {
+				miArc.Tags = strings.Join(tempTags, ",")
+			}
+			list = append(list, miArc)
+		}
+	}
+	if len(list) == 0 {
+		list = _emptyMiArc
+	}
+	return
+}
+
+func (s *Service) aids(c context.Context, pn, ps int64) (res []int64, err error) {
+	var start, end int64
+	if pn > 1 {
+		start = pn*ps + 1
+	} else {
+		start = 1
+	}
+	end = start + ps
+	if s.maxAid > 0 && end > s.maxAid {
+		log.Warn("aids(%d,%d) maxAid(%d)", pn, ps, s.maxAid)
+		err = ecode.RequestErr
+		return
+	}
+	for i := start; i < end; i++ {
+		res = append(res, i)
+	}
+	return
+}
+
+func (s *Service) justAID() {
+	var (
+		maxAid int64
+		err    error
+	)
+	for {
+		if maxAid, err = s.arc.MaxAID(context.Background()); err != nil {
+			web.PromError("MaxAID接口错误", "s.arc.MaxAID error(%v)", err)
+			time.Sleep(time.Second)
+			continue
+		}
+		if maxAid > 0 {
+			atomic.StoreInt64(&s.maxAid, maxAid+100)
+		}
+		time.Sleep(time.Minute)
+	}
+}

app/interface/main/web-goblin/service/web/full_test.go

@@ -0,0 +1,20 @@
+package web
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Full(t *testing.T) {
+	Convey("test Full", t, WithService(func(s *Service) {
+		var (
+			pn int64 = 1
+			ps int64 = 10
+		)
+		res, err := s.FullShort(context.Background(), pn, ps, "")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	}))
+}

app/interface/main/web-goblin/service/web/pgc.go

@@ -0,0 +1,23 @@
+package web
+
+import (
+	"context"
+
+	"go-common/library/log"
+)
+
+// PgcFull pgc full .
+func (s *Service) PgcFull(ctx context.Context, tp int, pn, ps int64, source string) (res interface{}, err error) {
+	if res, err = s.dao.PgcFull(ctx, tp, pn, ps, source); err != nil {
+		log.Error("s.dao.PgcFull error(%v)", err)
+	}
+	return
+}
+
+// PgcIncre pgc incre .
+func (s *Service) PgcIncre(ctx context.Context, tp int, pn, ps, start, end int64, source string) (res interface{}, err error) {
+	if res, err = s.dao.PgcIncre(ctx, tp, pn, ps, start, end, source); err != nil {
+		log.Error("s.dao.PgcIncre error(%s)", err)
+	}
+	return
+}

app/interface/main/web-goblin/service/web/pgc_test.go

@@ -0,0 +1,40 @@
+package web
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_PgcFull(t *testing.T) {
+	Convey("pgc full", t, WithService(func(s *Service) {
+		var (
+			c      = context.Background()
+			tp     = int(2)
+			pn     = int64(1)
+			ps     = int64(10)
+			source = "youku"
+		)
+		res, err := s.PgcFull(c, tp, pn, ps, source)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	}))
+}
+
+func TestService_PgcIncre(t *testing.T) {
+	Convey("pgc incre", t, WithService(func(s *Service) {
+		var (
+			c      = context.Background()
+			tp     = int(2)
+			pn     = int64(1)
+			ps     = int64(10)
+			start  = int64(1505876448)
+			end    = int64(1505876450)
+			source = "youku"
+		)
+		res, err := s.PgcIncre(c, tp, pn, ps, start, end, source)
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	}))
+}

app/interface/main/web-goblin/service/web/recruit.go

@@ -0,0 +1,18 @@
+package web
+
+import (
+	"context"
+	"encoding/json"
+	"net/url"
+
+	"go-common/app/interface/main/web-goblin/model/web"
+	"go-common/library/log"
+)
+
+// Recruit .
+func (s *Service) Recruit(ctx context.Context, param url.Values, route *web.Params) (res json.RawMessage, err error) {
+	if res, err = s.dao.Recruit(ctx, param, route); err != nil {
+		log.Error("s.dao.Recruit route(%s) error(%v)", route.Route, err)
+	}
+	return
+}

app/interface/main/web-goblin/service/web/recruit_test.go

@@ -0,0 +1,27 @@
+package web
+
+import (
+	"context"
+	"net/url"
+	"testing"
+
+	"go-common/app/interface/main/web-goblin/model/web"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_Recruit(t *testing.T) {
+	Convey("test recruit", t, WithService(func(s *Service) {
+		var (
+			ctx   = context.Background()
+			param = url.Values{}
+			ru    = &web.Params{
+				Route: "v1/jobs",
+			}
+		)
+		param.Set("mode", "social")
+		res, err := s.Recruit(ctx, param, ru)
+		So(len(res), ShouldBeGreaterThan)
+		So(err, ShouldBeNil)
+	}))
+}

app/interface/main/web-goblin/service/web/service.go

@@ -0,0 +1,74 @@
+package web
+
+import (
+	"context"
+	"time"
+
+	tagrpc "go-common/app/interface/main/tag/rpc/client"
+	"go-common/app/interface/main/web-goblin/conf"
+	"go-common/app/interface/main/web-goblin/dao/web"
+	webmdl "go-common/app/interface/main/web-goblin/model/web"
+	arcrpc "go-common/app/service/main/archive/api/gorpc"
+	"go-common/library/log"
+)
+
+const _chCardTypeAv = "av"
+
+// Service struct .
+type Service struct {
+	c            *conf.Config
+	dao          *web.Dao
+	arc          *arcrpc.Service2
+	tag          *tagrpc.Service
+	maxAid       int64
+	channelCards map[int64][]*webmdl.ChCard
+}
+
+// New init .
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: web.New(c),
+		arc: arcrpc.New2(c.ArchiveRPC),
+		tag: tagrpc.New2(c.TagRPC),
+	}
+	go s.justAID()
+	go s.chCardproc()
+	return s
+}
+
+// Ping Service .
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.dao.Ping(c)
+}
+
+// Close Service .
+func (s *Service) Close() {
+	s.dao.Close()
+}
+
+func (s *Service) chCardproc() {
+	for {
+		now := time.Now()
+		cardMap, err := s.dao.ChCard(context.Background(), now)
+		if err != nil {
+			log.Error("chCardproc s.dao.ChCard() error(%v)", err)
+			time.Sleep(time.Second)
+		}
+		l := len(cardMap)
+		if l == 0 {
+			time.Sleep(time.Duration(s.c.Rule.ChCardInterval))
+			continue
+		}
+		tmp := make(map[int64][]*webmdl.ChCard, l)
+		for channelID, card := range cardMap {
+			for _, v := range card {
+				if v.Type == _chCardTypeAv {
+					tmp[channelID] = append(tmp[channelID], v)
+				}
+			}
+		}
+		s.channelCards = tmp
+		time.Sleep(time.Duration(s.c.Rule.ChCardInterval))
+	}
+}

app/interface/main/web-goblin/service/web/service_test.go

@@ -0,0 +1,29 @@
+package web
+
+import (
+	"flag"
+	"path/filepath"
+	"time"
+
+	"go-common/app/interface/main/web-goblin/conf"
+)
+
+var svf *Service
+
+func init() {
+	dir, _ := filepath.Abs("../cmd/web-goblin-test.toml")
+	flag.Set("conf", dir)
+	if err := conf.Init(); err != nil {
+		panic(err)
+	}
+	if svf == nil {
+		svf = New(conf.Conf)
+	}
+	time.Sleep(time.Second)
+}
+
+func WithService(f func(s *Service)) func() {
+	return func() {
+		f(svf)
+	}
+}

app/interface/main/web-goblin/service/web/ugc.go

@@ -0,0 +1,67 @@
+package web
+
+import (
+	"context"
+
+	webmdl "go-common/app/interface/main/web-goblin/model/web"
+	"go-common/library/log"
+	"go-common/library/net/metadata"
+	"go-common/library/xstr"
+)
+
+const (
+	_del = "del"
+)
+
+// UgcFull search all ugc .
+func (s *Service) UgcFull(ctx context.Context, pn, ps int64, source string) (res []*webmdl.Mi, err error) {
+	if res, err = s.FullShort(ctx, pn, ps, source); err != nil {
+		log.Error("UgcFull error (%v)", err)
+		return
+	}
+	if len(res) > 0 {
+		for idx := range res {
+			res[idx].UgcFullDeal()
+		}
+	}
+	return
+}
+
+// UgcIncre search ugc after a certain time .
+func (s *Service) UgcIncre(ctx context.Context, pn, ps int, start, end int64, source string) (res []*webmdl.Mi, err error) {
+	var (
+		aids    []*webmdl.SearchAids
+		opmap   map[int64]string
+		delaids []int64
+		tmpAids []int64
+		ip      = metadata.String(ctx, metadata.RemoteIP)
+	)
+	if aids, err = s.dao.UgcIncre(ctx, pn, ps, start, end); err != nil {
+		log.Error("s.dao.UgcIncre error (%v)", err)
+		return
+	}
+	opmap = make(map[int64]string, len(aids))
+	for _, v := range aids {
+		opmap[v.Aid] = v.Action
+		if v.Action == _del {
+			delaids = append(delaids, v.Aid)
+		} else {
+			tmpAids = append(tmpAids, v.Aid)
+		}
+	}
+	if res, err = s.archiveWithTag(ctx, tmpAids, ip, opmap, source); err != nil {
+		log.Warn("s.archiveWithTag ip(%s) aids(%s) error(%v)", err, ip, xstr.JoinInts(tmpAids))
+	}
+	for _, v := range delaids {
+		m := &webmdl.Mi{}
+		m.Op = _del
+		m.ID = v
+		res = append(res, m)
+	}
+	if len(res) > 0 {
+		for idx := range res {
+			res[idx].UgcIncreDeal()
+		}
+	}
+	return
+}

app/interface/main/web-goblin/service/web/ugc_test.go

@@ -0,0 +1,36 @@
+package web
+
+import (
+	"context"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestService_UgcFull(t *testing.T) {
+	Convey("ugc full", t, WithService(func(s *Service) {
+		var (
+			c  = context.Background()
+			pn = int64(1)
+			ps = int64(10)
+		)
+		res, err := s.UgcFull(c, pn, ps, "")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	}))
+}
+
+func TestService_UgcIncre(t *testing.T) {
+	Convey("pgc incre", t, WithService(func(s *Service) {
+		var (
+			c     = context.Background()
+			pn    = 1
+			ps    = 10
+			start = int64(1505876448)
+			end   = int64(1505876450)
+		)
+		res, err := s.UgcIncre(c, pn, ps, start, end, "")
+		So(err, ShouldBeNil)
+		So(res, ShouldNotBeNil)
+	}))
+}

app/interface/main/web-goblin/service/wechat/BUILD

@@ -0,0 +1,37 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "service.go",
+        "wechat.go",
+    ],
+    importpath = "go-common/app/interface/main/web-goblin/service/wechat",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/interface/main/web-goblin/conf:go_default_library",
+        "//app/interface/main/web-goblin/dao/wechat:go_default_library",
+        "//app/interface/main/web-goblin/model/wechat:go_default_library",
+        "//library/log: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/web-goblin/service/wechat/service.go

@@ -0,0 +1,21 @@
+package wechat
+
+import (
+	"go-common/app/interface/main/web-goblin/conf"
+	"go-common/app/interface/main/web-goblin/dao/wechat"
+)
+
+// Service struct .
+type Service struct {
+	c   *conf.Config
+	dao *wechat.Dao
+}
+
+// New init wechat service.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:   c,
+		dao: wechat.New(c),
+	}
+	return s
+}

app/interface/main/web-goblin/service/wechat/wechat.go

@@ -0,0 +1,19 @@
+package wechat
+
+import (
+	"context"
+
+	"go-common/app/interface/main/web-goblin/model/wechat"
+	"go-common/library/log"
+)
+
+// Qrcode get qrcode from wechat.
+func (s *Service) Qrcode(c context.Context, arg string) (qrcode []byte, err error) {
+	var accessToken *wechat.AccessToken
+	if accessToken, err = s.dao.AccessToken(c); err != nil {
+		log.Error("Qrcode s.dao.AccessToken error(%v) arg(%s)", err, arg)
+		return
+	}
+	qrcode, err = s.dao.Qrcode(c, accessToken.AccessToken, arg)
+	return
+}